diff --git a/bench/pool_call_many_bench.exs b/bench/pool_call_many_bench.exs
new file mode 100644
index 0000000..f6190ae
--- /dev/null
+++ b/bench/pool_call_many_bench.exs
@@ -0,0 +1,89 @@
+# Benchmark: Pool.call_many vs repeated Pool.call
+#
+# Demonstrates the overhead savings from batching multiple function calls
+# into a single checkout/checkin cycle.
+#
+# Run: mix run bench/pool_call_many_bench.exs
+
+math_wasm = "fixtures/math.wasm"
+{:ok, pool} = Firebird.Pool.start_link(wasm: math_wasm, size: 4)
+
+# Build call lists of various sizes
+calls_5 = for i <- 1..5, do: {:add, [i, i]}
+calls_20 = for i <- 1..20, do: {:add, [i, i]}
+calls_100 = for i <- 1..100, do: {:add, [i, i]}
+
+defmodule BenchHelper do
+  def repeated_calls(pool, calls) do
+    Enum.map(calls, fn {func, args} ->
+      {:ok, result} = Firebird.Pool.call(pool, func, args)
+      result
+    end)
+  end
+end
+
+IO.puts("=" |> String.duplicate(70))
+IO.puts("Pool.call_many vs repeated Pool.call benchmark")
+IO.puts("=" |> String.duplicate(70))
+
+for {label, calls} <- [{"5 calls", calls_5}, {"20 calls", calls_20}, {"100 calls", calls_100}] do
+  IO.puts("\n--- #{label} ---")
+
+  # Warmup
+  for _ <- 1..10 do
+    {:ok, _} = Firebird.Pool.call_many(pool, calls)
+    BenchHelper.repeated_calls(pool, calls)
+  end
+
+  iterations = 200
+
+  # Benchmark call_many
+  many_times = for _ <- 1..iterations do
+    {time, {:ok, _results}} = :timer.tc(fn -> Firebird.Pool.call_many(pool, calls) end)
+    time
+  end
+
+  # Benchmark repeated call
+  repeat_times = for _ <- 1..iterations do
+    {time, _results} = :timer.tc(fn -> BenchHelper.repeated_calls(pool, calls) end)
+    time
+  end
+
+  many_avg = Enum.sum(many_times) / iterations
+  repeat_avg = Enum.sum(repeat_times) / iterations
+  speedup = repeat_avg / max(many_avg, 0.1)
+
+  many_p50 = Enum.sort(many_times) |> Enum.at(div(iterations, 2))
+  repeat_p50 = Enum.sort(repeat_times) |> Enum.at(div(iterations, 2))
+
+  IO.puts("  call_many:      avg=#{Float.round(many_avg, 1)}μs  p50=#{many_p50}μs")
+  IO.puts("  repeated call:  avg=#{Float.round(repeat_avg, 1)}μs  p50=#{repeat_p50}μs")
+  IO.puts("  speedup:        #{Float.round(speedup, 2)}x faster with call_many")
+end
+
+# Also benchmark against pure Elixir equivalent
+IO.puts("\n--- call_many vs native Elixir (100 additions) ---")
+
+native_times = for _ <- 1..200 do
+  {time, _} = :timer.tc(fn ->
+    for i <- 1..100, do: i + i
+  end)
+  time
+end
+
+wasm_times = for _ <- 1..200 do
+  {time, {:ok, _}} = :timer.tc(fn ->
+    Firebird.Pool.call_many(pool, calls_100)
+  end)
+  time
+end
+
+native_avg = Enum.sum(native_times) / 200
+wasm_avg = Enum.sum(wasm_times) / 200
+
+IO.puts("  WASM call_many: avg=#{Float.round(wasm_avg, 1)}μs")
+IO.puts("  Native Elixir:  avg=#{Float.round(native_avg, 1)}μs")
+IO.puts("  Overhead ratio: #{Float.round(wasm_avg / max(native_avg, 0.1), 1)}x")
+
+Firebird.Pool.stop(pool)
+IO.puts("\nDone.")
diff --git a/bench/wasm_collection.exs b/bench/wasm_collection.exs
new file mode 100644
index 0000000..f6c88d8
--- /dev/null
+++ b/bench/wasm_collection.exs
@@ -0,0 +1,47 @@
+# Benchmark: WasmRunner collection helpers vs manual loops
+#
+# Run: mix run bench/wasm_collection.exs
+#
+# Compares the overhead of WasmRunner.map/4, reduce/5, and filter/4
+# against manual with_instance + Enum loops.
+
+alias Firebird.WasmRunner
+
+math_wasm = "fixtures/math.wasm"
+{:ok, compiled} = WasmRunner.precompile(math_wasm)
+
+inputs = Enum.to_list(1..50)
+
+Benchee.run(
+  %{
+    "WasmRunner.map (from file)" => fn ->
+      {:ok, _} = WasmRunner.map(math_wasm, :fibonacci, inputs)
+    end,
+    "WasmRunner.map (precompiled)" => fn ->
+      {:ok, _} = WasmRunner.map(compiled, :fibonacci, inputs)
+    end,
+    "manual with_instance + Enum.map" => fn ->
+      {:ok, _results} =
+        WasmRunner.with_instance(math_wasm, fn pid ->
+          Enum.map(inputs, fn n ->
+            WasmRunner.call_single!(pid, :fibonacci, [n])
+          end)
+        end)
+    end,
+    "WasmRunner.reduce (from file)" => fn ->
+      {:ok, _} = WasmRunner.reduce(math_wasm, :add, inputs, 0)
+    end,
+    "WasmRunner.reduce (precompiled)" => fn ->
+      {:ok, _} = WasmRunner.reduce(compiled, :add, inputs, 0)
+    end,
+    "WasmRunner.filter (from file)" => fn ->
+      {:ok, _} = WasmRunner.filter(math_wasm, :is_prime, inputs)
+    end,
+    "WasmRunner.filter (precompiled)" => fn ->
+      {:ok, _} = WasmRunner.filter(compiled, :is_prime, inputs)
+    end
+  },
+  warmup: 1,
+  time: 3,
+  memory_time: 1
+)
diff --git a/bench/wasm_pipe.exs b/bench/wasm_pipe.exs
new file mode 100644
index 0000000..297a567
--- /dev/null
+++ b/bench/wasm_pipe.exs
@@ -0,0 +1,75 @@
+# Benchmark: WasmRunner.pipe/2 vs sequential WasmRunner.run/2
+#
+# Compares the performance of:
+# 1. pipe/2 - loads once, chains calls
+# 2. Multiple run/2 - loads per call (baseline)
+# 3. with_instance + manual chaining
+#
+# Run: mix run bench/wasm_pipe.exs
+
+alias Firebird.WasmRunner
+
+math_wasm = "fixtures/math.wasm"
+
+IO.puts("=== WasmRunner.pipe/2 Benchmark ===\n")
+
+# Warmup
+WasmRunner.pipe(math_wasm, [{:add, [5, 3]}, {:fibonacci, []}, {:multiply, [:pipe, 2]}])
+
+# Benchmark pipe/2 (3-stage pipeline)
+pipe_result = WasmRunner.benchmark(math_wasm, :add, [[5, 3]], iterations: 100)
+IO.puts("Single call baseline: avg=#{pipe_result.avg_us}μs")
+
+# Manual timing of pipe vs separate runs
+iterations = 100
+
+pipe_times =
+  for _ <- 1..iterations do
+    {elapsed, _} =
+      :timer.tc(fn ->
+        WasmRunner.pipe!(math_wasm, [
+          {:add, [5, 3]},
+          {:fibonacci, []},
+          {:multiply, [:pipe, 2]}
+        ])
+      end)
+
+    elapsed
+  end
+
+separate_times =
+  for _ <- 1..iterations do
+    {elapsed, _} =
+      :timer.tc(fn ->
+        r1 = WasmRunner.run!(math_wasm, add: [5, 3])
+        r2 = WasmRunner.run!(math_wasm, fibonacci: [r1])
+        WasmRunner.run!(math_wasm, multiply: [r2, 2])
+      end)
+
+    elapsed
+  end
+
+with_instance_times =
+  for _ <- 1..iterations do
+    {elapsed, _} =
+      :timer.tc(fn ->
+        WasmRunner.with_instance(math_wasm, fn pid ->
+          r1 = WasmRunner.call_single!(pid, :add, [5, 3])
+          r2 = WasmRunner.call_single!(pid, :fibonacci, [r1])
+          WasmRunner.call_single!(pid, :multiply, [r2, 2])
+        end)
+      end)
+
+    elapsed
+  end
+
+pipe_avg = Enum.sum(pipe_times) / iterations
+separate_avg = Enum.sum(separate_times) / iterations
+with_instance_avg = Enum.sum(with_instance_times) / iterations
+
+IO.puts("\n3-stage pipeline (#{iterations} iterations):")
+IO.puts("  pipe/2:          avg=#{Float.round(pipe_avg, 1)}μs")
+IO.puts("  3x run/2:        avg=#{Float.round(separate_avg, 1)}μs")
+IO.puts("  with_instance:   avg=#{Float.round(with_instance_avg, 1)}μs")
+IO.puts("  pipe speedup vs separate: #{Float.round(separate_avg / pipe_avg, 2)}x")
+IO.puts("  pipe vs with_instance:    #{Float.round(pipe_avg / with_instance_avg, 2)}x overhead")
diff --git a/bench/wasm_runner_run.exs b/bench/wasm_runner_run.exs
new file mode 100644
index 0000000..86681ff
--- /dev/null
+++ b/bench/wasm_runner_run.exs
@@ -0,0 +1,149 @@
+# Benchmark: WasmRunner.run/2 vs native Elixir
+#
+# Run: mix run bench/wasm_runner_run.exs
+#
+# Compares the one-shot WasmRunner.run/2 API against:
+# 1. Pure Elixir equivalent functions
+# 2. Pre-loaded WASM instance (to isolate call overhead from load overhead)
+# 3. Precompiled module (to show compilation cache benefit)
+
+defmodule NativeElixir do
+  def add(a, b), do: a + b
+  def multiply(a, b), do: a * b
+
+  def fibonacci(0), do: 0
+  def fibonacci(1), do: 1
+  def fibonacci(n) when n > 1, do: fibonacci(n - 1) + fibonacci(n - 2)
+end
+
+wasm_path = "fixtures/math.wasm"
+
+IO.puts("=" |> String.duplicate(70))
+IO.puts("WasmRunner.run/2 Benchmark")
+IO.puts("=" |> String.duplicate(70))
+
+# --- Section 1: One-shot run/2 vs Elixir ---
+IO.puts("\n## 1. One-shot execution: run/2 vs pure Elixir\n")
+
+iterations = 100
+
+# Warmup
+for _ <- 1..5 do
+  Firebird.WasmRunner.run(wasm_path, add: [5, 3])
+  NativeElixir.add(5, 3)
+end
+
+# Benchmark run/2 (includes load + call + cleanup each time)
+run_times =
+  for _ <- 1..iterations do
+    {us, _} = :timer.tc(fn -> Firebird.WasmRunner.run(wasm_path, add: [5, 3]) end)
+    us
+  end
+
+# Benchmark Elixir
+elixir_times =
+  for _ <- 1..iterations do
+    {us, _} = :timer.tc(fn -> NativeElixir.add(5, 3) end)
+    us
+  end
+
+run_avg = Enum.sum(run_times) / iterations
+elixir_avg = Enum.sum(elixir_times) / iterations
+run_p50 = Enum.sort(run_times) |> Enum.at(div(iterations, 2))
+elixir_p50 = Enum.sort(elixir_times) |> Enum.at(div(iterations, 2))
+
+IO.puts("  WasmRunner.run/2 (add):  avg=#{Float.round(run_avg, 1)}μs  p50=#{run_p50}μs")
+IO.puts("  Pure Elixir (add):       avg=#{Float.round(elixir_avg, 1)}μs  p50=#{elixir_p50}μs")
+IO.puts("  Overhead ratio:          #{Float.round(run_avg / max(elixir_avg, 0.1), 1)}x")
+
+# --- Section 2: run/2 with multiple calls ---
+IO.puts("\n## 2. Multiple calls in one run/2 (amortizes load cost)\n")
+
+multi_times =
+  for _ <- 1..iterations do
+    {us, _} =
+      :timer.tc(fn ->
+        Firebird.WasmRunner.run(wasm_path,
+          add: [5, 3],
+          multiply: [4, 7],
+          fibonacci: [10]
+        )
+      end)
+    us
+  end
+
+multi_avg = Enum.sum(multi_times) / iterations
+per_call = multi_avg / 3
+
+IO.puts("  3 calls in one run/2:    avg=#{Float.round(multi_avg, 1)}μs total")
+IO.puts("  Per-call amortized:      avg=#{Float.round(per_call, 1)}μs")
+IO.puts("  vs single run/2:         #{Float.round(multi_avg / run_avg, 2)}x (ideal: 1.0x + call overhead)")
+
+# --- Section 3: Precompiled vs cold run/2 ---
+IO.puts("\n## 3. Precompiled module vs cold start\n")
+
+{:ok, compiled} = Firebird.WasmRunner.precompile(wasm_path)
+
+precompiled_times =
+  for _ <- 1..iterations do
+    {us, _} = :timer.tc(fn -> Firebird.WasmRunner.run(compiled, add: [5, 3]) end)
+    us
+  end
+
+pre_avg = Enum.sum(precompiled_times) / iterations
+pre_p50 = Enum.sort(precompiled_times) |> Enum.at(div(iterations, 2))
+
+IO.puts("  Cold run/2:              avg=#{Float.round(run_avg, 1)}μs  p50=#{run_p50}μs")
+IO.puts("  Precompiled run/2:       avg=#{Float.round(pre_avg, 1)}μs  p50=#{pre_p50}μs")
+IO.puts("  Speedup:                 #{Float.round(run_avg / max(pre_avg, 0.1), 1)}x")
+
+# --- Section 4: Pre-loaded instance (call overhead only) ---
+IO.puts("\n## 4. Pre-loaded instance (isolates call overhead)\n")
+
+{:ok, pid} = Firebird.WasmRunner.start(wasm_path)
+
+loaded_times =
+  for _ <- 1..iterations do
+    {us, _} = :timer.tc(fn -> Firebird.WasmRunner.call_single(pid, :add, [5, 3]) end)
+    us
+  end
+
+Firebird.stop(pid)
+
+loaded_avg = Enum.sum(loaded_times) / iterations
+loaded_p50 = Enum.sort(loaded_times) |> Enum.at(div(iterations, 2))
+
+IO.puts("  Pre-loaded call_single:  avg=#{Float.round(loaded_avg, 1)}μs  p50=#{loaded_p50}μs")
+IO.puts("  run/2 overhead (load):   ~#{Float.round(run_avg - loaded_avg, 1)}μs per call")
+
+# --- Section 5: fibonacci(30) - compute-heavy ---
+IO.puts("\n## 5. Compute-heavy: fibonacci(30)\n")
+
+fib_wasm_times =
+  for _ <- 1..50 do
+    {us, _} = :timer.tc(fn -> Firebird.WasmRunner.run(wasm_path, fibonacci: [30]) end)
+    us
+  end
+
+fib_elixir_times =
+  for _ <- 1..50 do
+    {us, _} = :timer.tc(fn -> NativeElixir.fibonacci(30) end)
+    us
+  end
+
+fib_wasm_avg = Enum.sum(fib_wasm_times) / 50
+fib_elixir_avg = Enum.sum(fib_elixir_times) / 50
+
+IO.puts("  WASM run/2 fib(30):      avg=#{Float.round(fib_wasm_avg, 1)}μs")
+IO.puts("  Elixir fib(30):          avg=#{Float.round(fib_elixir_avg, 1)}μs")
+
+if fib_wasm_avg < fib_elixir_avg do
+  IO.puts("  → WASM wins by #{Float.round(fib_elixir_avg / fib_wasm_avg, 1)}x")
+else
+  IO.puts("  → Elixir wins by #{Float.round(fib_wasm_avg / fib_elixir_avg, 1)}x (WASM has load overhead)")
+end
+
+IO.puts("\n" <> String.duplicate("=", 70))
+IO.puts("Summary: run/2 is the simplest API for one-shot WASM execution.")
+IO.puts("For hot paths, use precompiled modules or pools to amortize load cost.")
+IO.puts(String.duplicate("=", 70))
diff --git a/docs/PERFORMANCE_GUIDE.md b/docs/PERFORMANCE_GUIDE.md
index 2c9c274..3adb4b8 100644
--- a/docs/PERFORMANCE_GUIDE.md
+++ b/docs/PERFORMANCE_GUIDE.md
@@ -382,6 +382,41 @@ stats = bench_wasm_call wasm, :add, [5, 3], iterations: 100_000
 
 ---
 
+## WasmRunner.run/2 Performance Characteristics
+
+`WasmRunner.run/2` is the simplest one-shot API. Here's what to expect:
+
+| Scenario | Typical Latency | Use When |
+|----------|----------------|----------|
+| `run/2` cold (from file) | ~2ms | Scripts, CLI tools, infrequent calls |
+| `run/2` precompiled | ~40μs | Repeated calls, avoid recompilation |
+| `call_single` (pre-loaded) | ~15μs | Hot paths, keep instance alive |
+| Pool `call_one` | ~15μs | Concurrent access, production servers |
+
+**Key insight**: ~97% of `run/2` latency is WASM compilation. For hot paths:
+
+```elixir
+# One-shot (simple, ~2ms) — great for scripts
+{:ok, 8} = WasmRunner.run("math.wasm", add: [5, 3])
+
+# Precompiled (53x faster) — amortize compilation
+{:ok, compiled} = WasmRunner.precompile("math.wasm")
+{:ok, 8} = WasmRunner.run(compiled, add: [5, 3])
+
+# Multiple calls in one load (amortizes overhead)
+{:ok, [8, 28, 55]} = WasmRunner.run("math.wasm",
+  add: [5, 3], multiply: [4, 7], fibonacci: [10])
+
+# Pre-loaded instance (~15μs/call) — best for hot paths
+{:ok, pid} = WasmRunner.start("math.wasm")
+{:ok, 8} = WasmRunner.call_single(pid, :add, [5, 3])
+```
+
+For compute-heavy functions (e.g., `fibonacci(30)`), WASM can be **5x+ faster**
+than equivalent pure Elixir, even including the ~2ms load overhead.
+
+Run the benchmark yourself: `mix run bench/wasm_runner_run.exs`
+
 ## Quick Reference: Profiling Commands
 
 ```bash
diff --git a/docs/POOL_CALL_MANY.md b/docs/POOL_CALL_MANY.md
new file mode 100644
index 0000000..f65b475
--- /dev/null
+++ b/docs/POOL_CALL_MANY.md
@@ -0,0 +1,73 @@
+# Pool.call_many — Batched Function Calls
+
+## The Problem
+
+Each `Pool.call/3` incurs a GenServer round-trip for checkout and checkin:
+
+```
+call(pool, :add, [1, 2])   →  checkout → wasm_call → checkin
+call(pool, :add, [3, 4])   →  checkout → wasm_call → checkin
+call(pool, :add, [5, 6])   →  checkout → wasm_call → checkin
+```
+
+For N calls, that's N checkouts + N checkins = 2N GenServer messages.
+
+## The Solution
+
+`Pool.call_many/2` batches calls into a single checkout/checkin cycle:
+
+```
+call_many(pool, [...])   →  checkout → wasm_call → wasm_call → wasm_call → checkin
+```
+
+For N calls: 1 checkout + N WASM calls + 1 checkin = 2 GenServer messages.
+
+## API
+
+```elixir
+# Raw results (each is a list)
+{:ok, [[8], [28], [55]]} = Pool.call_many(pool, [
+  {:add, [5, 3]},
+  {:multiply, [4, 7]},
+  {:fibonacci, [10]}
+])
+
+# Unwrapped results (single values extracted)
+{:ok, [8, 28, 55]} = Pool.call_many_unwrapped(pool, [
+  {:add, [5, 3]},
+  {:multiply, [4, 7]},
+  {:fibonacci, [10]}
+])
+
+# Bang variant
+[[8], [28]] = Pool.call_many!(pool, [{:add, [5, 3]}, {:multiply, [4, 7]}])
+```
+
+## Performance
+
+Benchmark results (fixtures/math.wasm, pool size 4):
+
+| Batch Size | call_many avg | repeated call avg | Speedup |
+|-----------|---------------|-------------------|---------|
+| 5 calls   | ~88μs         | ~112μs            | 1.27x   |
+| 20 calls  | ~303μs        | ~358μs            | 1.18x   |
+| 100 calls | ~1802μs       | ~2015μs           | 1.12x   |
+
+The speedup comes from eliminating N-1 GenServer round-trips. It's most
+pronounced for small batches where checkout/checkin overhead is proportionally
+larger relative to the WASM execution time.
+
+## Error Handling
+
+- Stops on the first error and returns `{:error, reason}`
+- The instance is **always** checked back in (via `try/after`)
+- Subsequent calls to the pool work normally after an error
+
+## When to Use
+
+Use `call_many/2` when you have multiple function calls to make and don't
+need to inspect intermediate results:
+
+- Processing a batch of inputs through the same function
+- Running a sequence of related operations (e.g., encode → process → decode)
+- Any loop where you'd otherwise call `Pool.call/3` repeatedly
diff --git a/examples/basic_usage.exs b/examples/basic_usage.exs
index ec6cf13..5160cb5 100644
--- a/examples/basic_usage.exs
+++ b/examples/basic_usage.exs
@@ -28,11 +28,13 @@ IO.puts("✓ fibonacci(10) = #{result}")
 IO.puts("✓ factorial(5) = #{result}")
 
 # 5. Batch calls
-{:ok, results} = Firebird.call_many(instance, [
-  {:add, [10, 20]},
-  {:multiply, [3, 4]},
-  {:is_prime, [17]}
-])
+{:ok, results} =
+  Firebird.call_many(instance, [
+    {:add, [10, 20]},
+    {:multiply, [3, 4]},
+    {:is_prime, [17]}
+  ])
+
 IO.puts("✓ Batch results: #{inspect(results)}")
 
 # 6. Memory operations
diff --git a/examples/build_and_run.exs b/examples/build_and_run.exs
index 7ee9e4c..0a441db 100644
--- a/examples/build_and_run.exs
+++ b/examples/build_and_run.exs
@@ -15,7 +15,7 @@ IO.puts("=" |> String.duplicate(60))
 # --- Step 1: Create a temporary Go project ---
 IO.puts("\n📝 Step 1: Creating Go WASM project...")
 
-tmp_dir = Path.join(System.tmp_dir!(), "firebird_demo_#{:rand.uniform(100000)}")
+tmp_dir = Path.join(System.tmp_dir!(), "firebird_demo_#{:rand.uniform(100_000)}")
 :ok = Firebird.Builder.scaffold_go(tmp_dir, functions: [:add, :multiply, :double])
 
 # Customize the generated code
@@ -53,9 +53,10 @@ IO.puts("   Files: #{File.ls!(tmp_dir) |> Enum.join(", ")}")
 # --- Step 2: Build WASM ---
 IO.puts("\n🔨 Step 2: Building Go → WASM...")
 
-{build_time, {:ok, wasm_path}} = :timer.tc(fn ->
-  Firebird.Builder.build_go(tmp_dir)
-end)
+{build_time, {:ok, wasm_path}} =
+  :timer.tc(fn ->
+    Firebird.Builder.build_go(tmp_dir)
+  end)
 
 wasm_size = File.stat!(wasm_path).size
 IO.puts("   Built: #{wasm_path}")
@@ -65,9 +66,10 @@ IO.puts("   Time: #{div(build_time, 1000)}ms")
 # --- Step 3: Load and call ---
 IO.puts("\n🚀 Step 3: Loading and calling WASM functions...")
 
-{load_time, {:ok, instance}} = :timer.tc(fn ->
-  Firebird.load(wasm_path, wasi: true)
-end)
+{load_time, {:ok, instance}} =
+  :timer.tc(fn ->
+    Firebird.load(wasm_path, wasi: true)
+  end)
 
 IO.puts("   Loaded in #{div(load_time, 1000)}ms")
 
@@ -95,18 +97,24 @@ IO.puts("\n🔗 Step 4: Using Pipeline to chain calls...")
 
 result =
   Firebird.pipeline(instance)
-  |> Firebird.Pipeline.call(:add, [5, 3])           # 8
-  |> Firebird.Pipeline.call(:square, [:_])           # 64
-  |> Firebird.Pipeline.call(:double, [:_])           # 128
+  # 8
+  |> Firebird.Pipeline.call(:add, [5, 3])
+  # 64
+  |> Firebird.Pipeline.call(:square, [:_])
+  # 128
+  |> Firebird.Pipeline.call(:double, [:_])
   |> Firebird.Pipeline.run!()
 
 IO.puts("   add(5,3) |> square |> double = #{hd(result)}")
 
 result2 =
   Firebird.pipeline(instance)
-  |> Firebird.Pipeline.call(:fibonacci, [10])        # 55
-  |> Firebird.Pipeline.call(:add, [:_, 45])          # 100
-  |> Firebird.Pipeline.call(:multiply, [:_, 3])      # 300
+  # 55
+  |> Firebird.Pipeline.call(:fibonacci, [10])
+  # 100
+  |> Firebird.Pipeline.call(:add, [:_, 45])
+  # 300
+  |> Firebird.Pipeline.call(:multiply, [:_, 3])
   |> Firebird.Pipeline.run!()
 
 IO.puts("   fibonacci(10) |> add(_, 45) |> multiply(_, 3) = #{hd(result2)}")
@@ -125,8 +133,9 @@ IO.puts("   " <> String.duplicate("─", 56))
 
 test_cases = [
   {"add(100,200)", :add, [100, 200], fn -> 100 + 200 end},
-  {"fibonacci(20)", :fibonacci, [20], fn -> Enum.reduce(2..20, {1, 0}, fn _, {b, a} -> {a + b, b} end) |> elem(0) end},
-  {"factorial(10)", :factorial, [10], fn -> Enum.reduce(1..10, 1, &*/2) end},
+  {"fibonacci(20)", :fibonacci, [20],
+   fn -> Enum.reduce(2..20, {1, 0}, fn _, {b, a} -> {a + b, b} end) |> elem(0) end},
+  {"factorial(10)", :factorial, [10], fn -> Enum.reduce(1..10, 1, &*/2) end}
 ]
 
 for {name, func, args, native_fn} <- test_cases do
@@ -137,7 +146,10 @@ for {name, func, args, native_fn} <- test_cases do
   native_r = if is_tuple(native_r), do: elem(native_r, 0), else: native_r
 
   status = if go_r == rust_r and rust_r == wat_r, do: "✅", else: "❌"
-  IO.puts("   #{status} #{String.pad_trailing(name, 16)} #{String.pad_leading("#{go_r}", 10)} #{String.pad_leading("#{rust_r}", 10)} #{String.pad_leading("#{wat_r}", 10)} #{String.pad_leading("#{native_r}", 10)}")
+
+  IO.puts(
+    "   #{status} #{String.pad_trailing(name, 16)} #{String.pad_leading("#{go_r}", 10)} #{String.pad_leading("#{rust_r}", 10)} #{String.pad_leading("#{wat_r}", 10)} #{String.pad_leading("#{native_r}", 10)}"
+  )
 end
 
 Firebird.stop(go_instance)
diff --git a/examples/compile_to_wasm.exs b/examples/compile_to_wasm.exs
index 8f9d6ef..5e39e8e 100644
--- a/examples/compile_to_wasm.exs
+++ b/examples/compile_to_wasm.exs
@@ -49,7 +49,11 @@ IO.puts("⚙️  Compiling to WebAssembly...")
 IO.puts("   Module: #{result.module}")
 IO.puts("   WAT size: #{byte_size(result.wat)} bytes")
 IO.puts("   WASM size: #{byte_size(result.wasm)} bytes")
-IO.puts("   Compression: #{Float.round(byte_size(result.wasm) / byte_size(result.wat) * 100, 1)}%")
+
+IO.puts(
+  "   Compression: #{Float.round(byte_size(result.wasm) / byte_size(result.wat) * 100, 1)}%"
+)
+
 IO.puts("")
 
 # Step 3: Load and execute
diff --git a/examples/complete_project/lib/my_app.ex b/examples/complete_project/lib/my_app.ex
index 85d6559..b27fa53 100644
--- a/examples/complete_project/lib/my_app.ex
+++ b/examples/complete_project/lib/my_app.ex
@@ -40,9 +40,12 @@ defmodule MyApp do
 
     # 5. Block API with auto-cleanup
     IO.puts("\n5. Block API:")
-    {:ok, z} = Firebird.with_instance("wasm/math.wasm", fn wasm ->
-      Firebird.call_one!(wasm, :fibonacci, [20])
-    end)
+
+    {:ok, z} =
+      Firebird.with_instance("wasm/math.wasm", fn wasm ->
+        Firebird.call_one!(wasm, :fibonacci, [20])
+      end)
+
     IO.puts("   fibonacci(20) = #{z}")
 
     IO.puts("\n✅ All done!")
diff --git a/examples/complete_project/lib/my_app/application.ex b/examples/complete_project/lib/my_app/application.ex
index d426223..f6eb83d 100644
--- a/examples/complete_project/lib/my_app/application.ex
+++ b/examples/complete_project/lib/my_app/application.ex
@@ -5,7 +5,7 @@ defmodule MyApp.Application do
   def start(_type, _args) do
     children = [
       # Start the WASM math module as a supervised process
-      MyApp.Math,
+      MyApp.Math
 
       # Or use a pool for concurrent workloads:
       # {Firebird.Pool, wasm: "wasm/math.wasm", size: 4, name: :math_pool}
diff --git a/examples/complete_wasm_demo/demo.exs b/examples/complete_wasm_demo/demo.exs
index 83ec2ea..2509f6e 100644
--- a/examples/complete_wasm_demo/demo.exs
+++ b/examples/complete_wasm_demo/demo.exs
@@ -88,11 +88,13 @@ IO.puts("  Firebird.run!(\"math.wasm\", :add, [999, 1]) = #{inspect(result)}")
 # --- 6. With Instance (auto-cleanup) ---
 IO.puts("\n━━━ 6. With Instance (auto-cleanup) ━━━\n")
 
-{:ok, result} = Firebird.with_instance("fixtures/math.wasm", fn wasm ->
-  {:ok, [a]} = Firebird.call(wasm, :add, [10, 20])
-  {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 3])
-  b
-end)
+{:ok, result} =
+  Firebird.with_instance("fixtures/math.wasm", fn wasm ->
+    {:ok, [a]} = Firebird.call(wasm, :add, [10, 20])
+    {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 3])
+    b
+  end)
+
 IO.puts("  (10 + 20) * 3 = #{result}")
 
 # --- 7. Pipe API ---
@@ -120,12 +122,16 @@ IO.puts("\n━━━ 9. Connection Pool ━━━\n")
 {:ok, pool} = Firebird.start_pool(wasm: "fixtures/math.wasm", size: 4)
 IO.puts("  Started pool with 4 instances")
 
-results = 1..10
-|> Task.async_stream(fn i ->
-  {:ok, [r]} = Firebird.pool_call(pool, :fibonacci, [i])
-  {i, r}
-end, max_concurrency: 4)
-|> Enum.map(fn {:ok, r} -> r end)
+results =
+  1..10
+  |> Task.async_stream(
+    fn i ->
+      {:ok, [r]} = Firebird.pool_call(pool, :fibonacci, [i])
+      {i, r}
+    end,
+    max_concurrency: 4
+  )
+  |> Enum.map(fn {:ok, r} -> r end)
 
 for {n, fib} <- results do
   IO.puts("  fibonacci(#{n}) = #{fib}")
@@ -151,7 +157,10 @@ IO.puts("  Next prime after 100: #{r}")
 IO.puts("  Digit sum of 9999: #{r}")
 
 # Sort array in WASM memory
-data = <<5::little-signed-32, 3::little-signed-32, 1::little-signed-32, 4::little-signed-32, 2::little-signed-32>>
+data =
+  <<5::little-signed-32, 3::little-signed-32, 1::little-signed-32, 4::little-signed-32,
+    2::little-signed-32>>
+
 :ok = Firebird.write_memory(algo, 0, data)
 Firebird.call(algo, :sort_i32, [0, 5])
 {:ok, sorted} = Firebird.read_memory(algo, 0, 20)
diff --git a/examples/comprehensive_demo.exs b/examples/comprehensive_demo.exs
index 1a0ba62..8a2e841 100644
--- a/examples/comprehensive_demo.exs
+++ b/examples/comprehensive_demo.exs
@@ -66,6 +66,7 @@ IO.puts("   Rust exports: #{inspect(exports)}")
 
 all = Firebird.all_exports(rust)
 IO.puts("   All exports (with types):")
+
 for {name, type} <- all do
   IO.puts("     #{name}: #{type}")
 end
@@ -81,15 +82,17 @@ IO.puts("")
 IO.puts("4. BATCH CALLS (call_many)")
 IO.puts("-" |> String.duplicate(40))
 
-{:ok, results} = Firebird.call_many(rust, [
-  {:add, [1, 2]},
-  {:multiply, [3, 4]},
-  {:fibonacci, [10]},
-  {:factorial, [5]},
-  {:gcd, [48, 18]}
-])
+{:ok, results} =
+  Firebird.call_many(rust, [
+    {:add, [1, 2]},
+    {:multiply, [3, 4]},
+    {:fibonacci, [10]},
+    {:factorial, [5]},
+    {:gcd, [48, 18]}
+  ])
 
 labels = ["add(1,2)", "multiply(3,4)", "fibonacci(10)", "factorial(5)", "gcd(48,18)"]
+
 for {label, [val]} <- Enum.zip(labels, results) do
   IO.puts("   #{label} = #{val}")
 end
@@ -106,7 +109,8 @@ IO.puts("-" |> String.duplicate(40))
 IO.puts("   Memory size: #{size} bytes (#{div(size, 65_536)} pages)")
 
 # Write and read back
-data = <<72, 101, 108, 108, 111>>  # "Hello"
+# "Hello"
+data = <<72, 101, 108, 108, 111>>
 :ok = Firebird.write_memory(rust, 0, data)
 {:ok, read_back} = Firebird.read_memory(rust, 0, 5)
 IO.puts("   Wrote #{inspect(data)} -> Read #{inspect(read_back)} (\"#{read_back}\")")
@@ -132,12 +136,14 @@ IO.puts("   Pool started with 4 instances")
 IO.puts("   pool_call add(100, 200) = #{result}")
 
 # Concurrent
-tasks = for i <- 1..10 do
-  Task.async(fn ->
-    {:ok, [r]} = Firebird.pool_call(pool, :fibonacci, [i])
-    r
-  end)
-end
+tasks =
+  for i <- 1..10 do
+    Task.async(fn ->
+      {:ok, [r]} = Firebird.pool_call(pool, :fibonacci, [i])
+      r
+    end)
+  end
+
 results = Task.await_many(tasks)
 IO.puts("   10 concurrent fibonacci calls: #{inspect(results)}")
 
@@ -154,7 +160,9 @@ IO.puts("-" |> String.duplicate(40))
 
 {:ok, str_wasm} = Firebird.load("fixtures/string_utils.wasm")
 
-{:ok, "HELLO WORLD"} = Firebird.WasmString.call_with_string(str_wasm, :to_uppercase, "hello world")
+{:ok, "HELLO WORLD"} =
+  Firebird.WasmString.call_with_string(str_wasm, :to_uppercase, "hello world")
+
 IO.puts("   to_uppercase(\"hello world\") = \"HELLO WORLD\"")
 
 {:ok, ptr, len} = Firebird.WasmString.write_string(str_wasm, "firebird")
@@ -181,18 +189,19 @@ test_cases = [
   {:factorial, [10]},
   {:gcd, [252, 105]},
   {:power, [2, 16]},
-  {:is_prime, [104729]},
+  {:is_prime, [104_729]},
   {:sum_range, [1, 1000]}
 ]
 
-all_match = Enum.all?(test_cases, fn {func, args} ->
-  {:ok, [r]} = Firebird.call(rust, func, args)
-  {:ok, [g]} = Firebird.call(go, func, args)
-  match = r == g
-  status = if match, do: "✅", else: "❌"
-  IO.puts("   #{status} #{func}(#{Enum.join(args, ", ")}): Rust=#{r}, Go=#{g}")
-  match
-end)
+all_match =
+  Enum.all?(test_cases, fn {func, args} ->
+    {:ok, [r]} = Firebird.call(rust, func, args)
+    {:ok, [g]} = Firebird.call(go, func, args)
+    match = r == g
+    status = if match, do: "✅", else: "❌"
+    IO.puts("   #{status} #{func}(#{Enum.join(args, ", ")}): Rust=#{r}, Go=#{g}")
+    match
+  end)
 
 IO.puts("   All results match: #{all_match}")
 
diff --git a/examples/concurrent_pool.exs b/examples/concurrent_pool.exs
index bf0e7a3..f8afad0 100644
--- a/examples/concurrent_pool.exs
+++ b/examples/concurrent_pool.exs
@@ -16,20 +16,22 @@ IO.puts("Started pool with #{Firebird.Pool.status(pool).pool_size} instances\n")
 n = 100
 
 # Sequential
-{sequential_time, _} = :timer.tc(fn ->
-  for i <- 1..n do
-    {:ok, [_]} = Firebird.Pool.call(pool, :fibonacci, [30])
-  end
-end)
+{sequential_time, _} =
+  :timer.tc(fn ->
+    for i <- 1..n do
+      {:ok, [_]} = Firebird.Pool.call(pool, :fibonacci, [30])
+    end
+  end)
 
 # Concurrent with tasks
-{concurrent_time, _} = :timer.tc(fn ->
-  1..n
-  |> Enum.map(fn _i ->
-    Task.async(fn -> Firebird.Pool.call!(pool, :fibonacci, [30]) end)
+{concurrent_time, _} =
+  :timer.tc(fn ->
+    1..n
+    |> Enum.map(fn _i ->
+      Task.async(fn -> Firebird.Pool.call!(pool, :fibonacci, [30]) end)
+    end)
+    |> Task.await_many()
   end)
-  |> Task.await_many()
-end)
 
 IO.puts("#{n} fibonacci(30) calls:")
 IO.puts("  Sequential:  #{div(sequential_time, 1000)}ms")
@@ -39,6 +41,7 @@ IO.puts("  Speedup:     #{Float.round(sequential_time / max(concurrent_time, 1),
 # ── 3. Mixed workloads ──────────────────────────────────────────────────────
 
 IO.puts("Mixed concurrent workload:")
+
 tasks = [
   Task.async(fn -> {:add, Firebird.Pool.call!(pool, :add, [100, 200])} end),
   Task.async(fn -> {:mul, Firebird.Pool.call!(pool, :multiply, [7, 8])} end),
diff --git a/examples/end_to_end_demo.exs b/examples/end_to_end_demo.exs
index dfb773c..ed27c73 100644
--- a/examples/end_to_end_demo.exs
+++ b/examples/end_to_end_demo.exs
@@ -113,7 +113,12 @@ IO.puts("  Binary search for 30 → index #{idx}")
 
 IO.puts("\n🌍 Cross-language comparison (WAT vs Go):\n")
 
-for {func, args} <- [{:add, [100, 200]}, {:multiply, [7, 8]}, {:fibonacci, [15]}, {:factorial, [10]}] do
+for {func, args} <- [
+      {:add, [100, 200]},
+      {:multiply, [7, 8]},
+      {:fibonacci, [15]},
+      {:factorial, [10]}
+    ] do
   {:ok, [wat_r]} = Firebird.call(wat, func, args)
   {:ok, [go_r]} = Firebird.call(go, func, args)
   match = if wat_r == go_r, do: "✅", else: "❌"
@@ -124,13 +129,15 @@ end
 
 IO.puts("\n📦 Batch operations:\n")
 
-{:ok, results} = Firebird.WasmRunner.run_batch("fixtures/math.wasm", [
-  {:add, [1, 2]},
-  {:multiply, [3, 4]},
-  {:fibonacci, [10]},
-  {:factorial, [5]},
-  {:gcd, [48, 36]}
-])
+{:ok, results} =
+  Firebird.WasmRunner.run_batch("fixtures/math.wasm", [
+    {:add, [1, 2]},
+    {:multiply, [3, 4]},
+    {:fibonacci, [10]},
+    {:factorial, [5]},
+    {:gcd, [48, 36]}
+  ])
+
 IO.puts("  Batch results: #{inspect(results)}")
 
 # ── 9. WasmRunner auto-WASI ──────────────────────────────────
diff --git a/examples/end_to_end_wasm_demo.exs b/examples/end_to_end_wasm_demo.exs
index 4211dc3..46cc838 100644
--- a/examples/end_to_end_wasm_demo.exs
+++ b/examples/end_to_end_wasm_demo.exs
@@ -47,9 +47,9 @@ calls = [
   {"add(5, 3)", :add, [5, 3], 8},
   {"multiply(7, 6)", :multiply, [7, 6], 42},
   {"fibonacci(10)", :fibonacci, [10], 55},
-  {"factorial(12)", :factorial, [12], 479001600},
+  {"factorial(12)", :factorial, [12], 479_001_600},
   {"gcd(48, 36)", :gcd, [48, 36], 12},
-  {"is_prime(104729)", :is_prime, [104729], 1},
+  {"is_prime(104729)", :is_prime, [104_729], 1},
   {"power(2, 10)", :power, [2, 10], 1024},
   {"sum_range(1, 100)", :sum_range, [1, 100], 5050}
 ]
@@ -59,7 +59,10 @@ for {label, func, args, expected} <- calls do
   {:ok, [g_result]} = Firebird.call(go, func, args)
 
   match = if r_result == g_result and r_result == expected, do: "✅", else: "❌"
-  IO.puts("  #{match} #{String.pad_trailing(label, 25)} Rust=#{r_result}  Go=#{g_result}  expected=#{expected}")
+
+  IO.puts(
+    "  #{match} #{String.pad_trailing(label, 25)} Rust=#{r_result}  Go=#{g_result}  expected=#{expected}"
+  )
 end
 
 # ── 4. Rust-only Features ────────────────────────────────────
@@ -78,20 +81,21 @@ IO.puts("  collatz_steps(27) = #{result} steps")
 {:ok, [result]} = Firebird.call(rust, :count_primes, [1000])
 IO.puts("  count_primes(1000) = #{result}")
 
-{:ok, [result]} = Firebird.call(rust, :isqrt, [1000000])
+{:ok, [result]} = Firebird.call(rust, :isqrt, [1_000_000])
 IO.puts("  isqrt(1000000) = #{result}")
 
 # ── 5. WasmRunner Ergonomic API ──────────────────────────────
 
 IO.puts("\n🚀 Step 5: WasmRunner batch execution\n")
 
-{:ok, results} = Firebird.WasmRunner.run_batch("fixtures/rust_math.wasm", [
-  {:add, [100, 200]},
-  {:multiply, [11, 11]},
-  {:fibonacci, [20]},
-  {:factorial, [10]},
-  {:count_primes, [100]}
-])
+{:ok, results} =
+  Firebird.WasmRunner.run_batch("fixtures/rust_math.wasm", [
+    {:add, [100, 200]},
+    {:multiply, [11, 11]},
+    {:fibonacci, [20]},
+    {:factorial, [10]},
+    {:count_primes, [100]}
+  ])
 
 IO.puts("  Batch results: #{inspect(results)}")
 IO.puts("  (add=300, multiply=121, fib=6765, factorial=3628800, primes=25)")
@@ -102,9 +106,12 @@ IO.puts("\n⚡ Step 6: Concurrent WASM execution\n")
 
 args_list = for n <- [10, 20, 30, 35, 40], do: [n]
 
-{time, {:ok, results}} = :timer.tc(fn ->
-  Firebird.WasmRunner.run_concurrent("fixtures/rust_math.wasm", :fibonacci, args_list, concurrency: 4)
-end)
+{time, {:ok, results}} =
+  :timer.tc(fn ->
+    Firebird.WasmRunner.run_concurrent("fixtures/rust_math.wasm", :fibonacci, args_list,
+      concurrency: 4
+    )
+  end)
 
 IO.puts("  fibonacci([10,20,30,35,40]) = #{inspect(results)}")
 IO.puts("  Concurrent execution time: #{time}μs (#{Float.round(time / 1000, 1)}ms)")
@@ -136,7 +143,9 @@ IO.puts("\n📝 Step 8: String processing (Rust WASM)\n")
 {:ok, "FIREBIRD"} = Firebird.WasmString.call_with_string(str_wasm, :to_uppercase, "firebird")
 IO.puts("  to_uppercase(\"firebird\") = \"FIREBIRD\"")
 
-{:ok, "HELLO WORLD"} = Firebird.WasmString.call_with_string(str_wasm, :to_uppercase, "hello world")
+{:ok, "HELLO WORLD"} =
+  Firebird.WasmString.call_with_string(str_wasm, :to_uppercase, "hello world")
+
 IO.puts("  to_uppercase(\"hello world\") = \"HELLO WORLD\"")
 
 Firebird.stop(str_wasm)
diff --git a/examples/error_handling.exs b/examples/error_handling.exs
index 66d308c..3b7f8cb 100644
--- a/examples/error_handling.exs
+++ b/examples/error_handling.exs
@@ -9,6 +9,7 @@ IO.puts("🔥 Firebird Error Handling Patterns\n")
 # ── 1. File not found ───────────────────────────────────────────────────────
 
 IO.puts("1. File not found:")
+
 case Firebird.load("nonexistent.wasm") do
   {:ok, _} -> IO.puts("  Loaded!")
   {:error, {:file_error, :enoent, path}} -> IO.puts("  ✓ File not found: #{path}")
@@ -18,6 +19,7 @@ end
 # ── 2. Bang version raises ──────────────────────────────────────────────────
 
 IO.puts("\n2. Bang version raises:")
+
 try do
   Firebird.load!("nonexistent.wasm")
 rescue
@@ -38,6 +40,7 @@ end
 
 IO.puts("\n4. Check before calling:")
 function = :add
+
 if Firebird.function_exists?(wasm, function) do
   {:ok, [result]} = Firebird.call(wasm, function, [5, 3])
   IO.puts("  ✓ #{function}(5, 3) = #{result}")
@@ -48,6 +51,7 @@ end
 # ── 5. run/3 — one-shot with error handling ──────────────────────────────────
 
 IO.puts("\n5. One-shot with run/3:")
+
 case Firebird.run("fixtures/math.wasm", :add, [5, 3]) do
   {:ok, [result]} -> IO.puts("  ✓ Result: #{result}")
   {:error, reason} -> IO.puts("  ✗ Error: #{inspect(reason)}")
@@ -56,11 +60,12 @@ end
 # ── 6. with_instance — block with auto-cleanup ──────────────────────────────
 
 IO.puts("\n6. Block with auto-cleanup:")
+
 case Firebird.with_instance("fixtures/math.wasm", fn inst ->
-  {:ok, [a]} = Firebird.call(inst, :add, [10, 20])
-  {:ok, [b]} = Firebird.call(inst, :multiply, [a, 2])
-  b
-end) do
+       {:ok, [a]} = Firebird.call(inst, :add, [10, 20])
+       {:ok, [b]} = Firebird.call(inst, :multiply, [a, 2])
+       b
+     end) do
   {:ok, result} -> IO.puts("  ✓ Result: #{result}")
   {:error, reason} -> IO.puts("  ✗ Error: #{inspect(reason)}")
 end
@@ -68,6 +73,7 @@ end
 # ── 7. Pattern: safe plugin loading ─────────────────────────────────────────
 
 IO.puts("\n7. Safe plugin loading pattern:")
+
 defmodule PluginLoader do
   def load(path) do
     with {:ok, instance} <- Firebird.load(path),
@@ -79,6 +85,7 @@ defmodule PluginLoader do
       false ->
         IO.puts("  ✗ Plugin missing required functions (init, process)")
         {:error, :invalid_plugin}
+
       {:error, _} = error ->
         IO.puts("  ✗ Failed to load: #{inspect(error)}")
         error
diff --git a/examples/go_math_demo.exs b/examples/go_math_demo.exs
index 66bd595..d534122 100644
--- a/examples/go_math_demo.exs
+++ b/examples/go_math_demo.exs
@@ -10,7 +10,11 @@ go_path = "fixtures/go_math.wasm"
 
 unless File.exists?(go_path) do
   IO.puts("❌ Go WASM not found. Build it first:")
-  IO.puts("   cd fixtures/go_math && tinygo build -o ../go_math.wasm -target wasm -no-debug main.go")
+
+  IO.puts(
+    "   cd fixtures/go_math && tinygo build -o ../go_math.wasm -target wasm -no-debug main.go"
+  )
+
   System.halt(1)
 end
 
@@ -53,15 +57,15 @@ IO.puts("Cross-language verification (Go vs Rust):")
 {:ok, rust_wasm} = Firebird.load("fixtures/math.wasm")
 
 for {func, args, label} <- [
-  {:add, [42, 58], "add(42, 58)"},
-  {:multiply, [7, 8], "multiply(7, 8)"},
-  {:fibonacci, [10], "fibonacci(10)"},
-  {:factorial, [5], "factorial(5)"},
-  {:gcd, [48, 18], "gcd(48, 18)"},
-  {:power, [2, 10], "power(2, 10)"},
-  {:is_prime, [97], "is_prime(97)"},
-  {:sum_range, [1, 100], "sum_range(1, 100)"}
-] do
+      {:add, [42, 58], "add(42, 58)"},
+      {:multiply, [7, 8], "multiply(7, 8)"},
+      {:fibonacci, [10], "fibonacci(10)"},
+      {:factorial, [5], "factorial(5)"},
+      {:gcd, [48, 18], "gcd(48, 18)"},
+      {:power, [2, 10], "power(2, 10)"},
+      {:is_prime, [97], "is_prime(97)"},
+      {:sum_range, [1, 100], "sum_range(1, 100)"}
+    ] do
   {:ok, [go_result]} = Firebird.call(wasm, func, args)
   {:ok, [rust_result]} = Firebird.call(rust_wasm, func, args)
   match = if go_result == rust_result, do: "✅", else: "❌"
diff --git a/examples/memory_management.exs b/examples/memory_management.exs
index e9f2618..1722f25 100644
--- a/examples/memory_management.exs
+++ b/examples/memory_management.exs
@@ -96,15 +96,20 @@ IO.puts("")
 # Define C-compatible struct layouts for complex data exchange.
 # Fields use natural alignment matching C/Rust/TinyGo defaults.
 
-layout = Memory.define_layout([
-  {:x, :f64},
-  {:y, :f64},
-  {:id, :i32},
-  {:flags, :u8}
-])
+layout =
+  Memory.define_layout([
+    {:x, :f64},
+    {:y, :f64},
+    {:id, :i32},
+    {:flags, :u8}
+  ])
 
 IO.puts("6️⃣  Struct layout defined")
-IO.puts("   Fields: #{inspect(Enum.map(layout.fields, fn {name, type} -> "#{name}:#{type}" end))}")
+
+IO.puts(
+  "   Fields: #{inspect(Enum.map(layout.fields, fn {name, type} -> "#{name}:#{type}" end))}"
+)
+
 IO.puts("   Offsets: #{inspect(layout.offsets)}")
 IO.puts("   Total size: #{layout.size} bytes (padded to max alignment)")
 
@@ -129,9 +134,11 @@ IO.puts("   Wrote #{struct_count} structs starting at offset #{arr_struct_ptr}")
 
 {:ok, read_points} = Memory.read_struct_array(alloc, layout, arr_struct_ptr, struct_count)
 IO.puts("   Read back #{length(read_points)} structs")
+
 for p <- read_points do
   IO.puts("     Point ##{p.id}: (#{p.x}, #{p.y}) flags=#{p.flags}")
 end
+
 IO.puts("")
 
 # ─── 7. Introspection ──────────────────────────────────────────────────────
@@ -162,18 +169,19 @@ IO.puts("")
 IO.puts("9️⃣  Scoped arena (with_arena)")
 IO.puts("   Cursor before: #{alloc.cursor}")
 
-{result, alloc} = Memory.with_arena(alloc, fn arena ->
-  # These allocations are temporary
-  {arena, ptr, len} = Memory.write_string(arena, "temporary data")
-  {:ok, temp_str} = Memory.read_string(arena, ptr, len)
+{result, alloc} =
+  Memory.with_arena(alloc, fn arena ->
+    # These allocations are temporary
+    {arena, ptr, len} = Memory.write_string(arena, "temporary data")
+    {:ok, temp_str} = Memory.read_string(arena, ptr, len)
 
-  {arena, _, _} = Memory.write_i32_array(arena, Enum.to_list(1..100))
+    {arena, _, _} = Memory.write_i32_array(arena, Enum.to_list(1..100))
 
-  IO.puts("   Inside arena: #{Memory.allocated_bytes(arena)} bytes allocated")
+    IO.puts("   Inside arena: #{Memory.allocated_bytes(arena)} bytes allocated")
 
-  # Return a result — it survives the arena reset
-  {temp_str, arena}
-end)
+    # Return a result — it survives the arena reset
+    {temp_str, arena}
+  end)
 
 IO.puts("   Cursor after: #{alloc.cursor} (reset to before)")
 IO.puts("   Result preserved: #{inspect(result)}")
diff --git a/examples/new_features.exs b/examples/new_features.exs
index 8eba019..07fa285 100644
--- a/examples/new_features.exs
+++ b/examples/new_features.exs
@@ -27,13 +27,14 @@ IO.puts("2️⃣  Inline WAT with wat!() compile-time macro")
 
 import Firebird.Sigils
 
-bytes = wat!("""
-(module
-  (func (export "square") (param i32) (result i32)
-    local.get 0
-    local.get 0
-    i32.mul))
-""")
+bytes =
+  wat!("""
+  (module
+    (func (export "square") (param i32) (result i32)
+      local.get 0
+      local.get 0
+      i32.mul))
+  """)
 
 {:ok, wasm} = Firebird.load(bytes)
 {:ok, [result]} = Firebird.call(wasm, :square, [7])
@@ -44,11 +45,15 @@ IO.puts("")
 # ─── 3. Quick.eval_wat for one-off computations ─────────────────
 IO.puts("3️⃣  Quick.eval_wat for one-off WAT evaluation")
 
-{:ok, [answer]} = Firebird.Quick.eval_wat("""
-(module
-  (func (export "meaning_of_life") (result i32)
-    i32.const 42))
-""", "meaning_of_life")
+{:ok, [answer]} =
+  Firebird.Quick.eval_wat(
+    """
+    (module
+      (func (export "meaning_of_life") (result i32)
+        i32.const 42))
+    """,
+    "meaning_of_life"
+  )
 
 IO.puts("   meaning_of_life() = #{answer}")
 IO.puts("")
@@ -67,8 +72,8 @@ IO.puts("")
 # ─── 5. Quick.wat_fn for reusable inline functions ──────────────
 IO.puts("5️⃣  Quick.wat_fn for creating callable WAT functions")
 
-negate = Firebird.Quick.wat_fn("negate", "(param i32) (result i32)",
-  "i32.const 0 local.get 0 i32.sub")
+negate =
+  Firebird.Quick.wat_fn("negate", "(param i32) (result i32)", "i32.const 0 local.get 0 i32.sub")
 
 {:ok, [neg5]} = negate.([5])
 {:ok, [neg100]} = negate.([100])
@@ -78,6 +83,7 @@ IO.puts("")
 
 # ─── Summary ─────────────────────────────────────────────────────
 IO.puts("✅ All features working!")
+
 IO.puts("""
    Summary of new DX features:
    • use Firebird, wasm: "..."  — shorter than use Firebird.Module
diff --git a/examples/phoenix_wasm_app.exs b/examples/phoenix_wasm_app.exs
index e38864f..2b9347f 100644
--- a/examples/phoenix_wasm_app.exs
+++ b/examples/phoenix_wasm_app.exs
@@ -31,38 +31,69 @@ alias Firebird.Phoenix.{RequestHandler, Middleware, Conn}
 {:ok, handler} = RequestHandler.new()
 
 # Add middleware
-handler = handler
-|> RequestHandler.use_middleware(Middleware.request_id())
-|> RequestHandler.use_middleware(Middleware.timer())
-|> RequestHandler.use_middleware(Middleware.logger())
-|> RequestHandler.use_middleware(Middleware.default_header("x-powered-by", "Firebird WASM"))
+handler =
+  handler
+  |> RequestHandler.use_middleware(Middleware.request_id())
+  |> RequestHandler.use_middleware(Middleware.timer())
+  |> RequestHandler.use_middleware(Middleware.logger())
+  |> RequestHandler.use_middleware(Middleware.default_header("x-powered-by", "Firebird WASM"))
 
 # Define routes
-handler = handler
-|> RequestHandler.route("GET", "/", "PageController.index")
-|> RequestHandler.route("GET", "/api/users", "UserController.index")
-|> RequestHandler.route("GET", "/api/users/:id", "UserController.show")
-|> RequestHandler.route("POST", "/api/users", "UserController.create")
-|> RequestHandler.route("PUT", "/api/users/:id", "UserController.update")
-|> RequestHandler.route("DELETE", "/api/users/:id", "UserController.delete")
-|> RequestHandler.route("GET", "/api/health", "HealthController.check")
+handler =
+  handler
+  |> RequestHandler.route("GET", "/", "PageController.index")
+  |> RequestHandler.route("GET", "/api/users", "UserController.index")
+  |> RequestHandler.route("GET", "/api/users/:id", "UserController.show")
+  |> RequestHandler.route("POST", "/api/users", "UserController.create")
+  |> RequestHandler.route("PUT", "/api/users/:id", "UserController.update")
+  |> RequestHandler.route("DELETE", "/api/users/:id", "UserController.delete")
+  |> RequestHandler.route("GET", "/api/health", "HealthController.check")
 
 # Define templates
-handler = handler
-|> RequestHandler.template("PageController.index", 200, "text/html",
-    "<html><body><h1>Welcome to Firebird Phoenix WASM</h1><p>A REST API powered by WebAssembly</p></body></html>")
-|> RequestHandler.template("UserController.index", 200, "application/json",
-    ~s([{"id":"1","name":"Alice"},{"id":"2","name":"Bob"},{"id":"3","name":"Charlie"}]))
-|> RequestHandler.template("UserController.show", 200, "application/json",
-    ~s({"id":"{{id}}","name":"User {{id}}","email":"user{{id}}@example.com"}))
-|> RequestHandler.template("UserController.create", 201, "application/json",
-    ~s({"status":"created","message":"User created successfully"}))
-|> RequestHandler.template("UserController.update", 200, "application/json",
-    ~s({"status":"updated","id":"{{id}}"}))
-|> RequestHandler.template("UserController.delete", 200, "application/json",
-    ~s({"status":"deleted","id":"{{id}}"}))
-|> RequestHandler.template("HealthController.check", 200, "application/json",
-    ~s({"status":"ok","uptime":"100%","wasm":"active"}))
+handler =
+  handler
+  |> RequestHandler.template(
+    "PageController.index",
+    200,
+    "text/html",
+    "<html><body><h1>Welcome to Firebird Phoenix WASM</h1><p>A REST API powered by WebAssembly</p></body></html>"
+  )
+  |> RequestHandler.template(
+    "UserController.index",
+    200,
+    "application/json",
+    ~s([{"id":"1","name":"Alice"},{"id":"2","name":"Bob"},{"id":"3","name":"Charlie"}])
+  )
+  |> RequestHandler.template(
+    "UserController.show",
+    200,
+    "application/json",
+    ~s({"id":"{{id}}","name":"User {{id}}","email":"user{{id}}@example.com"})
+  )
+  |> RequestHandler.template(
+    "UserController.create",
+    201,
+    "application/json",
+    ~s({"status":"created","message":"User created successfully"})
+  )
+  |> RequestHandler.template(
+    "UserController.update",
+    200,
+    "application/json",
+    ~s({"status":"updated","id":"{{id}}"})
+  )
+  |> RequestHandler.template(
+    "UserController.delete",
+    200,
+    "application/json",
+    ~s({"status":"deleted","id":"{{id}}"})
+  )
+  |> RequestHandler.template(
+    "HealthController.check",
+    200,
+    "application/json",
+    ~s({"status":"ok","uptime":"100%","wasm":"active"})
+  )
 
 IO.puts("🛣️  Routes defined:")
 IO.puts("   GET    /")
@@ -90,22 +121,25 @@ requests = [
 ]
 
 for {method, path, description} <- requests do
-  {time_us, {:ok, conn}} = :timer.tc(fn ->
-    RequestHandler.handle(handler, method, path)
-  end)
-
-  status_emoji = cond do
-    conn.status in 200..299 -> "✅"
-    conn.status == 404 -> "🔍"
-    true -> "❌"
-  end
-
-  body_preview = if conn.resp_body do
-    String.slice(conn.resp_body, 0..60)
-    |> String.replace("\n", " ")
-  else
-    "(empty)"
-  end
+  {time_us, {:ok, conn}} =
+    :timer.tc(fn ->
+      RequestHandler.handle(handler, method, path)
+    end)
+
+  status_emoji =
+    cond do
+      conn.status in 200..299 -> "✅"
+      conn.status == 404 -> "🔍"
+      true -> "❌"
+    end
+
+  body_preview =
+    if conn.resp_body do
+      String.slice(conn.resp_body, 0..60)
+      |> String.replace("\n", " ")
+    else
+      "(empty)"
+    end
 
   IO.puts("#{status_emoji} #{method} #{path}")
   IO.puts("   #{description}")
@@ -123,35 +157,49 @@ IO.puts("🔒 WASM Validator Demo\n")
 
 # Valid form
 IO.puts("  Valid user registration:")
-{:ok, result} = Firebird.Phoenix.Validator.validate(validator, %{
-  "name" => "Alice Smith",
-  "email" => "alice@example.com",
-  "age" => "25",
-  "password" => "securepass123"
-}, [
-  {:required, "name"},
-  {:required, "email"},
-  {:required, "password"},
-  {:type, "email", :email},
-  {:type, "age", :integer},
-  {:min_length, "password", 8}
-])
+
+{:ok, result} =
+  Firebird.Phoenix.Validator.validate(
+    validator,
+    %{
+      "name" => "Alice Smith",
+      "email" => "alice@example.com",
+      "age" => "25",
+      "password" => "securepass123"
+    },
+    [
+      {:required, "name"},
+      {:required, "email"},
+      {:required, "password"},
+      {:type, "email", :email},
+      {:type, "age", :integer},
+      {:min_length, "password", 8}
+    ]
+  )
+
 IO.puts("    Result: #{inspect(result)}")
 
 # Invalid form
 IO.puts("\n  Invalid user registration:")
-{:ok, result} = Firebird.Phoenix.Validator.validate(validator, %{
-  "name" => "A",
-  "email" => "not-email",
-  "age" => "abc"
-}, [
-  {:required, "name"},
-  {:required, "email"},
-  {:required, "password"},
-  {:type, "email", :email},
-  {:type, "age", :integer},
-  {:min_length, "name", 2}
-])
+
+{:ok, result} =
+  Firebird.Phoenix.Validator.validate(
+    validator,
+    %{
+      "name" => "A",
+      "email" => "not-email",
+      "age" => "abc"
+    },
+    [
+      {:required, "name"},
+      {:required, "email"},
+      {:required, "password"},
+      {:type, "email", :email},
+      {:type, "age", :integer},
+      {:min_length, "name", 2}
+    ]
+  )
+
 IO.puts("    Result: #{inspect(result)}")
 
 Firebird.Phoenix.Validator.stop(validator)
@@ -162,11 +210,13 @@ IO.puts("\n#{String.duplicate("─", 50)}")
 IO.puts("⚡ Performance Benchmark\n")
 
 iterations = 1000
-{total_us, _} = :timer.tc(fn ->
-  for _ <- 1..iterations do
-    RequestHandler.handle(handler, "GET", "/api/users/42")
-  end
-end)
+
+{total_us, _} =
+  :timer.tc(fn ->
+    for _ <- 1..iterations do
+      RequestHandler.handle(handler, "GET", "/api/users/42")
+    end
+  end)
 
 avg = total_us / iterations
 ops_per_sec = iterations / (total_us / 1_000_000)
@@ -192,4 +242,3 @@ This example demonstrated:
   ✅ Error handling (404 responses)
   ✅ Sub-millisecond request processing
 """)
-
diff --git a/examples/phoenix_wasm_demo.exs b/examples/phoenix_wasm_demo.exs
index 0e7f509..07958a2 100644
--- a/examples/phoenix_wasm_demo.exs
+++ b/examples/phoenix_wasm_demo.exs
@@ -31,7 +31,8 @@ IO.puts("✅ All modules loaded!\n")
 IO.puts("1️⃣  REQUEST LIFECYCLE: Parse → Route → Dispatch")
 IO.puts(String.duplicate("-", 50))
 
-raw_request = "GET /api/users/42 HTTP/1.1\r\nHost: example.com\r\nAccept: application/json\r\nCookie: session=signed_abc.1234567890abcdef\r\n\r\n"
+raw_request =
+  "GET /api/users/42 HTTP/1.1\r\nHost: example.com\r\nAccept: application/json\r\nCookie: session=signed_abc.1234567890abcdef\r\n\r\n"
 
 {:ok, parsed} = Firebird.Phoenix.Plug.parse_request(plug, raw_request)
 IO.puts("  Parsed: #{parsed.method} #{parsed.path}")
@@ -48,12 +49,14 @@ routes = [
 {:ok, match} = Firebird.Phoenix.Router.match(router, parsed.method, parsed.path, routes)
 IO.puts("  Matched: #{match.handler} (params: #{inspect(match.params)})")
 
-{:ok, response} = Firebird.Phoenix.JSON.api_response(json, 200, %{
-  "id" => match.params["id"],
-  "name" => "Alice Johnson",
-  "email" => "alice@example.com",
-  "active" => "true"
-})
+{:ok, response} =
+  Firebird.Phoenix.JSON.api_response(json, 200, %{
+    "id" => match.params["id"],
+    "name" => "Alice Johnson",
+    "email" => "alice@example.com",
+    "active" => "true"
+  })
+
 IO.puts("  Response: #{String.slice(response, 0..80)}...")
 IO.puts("")
 
@@ -67,13 +70,17 @@ eex = "<div class=\"user-card\"><h2><%= @name %></h2><p><%= @email %></p></div>"
 IO.puts("  EEx compiled: #{String.slice(wasm_template, 0..60)}...")
 
 # Render with layout
-layout = "<html><head><title>{{title}}</title></head><body><nav>{{nav}}</nav><main>{{inner_content}}</main></body></html>"
-{:ok, html} = Firebird.Phoenix.View.render_with_layout(view, layout, wasm_template, %{
-  "title" => "User Profile",
-  "nav" => "Home | Users | Settings",
-  "name" => "Alice Johnson",
-  "email" => "alice@example.com"
-})
+layout =
+  "<html><head><title>{{title}}</title></head><body><nav>{{nav}}</nav><main>{{inner_content}}</main></body></html>"
+
+{:ok, html} =
+  Firebird.Phoenix.View.render_with_layout(view, layout, wasm_template, %{
+    "title" => "User Profile",
+    "nav" => "Home | Users | Settings",
+    "name" => "Alice Johnson",
+    "email" => "alice@example.com"
+  })
+
 IO.puts("  Rendered: #{String.slice(html, 0..80)}...")
 IO.puts("")
 
@@ -81,13 +88,21 @@ IO.puts("")
 IO.puts("3️⃣  FORM BUILDING: Form + CSRF + View Helpers")
 IO.puts(String.duplicate("-", 50))
 
-{:ok, form} = Firebird.Phoenix.View.render_form(view, "/users", "POST", [
-  {"text", "name", "", "Full Name"},
-  {"email", "email", "", "Email"},
-  {"password", "password", "", "Password"},
-  {"select", "role", "user:User,admin:Admin,mod:Moderator", "Role"},
-  {"submit", "submit", "Create Account", ""}
-], %{"csrf_token" => "abc_csrf_token_123", "class" => "registration-form"})
+{:ok, form} =
+  Firebird.Phoenix.View.render_form(
+    view,
+    "/users",
+    "POST",
+    [
+      {"text", "name", "", "Full Name"},
+      {"email", "email", "", "Email"},
+      {"password", "password", "", "Password"},
+      {"select", "role", "user:User,admin:Admin,mod:Moderator", "Role"},
+      {"submit", "submit", "Create Account", ""}
+    ],
+    %{"csrf_token" => "abc_csrf_token_123", "class" => "registration-form"}
+  )
+
 IO.puts("  Form: #{String.slice(form, 0..80)}...")
 
 {:ok, link} = Firebird.Phoenix.View.link(view, "Back to Users", "/users", class: "btn")
@@ -101,11 +116,15 @@ IO.puts("4️⃣  SESSION MANAGEMENT: Cookies + Session + Flash")
 IO.puts(String.duplicate("-", 50))
 
 # Parse cookies
-{:ok, cookies} = Firebird.Phoenix.Session.parse_cookies(session, "session_id=abc123; theme=dark; lang=en")
+{:ok, cookies} =
+  Firebird.Phoenix.Session.parse_cookies(session, "session_id=abc123; theme=dark; lang=en")
+
 IO.puts("  Cookies: #{inspect(cookies)}")
 
 # Sign a session cookie
-{:ok, signed} = Firebird.Phoenix.Session.sign_cookie(session, "my_app_secret_key", "user_id=42&role=admin")
+{:ok, signed} =
+  Firebird.Phoenix.Session.sign_cookie(session, "my_app_secret_key", "user_id=42&role=admin")
+
 IO.puts("  Signed: #{signed}")
 
 # Verify it
@@ -113,17 +132,30 @@ IO.puts("  Signed: #{signed}")
 IO.puts("  Verified: #{verified}")
 
 # Encode session
-{:ok, encoded} = Firebird.Phoenix.Session.encode_session(session, %{"user_id" => "42", "role" => "admin"})
+{:ok, encoded} =
+  Firebird.Phoenix.Session.encode_session(session, %{"user_id" => "42", "role" => "admin"})
+
 IO.puts("  Session encoded: #{String.slice(encoded, 0..40)}...")
 
 # Flash messages
-{:ok, flash} = Firebird.Phoenix.Session.flash(session, :put, %{}, %{"info" => "Welcome back, Alice!", "success" => "Profile updated"})
+{:ok, flash} =
+  Firebird.Phoenix.Session.flash(session, :put, %{}, %{
+    "info" => "Welcome back, Alice!",
+    "success" => "Profile updated"
+  })
+
 IO.puts("  Flash: #{inspect(flash)}")
 
 # Build Set-Cookie header
-{:ok, set_cookie} = Firebird.Phoenix.Session.build_cookie(session, "session_id", encoded,
-  path: "/", http_only: true, secure: true, same_site: "Strict", max_age: "86400"
-)
+{:ok, set_cookie} =
+  Firebird.Phoenix.Session.build_cookie(session, "session_id", encoded,
+    path: "/",
+    http_only: true,
+    secure: true,
+    same_site: "Strict",
+    max_age: "86400"
+  )
+
 IO.puts("  Set-Cookie: #{String.slice(set_cookie, 0..60)}...")
 IO.puts("")
 
@@ -137,26 +169,53 @@ patterns = [
   {"notification:*", "NotificationChannel"}
 ]
 
-{:ok, %{handler: handler, params: params}} = Firebird.Phoenix.Channel.match_topic(channel, "room:lobby", patterns)
+{:ok, %{handler: handler, params: params}} =
+  Firebird.Phoenix.Channel.match_topic(channel, "room:lobby", patterns)
+
 IO.puts("  Topic matched: #{handler} (#{inspect(params)})")
 
-{:ok, msg_json} = Firebird.Phoenix.Channel.serialize_message(channel, "room:lobby", "new_msg", %{
-  "body" => "Hello everyone!",
-  "sender" => "alice",
-  "timestamp" => "1709100000"
-}, "ref_42")
+{:ok, msg_json} =
+  Firebird.Phoenix.Channel.serialize_message(
+    channel,
+    "room:lobby",
+    "new_msg",
+    %{
+      "body" => "Hello everyone!",
+      "sender" => "alice",
+      "timestamp" => "1709100000"
+    },
+    "ref_42"
+  )
+
 IO.puts("  Message: #{String.slice(msg_json, 0..80)}...")
 
-{:ok, broadcast} = Firebird.Phoenix.Channel.build_broadcast(channel, "room:lobby", "user_joined", %{
-  "user" => "alice",
-  "online_count" => "5"
-})
+{:ok, broadcast} =
+  Firebird.Phoenix.Channel.build_broadcast(channel, "room:lobby", "user_joined", %{
+    "user" => "alice",
+    "online_count" => "5"
+  })
+
 IO.puts("  Broadcast: #{String.slice(broadcast, 0..80)}...")
 
 # Presence tracking
-{:ok, state1} = Firebird.Phoenix.Channel.track_presence(channel, :join, "user:1", %{}, %{"name" => "Alice", "status" => "online"})
-{:ok, state2} = Firebird.Phoenix.Channel.track_presence(channel, :join, "user:2", state1, %{"name" => "Bob", "status" => "online"})
-{:ok, state3} = Firebird.Phoenix.Channel.track_presence(channel, :join, "user:3", state2, %{"name" => "Charlie", "status" => "away"})
+{:ok, state1} =
+  Firebird.Phoenix.Channel.track_presence(channel, :join, "user:1", %{}, %{
+    "name" => "Alice",
+    "status" => "online"
+  })
+
+{:ok, state2} =
+  Firebird.Phoenix.Channel.track_presence(channel, :join, "user:2", state1, %{
+    "name" => "Bob",
+    "status" => "online"
+  })
+
+{:ok, state3} =
+  Firebird.Phoenix.Channel.track_presence(channel, :join, "user:3", state2, %{
+    "name" => "Charlie",
+    "status" => "away"
+  })
+
 IO.puts("  Presence: #{map_size(state3)} users online")
 IO.puts("")
 
@@ -164,12 +223,19 @@ IO.puts("")
 IO.puts("6️⃣  LIVEVIEW: Component Render → Diff → Patch")
 IO.puts(String.duplicate("-", 50))
 
-{:ok, component} = Firebird.Phoenix.Live.render_component(live, "user-list",
-  "<div class=\"users\">{{children}}</div>", %{}, [
-    {"user-1", "<div class=\"user\">Alice (online)</div>"},
-    {"user-2", "<div class=\"user\">Bob (online)</div>"},
-    {"user-3", "<div class=\"user\">Charlie (away)</div>"}
-  ])
+{:ok, component} =
+  Firebird.Phoenix.Live.render_component(
+    live,
+    "user-list",
+    "<div class=\"users\">{{children}}</div>",
+    %{},
+    [
+      {"user-1", "<div class=\"user\">Alice (online)</div>"},
+      {"user-2", "<div class=\"user\">Bob (online)</div>"},
+      {"user-3", "<div class=\"user\">Charlie (away)</div>"}
+    ]
+  )
+
 IO.puts("  Component: #{String.slice(component, 0..80)}...")
 
 # Check for changes
@@ -186,10 +252,13 @@ IO.puts("")
 IO.puts("7️⃣  ENDPOINT PIPELINE: Security → CORS → Dispatch")
 IO.puts(String.duplicate("-", 50))
 
-{:ok, conn} = Firebird.Phoenix.Endpoint.execute_pipeline(endpoint,
-  "GET /api/data HTTP/1.1\r\nHost: example.com\r\nAccept: application/json\r\nAuthorization: Bearer token123\r\n\r\n",
-  ["put_secure_headers", "cors:*", "require_header:authorization"]
-)
+{:ok, conn} =
+  Firebird.Phoenix.Endpoint.execute_pipeline(
+    endpoint,
+    "GET /api/data HTTP/1.1\r\nHost: example.com\r\nAccept: application/json\r\nAuthorization: Bearer token123\r\n\r\n",
+    ["put_secure_headers", "cors:*", "require_header:authorization"]
+  )
+
 IO.puts("  Security: X-Frame-Options=#{conn.resp_headers["x-frame-options"]}")
 IO.puts("  CORS: #{conn.resp_headers["access-control-allow-origin"]}")
 IO.puts("  Pipeline halted: #{conn.halted}")
@@ -199,9 +268,15 @@ IO.puts("")
 IO.puts("8️⃣  JSON API: Paginated Response")
 IO.puts(String.duplicate("-", 50))
 
-users = Enum.map(1..5, fn i ->
-  %{"id" => "#{i}", "name" => "User #{i}", "email" => "user#{i}@example.com", "active" => "true"}
-end)
+users =
+  Enum.map(1..5, fn i ->
+    %{
+      "id" => "#{i}",
+      "name" => "User #{i}",
+      "email" => "user#{i}@example.com",
+      "active" => "true"
+    }
+  end)
 
 {:ok, paginated} = Firebird.Phoenix.JSON.api_paginated(json, 1, 20, 150, users)
 IO.puts("  Paginated: #{String.slice(paginated, 0..100)}...")
@@ -211,15 +286,19 @@ IO.puts("")
 IO.puts(String.duplicate("=", 50))
 IO.puts("📦 WASM Module Sizes:")
 total = 0
-for module <- ~w(phoenix_router phoenix_template phoenix_plug phoenix_endpoint phoenix_view phoenix_channel phoenix_json phoenix_live phoenix_session) do
+
+for module <-
+      ~w(phoenix_router phoenix_template phoenix_plug phoenix_endpoint phoenix_view phoenix_channel phoenix_json phoenix_live phoenix_session) do
   path = Path.join(fixtures_dir, "#{module}.wasm")
+
   if File.exists?(path) do
     size = File.stat!(path).size
     IO.puts("  #{String.pad_trailing(module <> ".wasm", 28)} #{Float.round(size / 1024, 1)} KB")
   end
 end
 
-total_size = ~w(phoenix_router phoenix_template phoenix_plug phoenix_endpoint phoenix_view phoenix_channel phoenix_json phoenix_live phoenix_session)
+total_size =
+  ~w(phoenix_router phoenix_template phoenix_plug phoenix_endpoint phoenix_view phoenix_channel phoenix_json phoenix_live phoenix_session)
   |> Enum.map(fn m -> Path.join(fixtures_dir, "#{m}.wasm") end)
   |> Enum.filter(&File.exists?/1)
   |> Enum.map(fn p -> File.stat!(p).size end)
diff --git a/examples/phoenix_wasm_full_app.exs b/examples/phoenix_wasm_full_app.exs
index 910846a..9ecd873 100644
--- a/examples/phoenix_wasm_full_app.exs
+++ b/examples/phoenix_wasm_full_app.exs
@@ -31,34 +31,51 @@ IO.puts("2. Building request handler with routes and middleware...")
 csrf_token = CSRF.generate_token()
 
 {:ok, handler} = RequestHandler.new(components: components)
-handler = handler
-# Middleware
-|> RequestHandler.use_middleware(Middleware.request_id())
-|> RequestHandler.use_middleware(Middleware.timer())
-# Routes
-|> RequestHandler.route("GET", "/", "Page.index")
-|> RequestHandler.route("GET", "/users", "User.index")
-|> RequestHandler.route("GET", "/users/:id", "User.show")
-|> RequestHandler.route("POST", "/users", "User.create")
-|> RequestHandler.route("PUT", "/users/:id", "User.update")
-|> RequestHandler.route("DELETE", "/users/:id", "User.delete")
-|> RequestHandler.route("GET", "/api/health", "Health.check")
-# Templates
-|> RequestHandler.template("Page.index", 200, "text/html",
-    "<html><body><h1>Welcome to Firebird</h1><p>Phoenix WASM Demo</p></body></html>")
-|> RequestHandler.template("User.index", 200, "application/json",
-    ~s([{"id":"1","name":"Alice"},{"id":"2","name":"Bob"}]))
-|> RequestHandler.template("User.show", 200, "application/json",
-    ~s({"id":"{{id}}","name":"User {{id}}"}))
-|> RequestHandler.template("User.create", 201, "application/json",
-    ~s({"status":"created"}))
-|> RequestHandler.template("User.update", 200, "application/json",
-    ~s({"id":"{{id}}","status":"updated"}))
-|> RequestHandler.template("User.delete", 204, "text/plain", "")
-# Dynamic actions
-|> RequestHandler.action("Health.check", fn _params ->
-  {200, "application/json", ~s({"status":"healthy","components":#{running}})}
-end)
+
+handler =
+  handler
+  # Middleware
+  |> RequestHandler.use_middleware(Middleware.request_id())
+  |> RequestHandler.use_middleware(Middleware.timer())
+  # Routes
+  |> RequestHandler.route("GET", "/", "Page.index")
+  |> RequestHandler.route("GET", "/users", "User.index")
+  |> RequestHandler.route("GET", "/users/:id", "User.show")
+  |> RequestHandler.route("POST", "/users", "User.create")
+  |> RequestHandler.route("PUT", "/users/:id", "User.update")
+  |> RequestHandler.route("DELETE", "/users/:id", "User.delete")
+  |> RequestHandler.route("GET", "/api/health", "Health.check")
+  # Templates
+  |> RequestHandler.template(
+    "Page.index",
+    200,
+    "text/html",
+    "<html><body><h1>Welcome to Firebird</h1><p>Phoenix WASM Demo</p></body></html>"
+  )
+  |> RequestHandler.template(
+    "User.index",
+    200,
+    "application/json",
+    ~s([{"id":"1","name":"Alice"},{"id":"2","name":"Bob"}])
+  )
+  |> RequestHandler.template(
+    "User.show",
+    200,
+    "application/json",
+    ~s({"id":"{{id}}","name":"User {{id}}"})
+  )
+  |> RequestHandler.template("User.create", 201, "application/json", ~s({"status":"created"}))
+  |> RequestHandler.template(
+    "User.update",
+    200,
+    "application/json",
+    ~s({"id":"{{id}}","status":"updated"})
+  )
+  |> RequestHandler.template("User.delete", 204, "text/plain", "")
+  # Dynamic actions
+  |> RequestHandler.action("Health.check", fn _params ->
+    {200, "application/json", ~s({"status":"healthy","components":#{running}})}
+  end)
 
 IO.puts("   ✅ 7 routes configured\n")
 
@@ -74,17 +91,20 @@ requests = [
   {"PUT", "/users/1", []},
   {"DELETE", "/users/1", []},
   {"GET", "/api/health", []},
-  {"GET", "/nonexistent", []},
+  {"GET", "/nonexistent", []}
 ]
 
 for {method, path, opts} <- requests do
   {:ok, conn} = RequestHandler.handle(handler, method, path, opts)
-  status_emoji = cond do
-    conn.status < 300 -> "✅"
-    conn.status < 400 -> "↗️"
-    conn.status < 500 -> "⚠️"
-    true -> "❌"
-  end
+
+  status_emoji =
+    cond do
+      conn.status < 300 -> "✅"
+      conn.status < 400 -> "↗️"
+      conn.status < 500 -> "⚠️"
+      true -> "❌"
+    end
+
   body_preview = String.slice(conn.resp_body, 0..50)
   IO.puts("   #{status_emoji} #{method} #{path} → #{conn.status} #{body_preview}")
 end
@@ -93,17 +113,19 @@ end
 
 IO.puts("\n4. Generating HTML forms...")
 
-form = [
-  Form.form_for("user", "/users", method: :post, csrf_token: csrf_token),
-  Form.label("user", "name", "Name"),
-  Form.text_input("user", "name", required: true, class: "form-control"),
-  Form.label("user", "email", "Email"),
-  Form.email_input("user", "email", placeholder: "user@example.com"),
-  Form.select("user", "role", ["admin", "user", "guest"], selected: "user"),
-  Form.checkbox("user", "active", checked: true),
-  Form.submit("Create User", class: "btn btn-primary"),
-  Form.end_form()
-] |> Enum.join("\n")
+form =
+  [
+    Form.form_for("user", "/users", method: :post, csrf_token: csrf_token),
+    Form.label("user", "name", "Name"),
+    Form.text_input("user", "name", required: true, class: "form-control"),
+    Form.label("user", "email", "Email"),
+    Form.email_input("user", "email", placeholder: "user@example.com"),
+    Form.select("user", "role", ["admin", "user", "guest"], selected: "user"),
+    Form.checkbox("user", "active", checked: true),
+    Form.submit("Create User", class: "btn btn-primary"),
+    Form.end_form()
+  ]
+  |> Enum.join("\n")
 
 IO.puts("   ✅ Form generated (#{byte_size(form)} bytes)")
 IO.puts("   CSRF token: #{String.slice(csrf_token, 0..15)}...")
@@ -111,6 +133,7 @@ IO.puts("   CSRF token: #{String.slice(csrf_token, 0..15)}...")
 # ─── 5. CSRF validation ───
 
 IO.puts("\n5. CSRF token validation...")
+
 assert_result = fn
   :valid -> "✅ valid"
   :invalid -> "❌ invalid"
@@ -120,6 +143,7 @@ IO.puts("   Correct token: #{assert_result.(CSRF.validate(csrf_token, csrf_token
 IO.puts("   Wrong token:   #{assert_result.(CSRF.validate("wrong", csrf_token))}")
 
 signed = CSRF.generate_signed_token(secret: "app-secret")
+
 case CSRF.validate_signed(signed, secret: "app-secret") do
   {:ok, _} -> IO.puts("   Signed token:  ✅ verified")
   _ -> IO.puts("   Signed token:  ❌ failed")
@@ -141,8 +165,11 @@ if WebSocket.upgrade_request?(ws_headers) do
 end
 
 # Channel message roundtrip
-frame = WebSocket.encode_channel_message("room:lobby", "new_msg",
-  %{"body" => "Hello from WASM!"}, ref: "1")
+frame =
+  WebSocket.encode_channel_message("room:lobby", "new_msg", %{"body" => "Hello from WASM!"},
+    ref: "1"
+  )
+
 {:ok, {:text, json}, <<>>} = WebSocket.decode_frame(frame)
 {:ok, msg} = WebSocket.decode_channel_message(json)
 IO.puts("   ✅ Channel message: #{msg.topic} / #{msg.event} → #{inspect(msg.payload)}")
@@ -151,39 +178,48 @@ IO.puts("   ✅ Channel message: #{msg.topic} / #{msg.event} → #{inspect(msg.p
 
 IO.puts("\n7. Rate limiting demo...")
 
-{_, _} = Enum.reduce(1..5, {RateLimiter.new(rate: 3, period: :minute, burst: 3), 0}, fn i, {limiter, _} ->
-  case RateLimiter.check(limiter, "demo-client") do
-    {:ok, new_limiter, remaining} ->
-      IO.puts("   Request #{i}: ✅ allowed (#{remaining} remaining)")
-      {new_limiter, remaining}
-    {:error, :rate_limited, new_limiter, retry_after} ->
-      IO.puts("   Request #{i}: 🚫 rate limited (retry after #{retry_after}ms)")
-      {new_limiter, retry_after}
-  end
-end)
+{_, _} =
+  Enum.reduce(1..5, {RateLimiter.new(rate: 3, period: :minute, burst: 3), 0}, fn i,
+                                                                                 {limiter, _} ->
+    case RateLimiter.check(limiter, "demo-client") do
+      {:ok, new_limiter, remaining} ->
+        IO.puts("   Request #{i}: ✅ allowed (#{remaining} remaining)")
+        {new_limiter, remaining}
+
+      {:error, :rate_limited, new_limiter, retry_after} ->
+        IO.puts("   Request #{i}: 🚫 rate limited (retry after #{retry_after}ms)")
+        {new_limiter, retry_after}
+    end
+  end)
 
 # ─── 8. WASM component benchmarks ───
 
 IO.puts("\n8. Quick performance check...")
 
-{time, _} = :timer.tc(fn ->
-  for _ <- 1..1000 do
-    RequestHandler.handle(handler, "GET", "/users/42")
-  end
-end)
+{time, _} =
+  :timer.tc(fn ->
+    for _ <- 1..1000 do
+      RequestHandler.handle(handler, "GET", "/users/42")
+    end
+  end)
+
 per_request = Float.round(time / 1000, 1)
 rps = Float.round(1_000_000 / per_request)
 IO.puts("   Full request lifecycle: #{per_request} µs/request (#{trunc(rps)} req/s)")
 
 if components[:router] do
-  {:ok, _} = Firebird.Phoenix.Router.compile(components[:router], [
-    {"GET", "/users/:id", "User.show"}
-  ])
-  {time, _} = :timer.tc(fn ->
-    for _ <- 1..1000 do
-      Firebird.Phoenix.Router.match_compiled(components[:router], "GET", "/users/42")
-    end
-  end)
+  {:ok, _} =
+    Firebird.Phoenix.Router.compile(components[:router], [
+      {"GET", "/users/:id", "User.show"}
+    ])
+
+  {time, _} =
+    :timer.tc(fn ->
+      for _ <- 1..1000 do
+        Firebird.Phoenix.Router.match_compiled(components[:router], "GET", "/users/42")
+      end
+    end)
+
   IO.puts("   Compiled route match:   #{Float.round(time / 1000, 1)} µs/match")
 end
 
diff --git a/examples/phoenix_wasm_server.exs b/examples/phoenix_wasm_server.exs
index f4407a0..144c21a 100644
--- a/examples/phoenix_wasm_server.exs
+++ b/examples/phoenix_wasm_server.exs
@@ -27,65 +27,65 @@ routes = [
   {"POST", "/api/users", "UserController.create"},
   {"PUT", "/api/users/:id", "UserController.update"},
   {"DELETE", "/api/users/:id", "UserController.delete"},
-  {"GET", "/health", "HealthController.check"},
+  {"GET", "/health", "HealthController.check"}
 ]
 
 # Define actions (handler => {status, content_type, body_template})
 actions = %{
-  "PageController.index" => {200, "text/html", """
-  <!DOCTYPE html>
-  <html>
-  <head><title>Phoenix WASM</title></head>
-  <body>
-    <h1>🔥 Welcome to Phoenix WASM!</h1>
-    <p>This page is served through WebAssembly-accelerated Phoenix components.</p>
-    <h2>API Endpoints</h2>
-    <ul>
-      <li><a href="/api/users">GET /api/users</a> - List users</li>
-      <li><a href="/api/users/42">GET /api/users/42</a> - Show user</li>
-      <li>POST /api/users - Create user</li>
-      <li><a href="/health">GET /health</a> - Health check</li>
-    </ul>
-    <h2>Architecture</h2>
-    <pre>
-    Request → gen_tcp → WASM Router → WASM Template → WASM Plug → Response
-    </pre>
-  </body>
-  </html>
-  """},
-
-  "PageController.about" => {200, "text/html", """
-  <html><body>
-    <h1>About Phoenix WASM</h1>
-    <p>All request processing happens in WebAssembly modules compiled from Rust.</p>
-    <a href="/">← Back</a>
-  </body></html>
-  """},
-
-  "UserController.index" => {200, "application/json",
-    ~s([{"id":1,"name":"Alice","email":"alice@example.com"},{"id":2,"name":"Bob","email":"bob@example.com"},{"id":3,"name":"Charlie","email":"charlie@example.com"}])},
-
-  "UserController.show" => {200, "application/json",
-    ~s({"id":"{{id}}","name":"User {{id}}","email":"user{{id}}@example.com"})},
-
-  "UserController.create" => {201, "application/json",
-    ~s({"id":"4","name":"New User","status":"created"})},
-
-  "UserController.update" => {200, "application/json",
-    ~s({"id":"{{id}}","status":"updated"})},
-
+  "PageController.index" =>
+    {200, "text/html",
+     """
+     <!DOCTYPE html>
+     <html>
+     <head><title>Phoenix WASM</title></head>
+     <body>
+       <h1>🔥 Welcome to Phoenix WASM!</h1>
+       <p>This page is served through WebAssembly-accelerated Phoenix components.</p>
+       <h2>API Endpoints</h2>
+       <ul>
+         <li><a href="/api/users">GET /api/users</a> - List users</li>
+         <li><a href="/api/users/42">GET /api/users/42</a> - Show user</li>
+         <li>POST /api/users - Create user</li>
+         <li><a href="/health">GET /health</a> - Health check</li>
+       </ul>
+       <h2>Architecture</h2>
+       <pre>
+       Request → gen_tcp → WASM Router → WASM Template → WASM Plug → Response
+       </pre>
+     </body>
+     </html>
+     """},
+  "PageController.about" =>
+    {200, "text/html",
+     """
+     <html><body>
+       <h1>About Phoenix WASM</h1>
+       <p>All request processing happens in WebAssembly modules compiled from Rust.</p>
+       <a href="/">← Back</a>
+     </body></html>
+     """},
+  "UserController.index" =>
+    {200, "application/json",
+     ~s([{"id":1,"name":"Alice","email":"alice@example.com"},{"id":2,"name":"Bob","email":"bob@example.com"},{"id":3,"name":"Charlie","email":"charlie@example.com"}])},
+  "UserController.show" =>
+    {200, "application/json",
+     ~s({"id":"{{id}}","name":"User {{id}}","email":"user{{id}}@example.com"})},
+  "UserController.create" =>
+    {201, "application/json", ~s({"id":"4","name":"New User","status":"created"})},
+  "UserController.update" => {200, "application/json", ~s({"id":"{{id}}","status":"updated"})},
   "UserController.delete" => {204, "application/json", ""},
-
-  "HealthController.check" => {200, "application/json",
-    ~s({"status":"ok","engine":"wasm","components":["router","template","plug","endpoint"]})},
+  "HealthController.check" =>
+    {200, "application/json",
+     ~s({"status":"ok","engine":"wasm","components":["router","template","plug","endpoint"]})}
 }
 
 # Start the server
-{:ok, server} = Firebird.Phoenix.Server.start_link(
-  port: 4001,
-  routes: routes,
-  actions: actions
-)
+{:ok, server} =
+  Firebird.Phoenix.Server.start_link(
+    port: 4001,
+    routes: routes,
+    actions: actions
+  )
 
 IO.puts("""
 ✅ Server started on http://localhost:4001
diff --git a/examples/pipeline_and_batch.exs b/examples/pipeline_and_batch.exs
index d4e6830..2d62fe3 100644
--- a/examples/pipeline_and_batch.exs
+++ b/examples/pipeline_and_batch.exs
@@ -23,8 +23,10 @@ IO.puts("── 1.1 Basic pipeline ──")
 
 result =
   Pipeline.new(wasm)
-  |> Pipeline.call(:add, [5, 3])           # => 8
-  |> Pipeline.call(:multiply, [:_, 2])     # => 8 * 2 = 16
+  # => 8
+  |> Pipeline.call(:add, [5, 3])
+  # => 8 * 2 = 16
+  |> Pipeline.call(:multiply, [:_, 2])
   |> Pipeline.run!()
 
 IO.puts("   add(5, 3) |> multiply(_, 2) = #{inspect(result)}")
@@ -36,8 +38,10 @@ IO.puts("\n── 1.2 Longer chain ──")
 
 result =
   Pipeline.new(wasm)
-  |> Pipeline.call(:add, [3, 7])           # => 10
-  |> Pipeline.call(:fibonacci, [:_])       # => fib(10) = 55
+  # => 10
+  |> Pipeline.call(:add, [3, 7])
+  # => fib(10) = 55
+  |> Pipeline.call(:fibonacci, [:_])
   |> Pipeline.run!()
 
 IO.puts("   add(3, 7) |> fibonacci(_) = #{inspect(result)}")
@@ -49,9 +53,12 @@ IO.puts("\n── 1.3 Transform — Elixir logic between WASM calls ──")
 
 result =
   Pipeline.new(wasm)
-  |> Pipeline.call(:add, [10, 20])                      # => [30]
-  |> Pipeline.transform(fn [x] -> [x, x] end)           # => [30, 30]
-  |> Pipeline.call(:multiply, [:_, :_])                  # => 30 * 30 = 900
+  # => [30]
+  |> Pipeline.call(:add, [10, 20])
+  # => [30, 30]
+  |> Pipeline.transform(fn [x] -> [x, x] end)
+  # => 30 * 30 = 900
+  |> Pipeline.call(:multiply, [:_, :_])
   |> Pipeline.run!()
 
 IO.puts("   add(10, 20) |> dup |> multiply(_, _) = #{inspect(result)}")
@@ -95,16 +102,20 @@ IO.puts("\n── 1.6 Pattern — compute then validate ──")
 # Check if a computed result is prime
 result =
   Pipeline.new(wasm)
-  |> Pipeline.call(:add, [4, 3])           # => 7
-  |> Pipeline.call(:is_prime, [:_])        # => 1 (true)
+  # => 7
+  |> Pipeline.call(:add, [4, 3])
+  # => 1 (true)
+  |> Pipeline.call(:is_prime, [:_])
   |> Pipeline.run!()
 
 IO.puts("   add(4, 3) |> is_prime(_) = #{inspect(result)} (1 = prime)")
 
 result =
   Pipeline.new(wasm)
-  |> Pipeline.call(:add, [4, 4])           # => 8
-  |> Pipeline.call(:is_prime, [:_])        # => 0 (false)
+  # => 8
+  |> Pipeline.call(:add, [4, 4])
+  # => 0 (false)
+  |> Pipeline.call(:is_prime, [:_])
   |> Pipeline.run!()
 
 IO.puts("   add(4, 4) |> is_prime(_) = #{inspect(result)} (0 = not prime)")
@@ -117,11 +128,13 @@ Firebird.stop(wasm)
 
 IO.puts("\n\n── Part 2: Batch Processing ──────────────────────────────────\n")
 
-{:ok, _pool} = Firebird.Pool.start_link(
-  wasm: "fixtures/math.wasm",
-  size: 4,
-  name: :batch_pool
-)
+{:ok, _pool} =
+  Firebird.Pool.start_link(
+    wasm: "fixtures/math.wasm",
+    size: 4,
+    name: :batch_pool
+  )
+
 IO.puts("✓ Pool started with 4 instances\n")
 
 alias Firebird.Batch
@@ -130,13 +143,14 @@ alias Firebird.Batch
 
 IO.puts("── 2.1 Batch.run — mixed function calls ──")
 
-results = Batch.run(:batch_pool, [
-  {:add, [10, 20]},
-  {:multiply, [6, 7]},
-  {:fibonacci, [10]},
-  {:factorial, [5]},
-  {:is_prime, [17]}
-])
+results =
+  Batch.run(:batch_pool, [
+    {:add, [10, 20]},
+    {:multiply, [6, 7]},
+    {:fibonacci, [10]},
+    {:factorial, [5]},
+    {:is_prime, [17]}
+  ])
 
 for {result, i} <- Enum.with_index(results) do
   case result do
@@ -162,6 +176,7 @@ IO.puts("\n── 2.3 Batch.pmap — safe parallel map ──")
 case Batch.pmap(:batch_pool, :add, [[1, 2], [3, 4], [5, 6]]) do
   {:ok, results} ->
     IO.puts("   ✓ All succeeded: #{inspect(Enum.map(results, fn [x] -> x end))}")
+
   {:error, errors} ->
     IO.puts("   ✗ Errors at indices: #{inspect(errors)}")
 end
@@ -184,11 +199,14 @@ IO.puts("   Throughput:        #{stats.calls_per_second} calls/sec")
 
 IO.puts("\n── 2.5 Error resilience — errors don't stop other calls ──")
 
-results = Batch.run(:batch_pool, [
-  {:add, [1, 2]},
-  {:nonexistent, [42]},    # this will fail
-  {:multiply, [3, 4]},     # this still runs
-])
+results =
+  Batch.run(:batch_pool, [
+    {:add, [1, 2]},
+    # this will fail
+    {:nonexistent, [42]},
+    # this still runs
+    {:multiply, [3, 4]}
+  ])
 
 for {result, i} <- Enum.with_index(results) do
   case result do
@@ -217,14 +235,17 @@ results =
   for n <- inputs do
     [result] =
       Pipeline.new(wasm)
-      |> Pipeline.call(:fibonacci, [n])       # compute fib(n)
-      |> Pipeline.call(:multiply, [:_, 2])    # double it
+      # compute fib(n)
+      |> Pipeline.call(:fibonacci, [n])
+      # double it
+      |> Pipeline.call(:multiply, [:_, 2])
       |> Pipeline.run!()
 
     {n, result}
   end
 
 IO.puts("   fib(n) * 2 for each input:")
+
 for {n, result} <- results do
   IO.puts("     n=#{n} → fib(#{n})*2 = #{result}")
 end
diff --git a/examples/pool_usage.exs b/examples/pool_usage.exs
index 8b8166b..7d02155 100644
--- a/examples/pool_usage.exs
+++ b/examples/pool_usage.exs
@@ -4,11 +4,12 @@
 IO.puts("🔥 Firebird.Pool Concurrent Usage\n")
 
 # Start a pool of 4 instances
-{:ok, _pool} = Firebird.Pool.start_link(
-  wasm: "fixtures/math.wasm",
-  size: 4,
-  name: :math_pool
-)
+{:ok, _pool} =
+  Firebird.Pool.start_link(
+    wasm: "fixtures/math.wasm",
+    size: 4,
+    name: :math_pool
+  )
 
 status = Firebird.Pool.status(:math_pool)
 IO.puts("✓ Pool started: #{status.size} instances, #{status.alive} alive")
@@ -28,6 +29,7 @@ tasks =
 
 results = Task.await_many(tasks)
 IO.puts("✓ Concurrent fibonacci results:")
+
 for {n, result} <- Enum.sort(results) do
   IO.puts("    fib(#{n}) = #{result}")
 end
diff --git a/examples/profiling_and_metrics.exs b/examples/profiling_and_metrics.exs
index 1950512..0ed469f 100644
--- a/examples/profiling_and_metrics.exs
+++ b/examples/profiling_and_metrics.exs
@@ -19,9 +19,10 @@ IO.puts("── 1. Quick Timing ──\n")
 
 wasm = Firebird.load!(wasm_path)
 
-{time_us, {:ok, [result]}} = :timer.tc(fn ->
-  Firebird.call(wasm, :fibonacci, [30])
-end)
+{time_us, {:ok, [result]}} =
+  :timer.tc(fn ->
+    Firebird.call(wasm, :fibonacci, [30])
+  end)
 
 IO.puts("  fibonacci(30) = #{result}")
 IO.puts("  Time: #{time_us}μs (#{Float.round(time_us / 1000, 2)}ms)\n")
@@ -34,10 +35,11 @@ Firebird.stop(wasm)
 
 IO.puts("── 2. Profiler (Detailed Stats) ──\n")
 
-profile = Firebird.Profiler.profile(wasm_path, :add, [5, 3],
-  iterations: 500,
-  warmup: 50
-)
+profile =
+  Firebird.Profiler.profile(wasm_path, :add, [5, 3],
+    iterations: 500,
+    warmup: 50
+  )
 
 IO.puts("  Function: #{profile.function}")
 IO.puts("  Iterations: #{profile.count}")
@@ -58,7 +60,11 @@ IO.puts("── 3. Startup Profiling ──\n")
 startup = Firebird.Profiler.profile_startup(wasm_path, iterations: 20)
 
 IO.puts("  WASM load time:")
-IO.puts("  Avg:    #{Float.round(startup.avg_us, 1)}μs (#{Float.round(startup.avg_us / 1000, 2)}ms)")
+
+IO.puts(
+  "  Avg:    #{Float.round(startup.avg_us, 1)}μs (#{Float.round(startup.avg_us / 1000, 2)}ms)"
+)
+
 IO.puts("  Min:    #{startup.min_us}μs")
 IO.puts("  Max:    #{startup.max_us}μs\n")
 
@@ -90,9 +96,7 @@ IO.puts("")
 
 IO.puts("── 5. Throughput ──\n")
 
-throughput = Firebird.Profiler.throughput(wasm_path, :add, [5, 3],
-  duration_ms: 1000
-)
+throughput = Firebird.Profiler.throughput(wasm_path, :add, [5, 3], duration_ms: 1000)
 
 IO.puts("  #{throughput.function}: #{Float.round(throughput.calls_per_second, 0)} calls/sec")
 IO.puts("  Total calls in #{throughput.duration_ms}ms: #{throughput.total_calls}")
@@ -128,12 +132,14 @@ metrics = Firebird.Metrics.report()
 IO.puts("  Collected metrics for #{map_size(metrics)} functions:\n")
 
 for {func, stats} <- Enum.sort_by(metrics, fn {_, s} -> s.calls end, :desc) do
-  IO.puts("  #{String.pad_trailing(func, 15)} " <>
-    "calls=#{String.pad_leading("#{stats.calls}", 4)}  " <>
-    "avg=#{String.pad_leading("#{Float.round(stats.avg_us, 1)}", 7)}μs  " <>
-    "min=#{String.pad_leading("#{stats.min_us}", 5)}μs  " <>
-    "max=#{String.pad_leading("#{stats.max_us}", 5)}μs  " <>
-    "errors=#{stats.errors}")
+  IO.puts(
+    "  #{String.pad_trailing(func, 15)} " <>
+      "calls=#{String.pad_leading("#{stats.calls}", 4)}  " <>
+      "avg=#{String.pad_leading("#{Float.round(stats.avg_us, 1)}", 7)}μs  " <>
+      "min=#{String.pad_leading("#{stats.min_us}", 5)}μs  " <>
+      "max=#{String.pad_leading("#{stats.max_us}", 5)}μs  " <>
+      "errors=#{stats.errors}"
+  )
 end
 
 IO.puts("")
@@ -162,16 +168,18 @@ n = 25
 iterations = 500
 
 # Benchmark WASM
-wasm_times = for _ <- 1..iterations do
-  {t, _} = :timer.tc(fn -> Firebird.call_one!(wasm, :fibonacci, [n]) end)
-  t
-end
+wasm_times =
+  for _ <- 1..iterations do
+    {t, _} = :timer.tc(fn -> Firebird.call_one!(wasm, :fibonacci, [n]) end)
+    t
+  end
 
 # Benchmark Elixir
-elixir_times = for _ <- 1..iterations do
-  {t, _} = :timer.tc(fn -> elixir_fib.(n) end)
-  t
-end
+elixir_times =
+  for _ <- 1..iterations do
+    {t, _} = :timer.tc(fn -> elixir_fib.(n) end)
+    t
+  end
 
 wasm_avg = Enum.sum(wasm_times) / iterations
 elixir_avg = Enum.sum(elixir_times) / iterations
diff --git a/examples/quick_start.exs b/examples/quick_start.exs
index 2de4e3c..f332687 100644
--- a/examples/quick_start.exs
+++ b/examples/quick_start.exs
@@ -50,11 +50,13 @@ IO.puts("   Stopped.")
 # ============================================================
 IO.puts("\n── 4. with_instance (auto-cleanup) ──")
 
-{:ok, result} = Firebird.with_instance("math.wasm", fn wasm ->
-  {:ok, [a]} = Firebird.call(wasm, :add, [10, 20])
-  {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 3])
-  b
-end)
+{:ok, result} =
+  Firebird.with_instance("math.wasm", fn wasm ->
+    {:ok, [a]} = Firebird.call(wasm, :add, [10, 20])
+    {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 3])
+    b
+  end)
+
 IO.puts("   (10 + 20) * 3 = #{result}")
 
 # ============================================================
@@ -72,13 +74,19 @@ Firebird.stop(wasm)
 # ============================================================
 IO.puts("\n── 6. Inline WAT ──")
 
-result = Firebird.quick("""
-(module
-  (func (export "triple") (param i32) (result i32)
-    local.get 0
-    i32.const 3
-    i32.mul))
-""", :triple, [14])
+result =
+  Firebird.quick(
+    """
+    (module
+      (func (export "triple") (param i32) (result i32)
+        local.get 0
+        i32.const 3
+        i32.mul))
+    """,
+    :triple,
+    [14]
+  )
+
 IO.puts("   triple(14) = #{result}")
 
 # ============================================================
@@ -88,6 +96,7 @@ IO.puts("\n── 7. Explore a WASM file ──")
 
 fns = Firebird.list_functions("math.wasm")
 IO.puts("   Functions in math.wasm:")
+
 for f <- fns do
   params = f.params |> Enum.map(&to_string/1) |> Enum.join(", ")
   results = f.results |> Enum.map(&to_string/1) |> Enum.join(", ")
diff --git a/examples/stream_processing.exs b/examples/stream_processing.exs
index bd8385c..a1e4373 100644
--- a/examples/stream_processing.exs
+++ b/examples/stream_processing.exs
@@ -138,17 +138,21 @@ readings = [10, 25, 42, 7, 99, 3, 55]
 
 processed =
   readings
-  |> Firebird.Stream.map(wasm, :fibonacci)   # transform each reading
-  |> Stream.zip(readings)                     # pair with original
+  # transform each reading
+  |> Firebird.Stream.map(wasm, :fibonacci)
+  # pair with original
+  |> Stream.zip(readings)
   |> Stream.map(fn {transformed, original} ->
     %{input: original, output: transformed}
   end)
   |> Enum.to_list()
 
 IO.puts("   Processed #{length(processed)} readings:")
+
 for %{input: i, output: o} <- Enum.take(processed, 3) do
   IO.puts("     input=#{i} → output=#{o}")
 end
+
 IO.puts("     ...")
 
 # Clean up
diff --git a/examples/string_processing.exs b/examples/string_processing.exs
index d849734..7785d43 100644
--- a/examples/string_processing.exs
+++ b/examples/string_processing.exs
@@ -41,6 +41,7 @@ IO.puts("   Memory freed\n")
 
 IO.puts("3. Multiple strings:")
 strings = ["hello", "world", "firebird", "elixir", "wasm"]
+
 for s <- strings do
   {:ok, upper} = Firebird.WasmString.call_with_string(wasm, :to_uppercase, s)
   IO.puts("   \"#{s}\" → \"#{upper}\"")
diff --git a/examples/supervision_tree.exs b/examples/supervision_tree.exs
index 84c0c51..c249fbc 100644
--- a/examples/supervision_tree.exs
+++ b/examples/supervision_tree.exs
@@ -59,12 +59,14 @@ IO.puts("  Pool status: #{inspect(status)}\n")
 # ── 5. Concurrent pool usage ──────────────────────────────────────────────
 
 IO.puts("Concurrent pool calls:")
-tasks = for i <- 1..10 do
-  Task.async(fn ->
-    [result] = Firebird.Pool.call!(:math_pool, :fibonacci, [20])
-    result
-  end)
-end
+
+tasks =
+  for i <- 1..10 do
+    Task.async(fn ->
+      [result] = Firebird.Pool.call!(:math_pool, :fibonacci, [20])
+      result
+    end)
+  end
 
 results = Task.await_many(tasks)
 IO.puts("  10 concurrent fibonacci(20) calls all returned: #{hd(results)}\n")
diff --git a/examples/testing_wasm.exs b/examples/testing_wasm.exs
index e133c9d..b7cdc27 100644
--- a/examples/testing_wasm.exs
+++ b/examples/testing_wasm.exs
@@ -97,6 +97,7 @@ add_table = [
 for {args, expected} <- add_table do
   {:ok, ^expected} = Firebird.call_one(wasm, :add, args)
 end
+
 IO.puts("✓ assert_wasm_table wasm, :add, #{inspect(add_table)}")
 
 fib_table = [
@@ -109,6 +110,7 @@ fib_table = [
 for {args, expected} <- fib_table do
   {:ok, ^expected} = Firebird.call_one(wasm, :fibonacci, args)
 end
+
 IO.puts("✓ assert_wasm_table wasm, :fibonacci, #{inspect(fib_table)}")
 
 # ============================================================
@@ -120,9 +122,11 @@ IO.puts("✓ assert_wasm_table wasm, :fibonacci, #{inspect(fib_table)}")
 IO.puts("\n─── Pattern 5: Export assertions ───")
 
 exports = Firebird.exports(wasm)
+
 for func <- [:add, :multiply, :fibonacci] do
   true = func in exports
 end
+
 IO.puts("✓ assert_wasm_exports wasm, [:add, :multiply, :fibonacci]")
 
 # ============================================================
@@ -177,9 +181,11 @@ IO.puts("✓ assert_wasm_error wasm, :nonexistent_function, [1, 2]")
 IO.puts("\n─── Pattern 9: Negative export assertions ───")
 
 exports = Firebird.exports(wasm)
+
 for func <- [:nonexistent, :missing] do
   false = func in exports
 end
+
 IO.puts("✓ refute_wasm_exports wasm, [:nonexistent, :missing]")
 
 # ============================================================
diff --git a/examples/thirty_seconds.exs b/examples/thirty_seconds.exs
index a76b49e..42bb559 100644
--- a/examples/thirty_seconds.exs
+++ b/examples/thirty_seconds.exs
@@ -11,18 +11,19 @@ IO.puts("✅ Setup verified\n")
 IO.puts("5 + 3 = 8 ✅")
 
 # Step 3: Write WASM inline with WAT
-wasm = Firebird.from_wat!("""
-(module
-  (func (export "square") (param i32) (result i32)
-    local.get 0
-    local.get 0
-    i32.mul)
-  (func (export "double") (param i32) (result i32)
-    local.get 0
-    i32.const 2
-    i32.mul)
-)
-""")
+wasm =
+  Firebird.from_wat!("""
+  (module
+    (func (export "square") (param i32) (result i32)
+      local.get 0
+      local.get 0
+      i32.mul)
+    (func (export "double") (param i32) (result i32)
+      local.get 0
+      i32.const 2
+      i32.mul)
+  )
+  """)
 
 [25] = Firebird.call!(wasm, :square, [5])
 IO.puts("5² = 25 ✅")
diff --git a/lib/firebird.ex b/lib/firebird.ex
index 4f31b6d..75f8b16 100644
--- a/lib/firebird.ex
+++ b/lib/firebird.ex
@@ -160,12 +160,14 @@ defmodule Firebird do
       {:ok, [8]} = Firebird.call(instance, :add, [5, 3])
       {:ok, [55]} = Firebird.call(instance, "fibonacci", [10])
   """
-  @spec call(pid(), atom() | String.t(), list()) :: {:ok, list()} | {:error, term()}
-  def call(instance, function, args) when is_list(args) do
-    Firebird.Runtime.call(instance, function, args)
+  @spec call(pid(), atom() | String.t(), list(), keyword()) :: {:ok, list()} | {:error, term()}
+  def call(instance, function, args, opts \\ [])
+
+  def call(instance, function, args, opts) when is_list(args) do
+    Firebird.Runtime.call(instance, function, args, opts)
   end
 
-  def call(_instance, _function, args) when not is_list(args) do
+  def call(_instance, _function, args, _opts) when not is_list(args) do
     raise ArgumentError, """
     Firebird.call/3 expects args as a list, got: #{inspect(args)}
 
@@ -269,6 +271,7 @@ defmodule Firebird do
       case function_type(instance, func) do
         {:ok, {params, results}} ->
           %{name: func, params: params, results: results, arity: length(params)}
+
         _ ->
           %{name: func, params: [], results: [], arity: 0}
       end
@@ -282,7 +285,8 @@ defmodule Firebird do
 
       {:ok, {[:i32, :i32], [:i32]}} = Firebird.function_type(instance, :add)
   """
-  @spec function_type(pid(), atom() | String.t()) :: {:ok, {list(), list()}} | {:error, :not_found}
+  @spec function_type(pid(), atom() | String.t()) ::
+          {:ok, {list(), list()}} | {:error, :not_found}
   def function_type(instance, function) do
     Firebird.Runtime.function_type(instance, function)
   end
@@ -294,7 +298,8 @@ defmodule Firebird do
 
       {:ok, bytes} = Firebird.read_memory(instance, 0, 10)
   """
-  @spec read_memory(pid(), non_neg_integer(), non_neg_integer()) :: {:ok, binary()} | {:error, term()}
+  @spec read_memory(pid(), non_neg_integer(), non_neg_integer()) ::
+          {:ok, binary()} | {:error, term()}
   def read_memory(instance, offset, length) do
     Firebird.Runtime.read_memory(instance, offset, length)
   end
@@ -347,6 +352,7 @@ defmodule Firebird do
     # SyncNif references are garbage collected, no explicit stop needed
     :ok
   end
+
   def stop(instance) do
     Firebird.Runtime.stop(instance)
   end
@@ -391,10 +397,11 @@ defmodule Firebird do
       %{
         alive: true,
         exports: exports(instance),
-        memory_bytes: case memory_size(instance) do
-          {:ok, size} -> size
-          _ -> nil
-        end
+        memory_bytes:
+          case memory_size(instance) do
+            {:ok, size} -> size
+            _ -> nil
+          end
       }
     else
       %{alive: false, exports: [], memory_bytes: nil}
@@ -420,12 +427,13 @@ defmodule Firebird do
 
       {:error, {:file_error, :enoent, path}} ->
         searched = Firebird.Runtime.search_paths(path)
-        searched_str = searched |> Enum.map(&("          • #{&1}")) |> Enum.join("\n")
+        searched_str = searched |> Enum.map(&"          • #{&1}") |> Enum.join("\n")
+
         raise """
         WASM file not found: #{path}
 
         Searched locations:
-#{searched_str}
+        #{searched_str}
 
         To initialize WASM in your project: mix firebird.init
         To use the bundled sample: Firebird.sample_wasm_path()
@@ -463,7 +471,7 @@ defmodule Firebird do
       {:ok, [55]}
   """
   @spec run(binary() | String.t(), atom() | String.t(), list(), keyword()) ::
-    {:ok, list()} | {:error, term()}
+          {:ok, list()} | {:error, term()}
   def run(wasm_source, function, args, opts \\ []) do
     with {:ok, pid} <- load(wasm_source, opts) do
       try do
@@ -506,7 +514,7 @@ defmodule Firebird do
       {:ok, 16}
   """
   @spec with_instance(binary() | String.t(), (pid() -> term()), keyword()) ::
-    {:ok, term()} | {:error, term()}
+          {:ok, term()} | {:error, term()}
   def with_instance(wasm_source, fun, opts \\ []) when is_function(fun, 1) do
     case load(wasm_source, opts) do
       {:ok, pid} ->
@@ -515,6 +523,7 @@ defmodule Firebird do
         after
           stop(pid)
         end
+
       {:error, _} = error ->
         error
     end
@@ -642,7 +651,8 @@ defmodule Firebird do
 
       {:ok, [8]} = Firebird.pool_call(pool, :add, [5, 3])
   """
-  @spec pool_call(GenServer.server(), atom() | String.t(), list()) :: {:ok, list()} | {:error, term()}
+  @spec pool_call(GenServer.server(), atom() | String.t(), list()) ::
+          {:ok, list()} | {:error, term()}
   def pool_call(pool, function, args) do
     Firebird.Pool.call(pool, function, args)
   end
@@ -666,7 +676,8 @@ defmodule Firebird do
 
       {:ok, 8} = Firebird.pool_call_one(pool, :add, [5, 3])
   """
-  @spec pool_call_one(GenServer.server(), atom() | String.t(), list()) :: {:ok, term()} | {:error, term()}
+  @spec pool_call_one(GenServer.server(), atom() | String.t(), list()) ::
+          {:ok, term()} | {:error, term()}
   def pool_call_one(pool, function, args) do
     Firebird.Pool.call_one(pool, function, args)
   end
@@ -739,9 +750,12 @@ defmodule Firebird do
   @spec from_wat!(String.t(), keyword()) :: pid()
   def from_wat!(wat_source, opts \\ []) do
     case from_wat(wat_source, opts) do
-      {:ok, pid} -> pid
+      {:ok, pid} ->
+        pid
+
       {:error, {:wat_compile_error, msg}} ->
         raise "WAT compilation failed:\n#{msg}"
+
       {:error, {:wat2wasm_not_found, _}} ->
         raise """
         wat2wasm not found. Install it:
@@ -749,6 +763,7 @@ defmodule Firebird do
           • Ubuntu: apt install wabt
           • Or download from: https://github.com/WebAssembly/wabt/releases
         """
+
       {:error, reason} ->
         raise "Failed to load WAT module: #{inspect(reason)}"
     end
@@ -765,18 +780,22 @@ defmodule Firebird do
   def compile_wat(wat_source) do
     case System.find_executable("wat2wasm") do
       nil ->
-        {:error, {:wat2wasm_not_found,
+        {:error,
+         {:wat2wasm_not_found,
           "Install wabt: brew install wabt (macOS) or apt install wabt (Ubuntu)"}}
+
       wat2wasm ->
         tmp_wat = Path.join(System.tmp_dir!(), "firebird_#{:erlang.phash2(wat_source)}.wat")
         tmp_wasm = Path.rootname(tmp_wat) <> ".wasm"
 
         try do
           File.write!(tmp_wat, wat_source)
+
           case System.cmd(wat2wasm, [tmp_wat, "-o", tmp_wasm], stderr_to_stdout: true) do
             {_, 0} ->
               wasm_bytes = File.read!(tmp_wasm)
               {:ok, wasm_bytes}
+
             {error_output, _} ->
               {:error, {:wat_compile_error, error_output}}
           end
@@ -807,28 +826,39 @@ defmodule Firebird do
     IO.puts("🔥 WASM Instance (#{if info.alive, do: "alive", else: "stopped"})")
     IO.puts("   Memory: #{format_bytes(info.memory_bytes || 0)}")
     IO.puts("   Exports (#{length(info.exports)}):")
+
     for func <- info.exports do
       case function_type(instance, func) do
         {:ok, {params, results}} ->
-          IO.puts("     #{func}(#{Enum.join(Enum.map(params, &inspect/1), ", ")}) → #{inspect(results)}")
+          IO.puts(
+            "     #{func}(#{Enum.join(Enum.map(params, &inspect/1), ", ")}) → #{inspect(results)}"
+          )
+
         _ ->
           IO.puts("     #{func}")
       end
     end
+
     :ok
   end
 
   def describe(path) when is_binary(path) do
     # Use smart path resolution for bare filenames
     resolved = Firebird.Runtime.resolve_wasm_path(path)
+
     case inspect_file(resolved) do
       {:ok, info} ->
         IO.puts("🔥 #{Path.basename(resolved)} (#{format_bytes(info.size_bytes)})")
         IO.puts("   Functions (#{length(info.functions)}):")
+
         for f <- info.functions do
-          IO.puts("     #{f.name}(#{Enum.join(Enum.map(f.params, &inspect/1), ", ")}) → #{inspect(f.results)}")
+          IO.puts(
+            "     #{f.name}(#{Enum.join(Enum.map(f.params, &inspect/1), ", ")}) → #{inspect(f.results)}"
+          )
         end
+
         :ok
+
       {:error, reason} ->
         IO.puts("❌ Cannot inspect #{path}: #{inspect(reason)}")
         :ok
@@ -902,6 +932,7 @@ defmodule Firebird do
       {:ok, pid} ->
         stop(pid)
         :ok
+
       {:error, _} = error ->
         error
     end
@@ -1099,27 +1130,32 @@ defmodule Firebird do
         result
 
       {:error, {:call_error, func_name, _reason}} ->
-        suggestion = if Process.alive?(instance) do
-          available = exports(instance) |> Enum.map(&to_string/1)
-          func_str = to_string(func_name)
-
-          if func_str not in available do
-            closest = available
-              |> Enum.map(fn a -> {a, String.jaro_distance(func_str, a)} end)
-              |> Enum.sort_by(fn {_, d} -> d end, :desc)
-              |> Enum.take(1)
-              |> Enum.filter(fn {_, d} -> d > 0.6 end)
-
-            case closest do
-              [{match, _}] -> "\n\nDid you mean: #{match}?\nAvailable: #{Enum.join(available, ", ")}"
-              _ -> "\nAvailable functions: #{Enum.join(available, ", ")}"
+        suggestion =
+          if Process.alive?(instance) do
+            available = exports(instance) |> Enum.map(&to_string/1)
+            func_str = to_string(func_name)
+
+            if func_str not in available do
+              closest =
+                available
+                |> Enum.map(fn a -> {a, String.jaro_distance(func_str, a)} end)
+                |> Enum.sort_by(fn {_, d} -> d end, :desc)
+                |> Enum.take(1)
+                |> Enum.filter(fn {_, d} -> d > 0.6 end)
+
+              case closest do
+                [{match, _}] ->
+                  "\n\nDid you mean: #{match}?\nAvailable: #{Enum.join(available, ", ")}"
+
+                _ ->
+                  "\nAvailable functions: #{Enum.join(available, ", ")}"
+              end
+            else
+              "\n\nThe function exists but the call failed. Check argument types/count."
             end
           else
-            "\n\nThe function exists but the call failed. Check argument types/count."
+            ""
           end
-        else
-          ""
-        end
 
         raise "WASM function '#{func_name}' not found.#{suggestion}"
 
@@ -1142,7 +1178,7 @@ defmodule Firebird do
       {:ok, 55}
   """
   @spec run_one(binary() | String.t(), atom() | String.t(), list(), keyword()) ::
-    {:ok, term()} | {:error, term()}
+          {:ok, term()} | {:error, term()}
   def run_one(wasm_source, function, args, opts \\ []) do
     case run(wasm_source, function, args, opts) do
       {:ok, [single]} -> {:ok, single}
@@ -1259,7 +1295,8 @@ defmodule Firebird do
       {:ok, inst1} = Firebird.instantiate(compiled)
       {:ok, inst2} = Firebird.instantiate(compiled)
   """
-  @spec precompile(binary() | String.t(), keyword()) :: {:ok, Firebird.Preloader.compiled()} | {:error, term()}
+  @spec precompile(binary() | String.t(), keyword()) ::
+          {:ok, Firebird.Preloader.compiled()} | {:error, term()}
   defdelegate precompile(wasm_source, opts \\ []), to: Firebird.Preloader, as: :compile
 
   @doc """
@@ -1358,8 +1395,10 @@ defmodule Firebird do
   def quick(source, function, args) when is_binary(source) do
     # Check if it looks like WAT (starts with parenthesis)
     trimmed = String.trim(source)
+
     if String.starts_with?(trimmed, "(") do
       {:ok, instance} = from_wat(source)
+
       try do
         call_one!(instance, function, args)
       after
@@ -1427,6 +1466,7 @@ defmodule Firebird do
     # Check tools
     tools = Firebird.Builder.check_tools()
     IO.puts("  🔧 Tools:")
+
     for {name, version} <- tools do
       status = if version, do: "✅ #{version}", else: "❌ not found"
       IO.puts("     #{name}: #{status}")
@@ -1434,9 +1474,11 @@ defmodule Firebird do
 
     # Check WASM directories
     IO.puts("  📁 WASM files:")
+
     for dir <- ["priv/wasm", "wasm", "fixtures"] do
       if File.dir?(dir) do
         wasm_files = Path.wildcard(Path.join(dir, "*.wasm"))
+
         if length(wasm_files) > 0 do
           IO.puts("     #{dir}/: #{length(wasm_files)} file(s)")
         end
diff --git a/lib/firebird/batch.ex b/lib/firebird/batch.ex
index 0f62cb9..950cef2 100644
--- a/lib/firebird/batch.ex
+++ b/lib/firebird/batch.ex
@@ -40,7 +40,9 @@ defmodule Firebird.Batch do
   - `:timeout` - Maximum time for entire batch (default: 30s)
   - `:max_concurrency` - Max concurrent tasks (default: pool_size * 2)
   """
-  @spec run(GenServer.server(), [{atom() | String.t(), list()}], keyword()) :: [{:ok, list()} | {:error, term()}]
+  @spec run(GenServer.server(), [{atom() | String.t(), list()}], keyword()) :: [
+          {:ok, list()} | {:error, term()}
+        ]
   def run(pool, calls, opts \\ []) do
     timeout = Keyword.get(opts, :timeout, @default_timeout)
     max_concurrency = Keyword.get(opts, :max_concurrency, System.schedulers_online() * 2)
@@ -88,7 +90,7 @@ defmodule Firebird.Batch do
       {:ok, results} = Firebird.Batch.pmap(pool, :fibonacci, Enum.map(1..10, &[&1]))
   """
   @spec pmap(GenServer.server(), atom() | String.t(), [list()], keyword()) ::
-    {:ok, [list()]} | {:error, [{integer(), term()}]}
+          {:ok, [list()]} | {:error, [{integer(), term()}]}
   def pmap(pool, function, args_list, opts \\ []) do
     calls = Enum.map(args_list, fn args -> {function, args} end)
     results = run(pool, calls, opts)
@@ -112,7 +114,7 @@ defmodule Firebird.Batch do
   Returns `{results, stats}` where stats includes timing info.
   """
   @spec run_with_stats(GenServer.server(), [{atom() | String.t(), list()}], keyword()) ::
-    {[{:ok, list()} | {:error, term()}], map()}
+          {[{:ok, list()} | {:error, term()}], map()}
   def run_with_stats(pool, calls, opts \\ []) do
     start = System.monotonic_time(:microsecond)
     results = run(pool, calls, opts)
@@ -127,7 +129,8 @@ defmodule Firebird.Batch do
       errors: errors,
       elapsed_us: elapsed,
       avg_us: if(length(results) > 0, do: Float.round(elapsed / length(results), 1), else: 0.0),
-      calls_per_second: if(elapsed > 0, do: Float.round(length(results) * 1_000_000 / elapsed, 1), else: 0.0)
+      calls_per_second:
+        if(elapsed > 0, do: Float.round(length(results) * 1_000_000 / elapsed, 1), else: 0.0)
     }
 
     {results, stats}
diff --git a/lib/firebird/benchmark.ex b/lib/firebird/benchmark.ex
index bc1bd12..600bc42 100644
--- a/lib/firebird/benchmark.ex
+++ b/lib/firebird/benchmark.ex
@@ -129,8 +129,7 @@ defmodule Firebird.Benchmark do
     wasm_stats = compute_stats(wasm_times, function, iterations)
     beam_stats = compute_stats(beam_times, function, iterations)
 
-    speedup =
-      if wasm_stats.avg_us > 0, do: beam_stats.avg_us / wasm_stats.avg_us, else: 0.0
+    speedup = if wasm_stats.avg_us > 0, do: beam_stats.avg_us / wasm_stats.avg_us, else: 0.0
 
     %{
       function: function,
@@ -206,7 +205,7 @@ defmodule Firebird.Benchmark do
   """
   @spec percentile([number()], number()) :: number()
   def percentile(sorted, p) when is_list(sorted) and length(sorted) > 0 do
-    k = (p / 100) * (length(sorted) - 1)
+    k = p / 100 * (length(sorted) - 1)
     f = trunc(k)
     c = Float.ceil(k) |> trunc()
 
@@ -254,7 +253,9 @@ defmodule Firebird.Benchmark do
 
     rows =
       Enum.map(results, fn r ->
-        name = (r[:name] || to_string(r.function)) |> String.pad_trailing(37) |> String.slice(0, 37)
+        name =
+          (r[:name] || to_string(r.function)) |> String.pad_trailing(37) |> String.slice(0, 37)
+
         wasm = r.wasm.avg_us |> Float.round(1) |> to_string() |> String.pad_leading(9)
         beam = r.beam.avg_us |> Float.round(1) |> to_string() |> String.pad_leading(9)
 
@@ -289,7 +290,8 @@ defmodule Firebird.Benchmark do
   """
   @spec format_csv([map()]) :: String.t()
   def format_csv(results) do
-    header = "name,function,wasm_avg_us,beam_avg_us,speedup,wasm_p50,wasm_p95,wasm_p99,beam_p50,beam_p95,beam_p99"
+    header =
+      "name,function,wasm_avg_us,beam_avg_us,speedup,wasm_p50,wasm_p95,wasm_p99,beam_p50,beam_p95,beam_p99"
 
     rows =
       Enum.map(results, fn r ->
@@ -325,7 +327,11 @@ defmodule Firebird.Benchmark do
     rows =
       Enum.map(results, fn r ->
         name = r[:name] || to_string(r.function)
-        speedup = if r.speedup >= 1.0, do: "#{Float.round(r.speedup, 2)}x", else: "#{Float.round(1.0 / max(r.speedup, 0.001), 2)}x slower"
+
+        speedup =
+          if r.speedup >= 1.0,
+            do: "#{Float.round(r.speedup, 2)}x",
+            else: "#{Float.round(1.0 / max(r.speedup, 0.001), 2)}x slower"
 
         "| #{name} | #{Float.round(r.wasm.avg_us, 1)} | #{Float.round(r.beam.avg_us, 1)} | #{speedup} | #{Float.round(r.wasm.p95_us, 1)} | #{Float.round(r.beam.p95_us, 1)} |"
       end)
@@ -333,4 +339,3 @@ defmodule Firebird.Benchmark do
     Enum.join([header, separator | rows], "\n")
   end
 end
-
diff --git a/lib/firebird/builder.ex b/lib/firebird/builder.ex
index 7f55420..4fa88cc 100644
--- a/lib/firebird/builder.ex
+++ b/lib/firebird/builder.ex
@@ -50,6 +50,7 @@ defmodule Firebird.Builder do
       true ->
         # Check for standalone .go files
         go_files = Path.wildcard(Path.join(source_dir, "*.go"))
+
         if length(go_files) > 0 do
           build_go(source_dir, opts)
         else
@@ -102,10 +103,14 @@ defmodule Firebird.Builder do
 
     args = [
       "build",
-      "-o", output,
-      "-target", target,
-      "-scheduler", scheduler,
-      "-gc", gc
+      "-o",
+      output,
+      "-target",
+      target,
+      "-scheduler",
+      scheduler,
+      "-gc",
+      gc
     ]
 
     args = if debug, do: args, else: args ++ ["-no-debug"]
@@ -123,12 +128,14 @@ defmodule Firebird.Builder do
   defp find_go_main(source_dir) do
     # Look for main.go first, then any .go file
     main = Path.join(source_dir, "main.go")
+
     if File.exists?(main) do
       "main.go"
     else
       case Path.wildcard(Path.join(source_dir, "*.go")) do
         [first | _] -> Path.basename(first)
-        [] -> "main.go"  # Let tinygo give the error
+        # Let tinygo give the error
+        [] -> "main.go"
       end
     end
   end
@@ -174,17 +181,17 @@ defmodule Firebird.Builder do
       {_output, 0} ->
         # Find the output wasm file
         profile = if release, do: "release", else: "debug"
-        wasm_files = Path.wildcard(
-          Path.join([source_dir, "target", target, profile, "*.wasm"])
-        )
+        wasm_files = Path.wildcard(Path.join([source_dir, "target", target, profile, "*.wasm"]))
 
         case wasm_files do
           [wasm_file | _] ->
             output = Keyword.get(opts, :output, wasm_file)
+
             if output != wasm_file do
               File.mkdir_p!(Path.dirname(output))
               File.cp!(wasm_file, output)
             end
+
             {:ok, Path.expand(output)}
 
           [] ->
@@ -215,14 +222,16 @@ defmodule Firebird.Builder do
     {load_opts, build_opts} = Keyword.split(opts, [:wasi, :memory_limit, :timeout])
 
     # Auto-detect WASI for Go projects
-    is_go = File.exists?(Path.join(Path.expand(source_dir), "go.mod")) or
-            length(Path.wildcard(Path.join(Path.expand(source_dir), "*.go"))) > 0
-
-    load_opts = if is_go and not Keyword.has_key?(load_opts, :wasi) do
-      Keyword.put(load_opts, :wasi, true)
-    else
-      load_opts
-    end
+    is_go =
+      File.exists?(Path.join(Path.expand(source_dir), "go.mod")) or
+        length(Path.wildcard(Path.join(Path.expand(source_dir), "*.go"))) > 0
+
+    load_opts =
+      if is_go and not Keyword.has_key?(load_opts, :wasi) do
+        Keyword.put(load_opts, :wasi, true)
+      else
+        load_opts
+      end
 
     with {:ok, wasm_path} <- build(source_dir, build_opts),
          {:ok, instance} <- Firebird.load(wasm_path, load_opts) do
@@ -245,7 +254,9 @@ defmodule Firebird.Builder do
       {:error, {:not_found, "WAT file not found: #{wat_file}"}}
     else
       case System.find_executable("wat2wasm") do
-        nil -> {:error, {:tool_missing, "wat2wasm not found. Install wabt."}}
+        nil ->
+          {:error, {:tool_missing, "wat2wasm not found. Install wabt."}}
+
         _wat2wasm ->
           basename = Path.basename(wat_file, ".wat")
           default_output = Path.join(Path.dirname(wat_file), "#{basename}.wasm")
@@ -281,7 +292,9 @@ defmodule Firebird.Builder do
 
   defp get_tool_version(tool, args) do
     case System.find_executable(tool) do
-      nil -> nil
+      nil ->
+        nil
+
       _path ->
         case System.cmd(tool, args, stderr_to_stdout: true) do
           {output, 0} -> output |> String.trim() |> String.split("\n") |> hd()
@@ -313,14 +326,15 @@ defmodule Firebird.Builder do
     """)
 
     # main.go
-    func_code = Enum.map_join(functions, "\n\n", fn func ->
-      """
-      //export #{func}
-      func #{func}(a, b int32) int32 {
-      \treturn a + b  // TODO: implement
-      }
-      """
-    end)
+    func_code =
+      Enum.map_join(functions, "\n\n", fn func ->
+        """
+        //export #{func}
+        func #{func}(a, b int32) int32 {
+        \treturn a + b  // TODO: implement
+        }
+        """
+      end)
 
     File.write!(Path.join(dir, "main.go"), """
     package main
@@ -388,14 +402,15 @@ defmodule Firebird.Builder do
     """)
 
     # src/lib.rs
-    func_code = Enum.map_join(functions, "\n\n", fn func ->
-      """
-      #[unsafe(no_mangle)]
-      pub extern "C" fn #{func}(a: i32, b: i32) -> i32 {
-          a + b  // TODO: implement
-      }
-      """
-    end)
+    func_code =
+      Enum.map_join(functions, "\n\n", fn func ->
+        """
+        #[unsafe(no_mangle)]
+        pub extern "C" fn #{func}(a: i32, b: i32) -> i32 {
+            a + b  // TODO: implement
+        }
+        """
+      end)
 
     File.write!(Path.join(dir, "src/lib.rs"), """
     //! #{module_name} - WASM functions for Firebird
diff --git a/lib/firebird/cache.ex b/lib/firebird/cache.ex
index 320a823..9cc99cf 100644
--- a/lib/firebird/cache.ex
+++ b/lib/firebird/cache.ex
@@ -141,6 +141,7 @@ defmodule Firebird.Cache do
 
             # Also persist to disk
             disk_cache_file = Path.join(cache_dir, key)
+
             unless cache_valid?(wasm_path, disk_cache_file) do
               persist_to_disk_async(wasm_path, disk_cache_file)
             end
@@ -198,6 +199,7 @@ defmodule Firebird.Cache do
     if File.dir?(cache_dir) do
       File.rm_rf!(cache_dir)
     end
+
     :ok
   end
 
@@ -226,17 +228,19 @@ defmodule Firebird.Cache do
 
         case read_meta(meta_path) do
           {:ok, meta} ->
-            cache_size = case File.stat(cache_path) do
-              {:ok, %{size: size}} -> size
-              _ -> 0
-            end
+            cache_size =
+              case File.stat(cache_path) do
+                {:ok, %{size: size}} -> size
+                _ -> 0
+              end
 
             Map.merge(meta, %{
               cache_file: cache_path,
               cache_size: cache_size
             })
 
-          _ -> nil
+          _ ->
+            nil
         end
       end)
       |> Enum.reject(&is_nil/1)
@@ -371,17 +375,20 @@ defmodule Firebird.Cache do
             File.write!(cache_file, bytes)
 
             {:ok, %{mtime: mtime}} = File.stat(expanded, time: :posix)
+
             write_meta(cache_file <> ".meta", %{
               source: wasm_path,
               source_mtime: mtime,
               cached_at: DateTime.utc_now() |> DateTime.to_iso8601(),
               source_size: byte_size(bytes)
             })
+
           _ ->
             :ok
         end
       rescue
-        _ -> :ok  # Don't fail on cache errors
+        # Don't fail on cache errors
+        _ -> :ok
       end
     end)
   end
@@ -397,7 +404,9 @@ defmodule Firebird.Cache do
           {:ok, meta} -> {:ok, meta}
           error -> error
         end
-      error -> error
+
+      error ->
+        error
     end
   end
 end
diff --git a/lib/firebird/compiler.ex b/lib/firebird/compiler.ex
index 9d1305b..ac7a50a 100644
--- a/lib/firebird/compiler.ex
+++ b/lib/firebird/compiler.ex
@@ -50,7 +50,19 @@ defmodule Firebird.Compiler do
       {:ok, wasm_binary} = Firebird.Compiler.to_wasm(wat)
   """
 
-  alias Firebird.Compiler.{IRGen, WATGen, TypeInference, Validator, Optimizer, TCO, Inliner, CSE, ConstantPropagation, IfChainToCase, LICM}
+  alias Firebird.Compiler.{
+    IRGen,
+    WATGen,
+    TypeInference,
+    Validator,
+    Optimizer,
+    TCO,
+    Inliner,
+    CSE,
+    ConstantPropagation,
+    IfChainToCase,
+    LICM
+  }
 
   @type compile_opts :: [
           output_dir: String.t(),
@@ -228,9 +240,12 @@ defmodule Firebird.Compiler do
       {:docs_v1, _, _, _, _, _, _} ->
         # Try to find the source file from module info
         case module.module_info(:compile)[:source] do
-          nil -> {:error, {:no_source, module}}
+          nil ->
+            {:error, {:no_source, module}}
+
           source_charlist ->
             source_path = List.to_string(source_charlist)
+
             case File.read(source_path) do
               {:ok, source} -> {:ok, source}
               {:error, _} -> {:error, {:source_not_found, source_path}}
diff --git a/lib/firebird/compiler/analyzer.ex b/lib/firebird/compiler/analyzer.ex
index 99a0fb6..ceff89d 100644
--- a/lib/firebird/compiler/analyzer.ex
+++ b/lib/firebird/compiler/analyzer.ex
@@ -16,22 +16,22 @@ defmodule Firebird.Compiler.Analyzer do
   alias Firebird.Compiler.IR
 
   @type analysis :: %{
-    module: atom(),
-    functions: [function_analysis()],
-    compilable: boolean(),
-    issues: [String.t()],
-    suggestions: [String.t()]
-  }
+          module: atom(),
+          functions: [function_analysis()],
+          compilable: boolean(),
+          issues: [String.t()],
+          suggestions: [String.t()]
+        }
 
   @type function_analysis :: %{
-    name: atom(),
-    arity: non_neg_integer(),
-    recursive: boolean(),
-    tail_recursive: boolean(),
-    estimated_complexity: String.t(),
-    compilable: boolean(),
-    issues: [String.t()]
-  }
+          name: atom(),
+          arity: non_neg_integer(),
+          recursive: boolean(),
+          tail_recursive: boolean(),
+          estimated_complexity: String.t(),
+          compilable: boolean(),
+          issues: [String.t()]
+        }
 
   @doc """
   Analyze an Elixir source string for WASM compilability.
@@ -44,6 +44,7 @@ defmodule Firebird.Compiler.Analyzer do
     else
       {:error, {meta, msg, token}} ->
         {:error, {:parse_error, meta, msg, token}}
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -68,9 +69,11 @@ defmodule Firebird.Compiler.Analyzer do
     func_analyses = Enum.map(module.functions, &analyze_function/1)
 
     all_compilable = Enum.all?(func_analyses, & &1.compilable)
-    all_issues = Enum.flat_map(func_analyses, fn fa ->
-      Enum.map(fa.issues, fn issue -> "#{fa.name}/#{fa.arity}: #{issue}" end)
-    end)
+
+    all_issues =
+      Enum.flat_map(func_analyses, fn fa ->
+        Enum.map(fa.issues, fn issue -> "#{fa.name}/#{fa.arity}: #{issue}" end)
+      end)
 
     suggestions = generate_suggestions(func_analyses)
 
@@ -125,41 +128,51 @@ defmodule Firebird.Compiler.Analyzer do
   defp has_nested_loops?({:call, _, args}) do
     Enum.any?(args, &has_nested_loops?/1)
   end
+
   defp has_nested_loops?({:binop, _, left, right}) do
     has_nested_loops?(left) or has_nested_loops?(right)
   end
+
   defp has_nested_loops?({:if, c, t, e}) do
     has_nested_loops?(c) or has_nested_loops?(t) or has_nested_loops?(e)
   end
+
   defp has_nested_loops?(_), do: false
 
   defp count_recursive_calls({:call, name, args}, name) do
     1 + Enum.sum(Enum.map(args, &count_recursive_calls(&1, name)))
   end
+
   defp count_recursive_calls({:call, _, args}, name) do
     Enum.sum(Enum.map(args, &count_recursive_calls(&1, name)))
   end
+
   defp count_recursive_calls({:binop, _, left, right}, name) do
     count_recursive_calls(left, name) + count_recursive_calls(right, name)
   end
+
   defp count_recursive_calls({:if, c, t, e}, name) do
-    max(count_recursive_calls(c, name),
-      max(count_recursive_calls(t, name), count_recursive_calls(e, name)))
+    max(
+      count_recursive_calls(c, name),
+      max(count_recursive_calls(t, name), count_recursive_calls(e, name))
+    )
   end
+
   defp count_recursive_calls({:unaryop, _, expr}, name) do
     count_recursive_calls(expr, name)
   end
+
   defp count_recursive_calls({:block, exprs}, name) do
     Enum.sum(Enum.map(exprs, &count_recursive_calls(&1, name)))
   end
+
   defp count_recursive_calls(_, _), do: 0
 
   defp generate_suggestions(func_analyses) do
     suggestions = []
 
     # Suggest TCO for recursive but not tail-recursive functions
-    non_tail =
-      Enum.filter(func_analyses, fn fa -> fa.recursive and not fa.tail_recursive end)
+    non_tail = Enum.filter(func_analyses, fn fa -> fa.recursive and not fa.tail_recursive end)
 
     suggestions =
       if Enum.any?(non_tail) do
diff --git a/lib/firebird/compiler/combiner.ex b/lib/firebird/compiler/combiner.ex
index c0734a4..299b808 100644
--- a/lib/firebird/compiler/combiner.ex
+++ b/lib/firebird/compiler/combiner.ex
@@ -176,7 +176,9 @@ defmodule Firebird.Compiler.Combiner do
 
   defp maybe_write(result, opts) do
     case Keyword.get(opts, :output_dir) do
-      nil -> :ok
+      nil ->
+        :ok
+
       dir ->
         File.mkdir_p!(dir)
         base = Atom.to_string(result.module) |> String.replace(".", "_")
diff --git a/lib/firebird/compiler/constant_propagation.ex b/lib/firebird/compiler/constant_propagation.ex
index 5a6aa88..11a9a70 100644
--- a/lib/firebird/compiler/constant_propagation.ex
+++ b/lib/firebird/compiler/constant_propagation.ex
@@ -141,8 +141,7 @@ defmodule Firebird.Compiler.ConstantPropagation do
   # If expressions — propagate into all branches with the same env
   # (branches don't introduce new bindings visible outside)
   def propagate_expr({:if, cond_expr, then_b, else_b}, env, params) do
-    {:if, propagate_expr(cond_expr, env, params),
-     propagate_expr(then_b, env, params),
+    {:if, propagate_expr(cond_expr, env, params), propagate_expr(then_b, env, params),
      propagate_expr(else_b, env, params)}
   end
 
diff --git a/lib/firebird/compiler/cse.ex b/lib/firebird/compiler/cse.ex
index 843b543..e47d1cb 100644
--- a/lib/firebird/compiler/cse.ex
+++ b/lib/firebird/compiler/cse.ex
@@ -140,6 +140,7 @@ defmodule Firebird.Compiler.CSE do
 
   defp count_subexpressions({:case, subject, clauses}, acc) do
     acc = count_subexpressions(subject, acc)
+
     Enum.reduce(clauses, acc, fn {_pat, _guard, body}, a ->
       count_subexpressions(body, a)
     end)
@@ -249,8 +250,7 @@ defmodule Firebird.Compiler.CSE do
   end
 
   defp replace_expr({:if, cond_e, then_e, else_e}, target, replacement) do
-    {:if, replace_expr(cond_e, target, replacement),
-     replace_expr(then_e, target, replacement),
+    {:if, replace_expr(cond_e, target, replacement), replace_expr(then_e, target, replacement),
      replace_expr(else_e, target, replacement)}
   end
 
diff --git a/lib/firebird/compiler/dependency_tracker.ex b/lib/firebird/compiler/dependency_tracker.ex
index 1706a80..ffae648 100644
--- a/lib/firebird/compiler/dependency_tracker.ex
+++ b/lib/firebird/compiler/dependency_tracker.ex
@@ -165,7 +165,8 @@ defmodule Firebird.Compiler.DependencyTracker do
 
   # Match remote function calls: Module.function(args)
   # The AST is: {{:., _, [{:__aliases__, _, parts}, func]}, _, args}
-  defp collect_calls({{:., _, [{:__aliases__, _, parts}, _func]}, _, args}, acc) when is_list(args) do
+  defp collect_calls({{:., _, [{:__aliases__, _, parts}, _func]}, _, args}, acc)
+       when is_list(args) do
     module = parts |> Enum.map(&to_string/1) |> Enum.join(".") |> String.to_atom()
     # Also collect from args
     acc = [module | acc]
@@ -274,6 +275,7 @@ defmodule Firebird.Compiler.DependencyTracker do
               in_progress: MapSet.delete(state.in_progress, node),
               result: [node | state.result]
           }
+
           {:ok, state}
 
         {:error, _} = err ->
@@ -304,9 +306,3 @@ defmodule Firebird.Compiler.DependencyTracker do
     end)
   end
 end
-
-
-
-
-
-
diff --git a/lib/firebird/compiler/if_chain_to_case.ex b/lib/firebird/compiler/if_chain_to_case.ex
index 82b1ffb..80ad6ba 100644
--- a/lib/firebird/compiler/if_chain_to_case.ex
+++ b/lib/firebird/compiler/if_chain_to_case.ex
@@ -54,7 +54,9 @@ defmodule Firebird.Compiler.IfChainToCase do
   Convert if-eq chains to case expressions in a single expression.
   """
   @spec convert_expr(term()) :: term()
-  def convert_expr({:if, {:binop, :eq, {:var, var_name}, {:literal, _}} = _cond, _then, _else} = expr) do
+  def convert_expr(
+        {:if, {:binop, :eq, {:var, var_name}, {:literal, _}} = _cond, _then, _else} = expr
+      ) do
     case extract_if_eq_chain(expr, var_name) do
       {:ok, clauses, default_body} when length(clauses) >= @min_chain_length ->
         # Convert to case expression; recursively convert bodies
@@ -125,7 +127,8 @@ defmodule Firebird.Compiler.IfChainToCase do
   defp extract_if_eq_chain(
          {:if, {:binop, :eq, {:var, var_name}, {:literal, val}}, then_body, else_body},
          var_name
-       ) when is_integer(val) do
+       )
+       when is_integer(val) do
     case extract_if_eq_chain(else_body, var_name) do
       {:ok, rest_clauses, default} ->
         {:ok, [{val, then_body} | rest_clauses], default}
diff --git a/lib/firebird/compiler/inliner.ex b/lib/firebird/compiler/inliner.ex
index d9ce534..ce57386 100644
--- a/lib/firebird/compiler/inliner.ex
+++ b/lib/firebird/compiler/inliner.ex
@@ -88,7 +88,10 @@ defmodule Firebird.Compiler.Inliner do
   def ir_size({:unaryop, _, expr}), do: 1 + ir_size(expr)
   def ir_size({:call, _, args}), do: 1 + Enum.sum(Enum.map(args, &ir_size/1))
   def ir_size({:if, c, t, e}), do: 1 + ir_size(c) + ir_size(t) + ir_size(e)
-  def ir_size({:case, s, clauses}), do: 1 + ir_size(s) + Enum.sum(Enum.map(clauses, fn {_, _, b} -> ir_size(b) end))
+
+  def ir_size({:case, s, clauses}),
+    do: 1 + ir_size(s) + Enum.sum(Enum.map(clauses, fn {_, _, b} -> ir_size(b) end))
+
   def ir_size({:let, _, v}), do: 1 + ir_size(v)
   def ir_size({:block, exprs}), do: Enum.sum(Enum.map(exprs, &ir_size/1))
   def ir_size({:tail_loop, _, body}), do: 1 + ir_size(body)
@@ -124,7 +127,8 @@ defmodule Firebird.Compiler.Inliner do
   end
 
   defp inline_calls({:if, c, t, e}, inline_map, cf) do
-    {:if, inline_calls(c, inline_map, cf), inline_calls(t, inline_map, cf), inline_calls(e, inline_map, cf)}
+    {:if, inline_calls(c, inline_map, cf), inline_calls(t, inline_map, cf),
+     inline_calls(e, inline_map, cf)}
   end
 
   defp inline_calls({:case, s, clauses}, inline_map, cf) do
@@ -160,7 +164,8 @@ defmodule Firebird.Compiler.Inliner do
   end
 
   defp substitute_inline({:if, c, t, e}, var_map) do
-    {:if, substitute_inline(c, var_map), substitute_inline(t, var_map), substitute_inline(e, var_map)}
+    {:if, substitute_inline(c, var_map), substitute_inline(t, var_map),
+     substitute_inline(e, var_map)}
   end
 
   defp substitute_inline({:let, name, value}, var_map) do
diff --git a/lib/firebird/compiler/ir.ex b/lib/firebird/compiler/ir.ex
index 97bc311..f140bd7 100644
--- a/lib/firebird/compiler/ir.ex
+++ b/lib/firebird/compiler/ir.ex
@@ -81,9 +81,19 @@ defmodule Firebird.Compiler.IR do
           | {:let, atom(), expr()}
 
   @type op ::
-          :add | :sub | :mul | :div_s | :rem_s
-          | :eq | :ne | :lt_s | :gt_s | :le_s | :ge_s
-          | :and_ | :or_
+          :add
+          | :sub
+          | :mul
+          | :div_s
+          | :rem_s
+          | :eq
+          | :ne
+          | :lt_s
+          | :gt_s
+          | :le_s
+          | :ge_s
+          | :and_
+          | :or_
 
   @type pattern ::
           {:literal_pat, integer()}
diff --git a/lib/firebird/compiler/ir_gen.ex b/lib/firebird/compiler/ir_gen.ex
index d79fb77..dd2ac29 100644
--- a/lib/firebird/compiler/ir_gen.ex
+++ b/lib/firebird/compiler/ir_gen.ex
@@ -51,19 +51,20 @@ defmodule Firebird.Compiler.IRGen do
 
     exports = Enum.map(wasm_functions, fn f -> f.name end) |> Enum.uniq()
 
-    {:ok, %IR.Module{
-      name: module_name,
-      functions: wasm_functions,
-      exports: exports
-    }}
+    {:ok,
+     %IR.Module{
+       name: module_name,
+       functions: wasm_functions,
+       exports: exports
+     }}
   end
 
   # Handle {:__block__, _, _} wrapper
   defp extract_module({:__block__, _, stmts}) do
     case Enum.find(stmts, fn
-      {:defmodule, _, _} -> true
-      _ -> false
-    end) do
+           {:defmodule, _, _} -> true
+           _ -> false
+         end) do
       nil -> {:error, :no_module_found}
       module_ast -> extract_module(module_ast)
     end
@@ -107,8 +108,10 @@ defmodule Firebird.Compiler.IRGen do
     |> Enum.flat_map(fn
       [{:@, _, [{:wasm, _, [true]}]}, {:def, _, [{:when, _, [{name, _, _} | _]} | _]}] ->
         [name]
+
       [{:@, _, [{:wasm, _, [true]}]}, {:def, _, [{name, _, _} | _]}] when name != :when ->
         [name]
+
       _ ->
         []
     end)
@@ -122,13 +125,14 @@ defmodule Firebird.Compiler.IRGen do
     |> Enum.map(&parse_def/1)
     |> Enum.group_by(fn {name, arity, _, _, _} -> {name, arity} end)
     |> Enum.map(fn {{name, arity}, clause_defs} ->
-      clauses = Enum.map(clause_defs, fn {_, _, patterns, guard, body} ->
-        %IR.Clause{
-          patterns: Enum.map(patterns, &pattern_to_ir/1),
-          guard: guard_to_ir(guard),
-          body: expr_to_ir(body)
-        }
-      end)
+      clauses =
+        Enum.map(clause_defs, fn {_, _, patterns, guard, body} ->
+          %IR.Clause{
+            patterns: Enum.map(patterns, &pattern_to_ir/1),
+            guard: guard_to_ir(guard),
+            body: expr_to_ir(body)
+          }
+        end)
 
       # Generate parameter names from the first clause's arity
       params = generate_params(arity)
@@ -184,7 +188,11 @@ defmodule Firebird.Compiler.IRGen do
     if all_variable_patterns?(single.patterns) do
       # Single clause with all variable patterns - just use the body directly
       # But we need to substitute pattern var names with param names
-      substitute_pattern_vars(single.body, single.patterns, generate_params(length(single.patterns)))
+      substitute_pattern_vars(
+        single.body,
+        single.patterns,
+        generate_params(length(single.patterns))
+      )
     else
       build_clause_chain([single], generate_params(length(single.patterns)))
     end
@@ -242,21 +250,30 @@ defmodule Firebird.Compiler.IRGen do
       |> Enum.flat_map(fn
         {{:literal_pat, val}, param} ->
           [{:binop, :eq, {:var, param}, {:literal, val}}]
+
         _ ->
           []
       end)
 
-    base_condition = case conditions do
-      [] -> {:literal, 1}  # always true
-      [single] -> single
-      [first | rest] ->
-        Enum.reduce(rest, first, fn cond, acc ->
-          {:binop, :and_, acc, cond}
-        end)
-    end
+    base_condition =
+      case conditions do
+        # always true
+        [] ->
+          {:literal, 1}
+
+        [single] ->
+          single
+
+        [first | rest] ->
+          Enum.reduce(rest, first, fn cond, acc ->
+            {:binop, :and_, acc, cond}
+          end)
+      end
 
     case guard do
-      nil -> base_condition
+      nil ->
+        base_condition
+
       guard_expr ->
         if base_condition == {:literal, 1} do
           guard_expr
@@ -306,8 +323,7 @@ defmodule Firebird.Compiler.IRGen do
   end
 
   defp substitute_vars({:if, cond, then_b, else_b}, var_map) do
-    {:if, substitute_vars(cond, var_map),
-     substitute_vars(then_b, var_map),
+    {:if, substitute_vars(cond, var_map), substitute_vars(then_b, var_map),
      substitute_vars(else_b, var_map)}
   end
 
@@ -342,8 +358,12 @@ defmodule Firebird.Compiler.IRGen do
   def expr_to_ir({:+, _, [left, right]}), do: {:binop, :add, expr_to_ir(left), expr_to_ir(right)}
   def expr_to_ir({:-, _, [left, right]}), do: {:binop, :sub, expr_to_ir(left), expr_to_ir(right)}
   def expr_to_ir({:*, _, [left, right]}), do: {:binop, :mul, expr_to_ir(left), expr_to_ir(right)}
-  def expr_to_ir({:div, _, [left, right]}), do: {:binop, :div_s, expr_to_ir(left), expr_to_ir(right)}
-  def expr_to_ir({:rem, _, [left, right]}), do: {:binop, :rem_s, expr_to_ir(left), expr_to_ir(right)}
+
+  def expr_to_ir({:div, _, [left, right]}),
+    do: {:binop, :div_s, expr_to_ir(left), expr_to_ir(right)}
+
+  def expr_to_ir({:rem, _, [left, right]}),
+    do: {:binop, :rem_s, expr_to_ir(left), expr_to_ir(right)}
 
   # Unary minus
   def expr_to_ir({:-, _, [expr]}), do: {:binop, :sub, {:literal, 0}, expr_to_ir(expr)}
@@ -353,28 +373,54 @@ defmodule Firebird.Compiler.IRGen do
   def expr_to_ir({:!=, _, [left, right]}), do: {:binop, :ne, expr_to_ir(left), expr_to_ir(right)}
   def expr_to_ir({:<, _, [left, right]}), do: {:binop, :lt_s, expr_to_ir(left), expr_to_ir(right)}
   def expr_to_ir({:>, _, [left, right]}), do: {:binop, :gt_s, expr_to_ir(left), expr_to_ir(right)}
-  def expr_to_ir({:<=, _, [left, right]}), do: {:binop, :le_s, expr_to_ir(left), expr_to_ir(right)}
-  def expr_to_ir({:>=, _, [left, right]}), do: {:binop, :ge_s, expr_to_ir(left), expr_to_ir(right)}
+
+  def expr_to_ir({:<=, _, [left, right]}),
+    do: {:binop, :le_s, expr_to_ir(left), expr_to_ir(right)}
+
+  def expr_to_ir({:>=, _, [left, right]}),
+    do: {:binop, :ge_s, expr_to_ir(left), expr_to_ir(right)}
 
   # Boolean operations
-  def expr_to_ir({:and, _, [left, right]}), do: {:binop, :and_, expr_to_ir(left), expr_to_ir(right)}
+  def expr_to_ir({:and, _, [left, right]}),
+    do: {:binop, :and_, expr_to_ir(left), expr_to_ir(right)}
+
   def expr_to_ir({:or, _, [left, right]}), do: {:binop, :or_, expr_to_ir(left), expr_to_ir(right)}
   def expr_to_ir({:not, _, [expr]}), do: {:unaryop, :not, expr_to_ir(expr)}
 
   # Bitwise operations - operator syntax (&&&, |||, ^^^, <<<, >>>)
-  def expr_to_ir({:&&&, _, [left, right]}), do: {:binop, :band, expr_to_ir(left), expr_to_ir(right)}
-  def expr_to_ir({:|||, _, [left, right]}), do: {:binop, :bor, expr_to_ir(left), expr_to_ir(right)}
-  def expr_to_ir({:"^^^", _, [left, right]}), do: {:binop, :bxor, expr_to_ir(left), expr_to_ir(right)}
-  def expr_to_ir({:<<<, _, [left, right]}), do: {:binop, :shl, expr_to_ir(left), expr_to_ir(right)}
-  def expr_to_ir({:>>>, _, [left, right]}), do: {:binop, :shr_s, expr_to_ir(left), expr_to_ir(right)}
+  def expr_to_ir({:&&&, _, [left, right]}),
+    do: {:binop, :band, expr_to_ir(left), expr_to_ir(right)}
+
+  def expr_to_ir({:|||, _, [left, right]}),
+    do: {:binop, :bor, expr_to_ir(left), expr_to_ir(right)}
+
+  def expr_to_ir({:"^^^", _, [left, right]}),
+    do: {:binop, :bxor, expr_to_ir(left), expr_to_ir(right)}
+
+  def expr_to_ir({:<<<, _, [left, right]}),
+    do: {:binop, :shl, expr_to_ir(left), expr_to_ir(right)}
+
+  def expr_to_ir({:>>>, _, [left, right]}),
+    do: {:binop, :shr_s, expr_to_ir(left), expr_to_ir(right)}
+
   def expr_to_ir({:"~~~", _, [expr]}), do: {:unaryop, :bnot, expr_to_ir(expr)}
 
   # Bitwise operations - function syntax (band, bor, bxor, bsl, bsr, bnot)
-  def expr_to_ir({:band, _, [left, right]}), do: {:binop, :band, expr_to_ir(left), expr_to_ir(right)}
-  def expr_to_ir({:bor, _, [left, right]}), do: {:binop, :bor, expr_to_ir(left), expr_to_ir(right)}
-  def expr_to_ir({:bxor, _, [left, right]}), do: {:binop, :bxor, expr_to_ir(left), expr_to_ir(right)}
-  def expr_to_ir({:bsl, _, [left, right]}), do: {:binop, :shl, expr_to_ir(left), expr_to_ir(right)}
-  def expr_to_ir({:bsr, _, [left, right]}), do: {:binop, :shr_s, expr_to_ir(left), expr_to_ir(right)}
+  def expr_to_ir({:band, _, [left, right]}),
+    do: {:binop, :band, expr_to_ir(left), expr_to_ir(right)}
+
+  def expr_to_ir({:bor, _, [left, right]}),
+    do: {:binop, :bor, expr_to_ir(left), expr_to_ir(right)}
+
+  def expr_to_ir({:bxor, _, [left, right]}),
+    do: {:binop, :bxor, expr_to_ir(left), expr_to_ir(right)}
+
+  def expr_to_ir({:bsl, _, [left, right]}),
+    do: {:binop, :shl, expr_to_ir(left), expr_to_ir(right)}
+
+  def expr_to_ir({:bsr, _, [left, right]}),
+    do: {:binop, :shr_s, expr_to_ir(left), expr_to_ir(right)}
+
   def expr_to_ir({:bnot, _, [expr]}), do: {:unaryop, :bnot, expr_to_ir(expr)}
 
   # if/else (must be before the generic function call catch-all)
@@ -406,9 +452,11 @@ defmodule Firebird.Compiler.IRGen do
 
   # case expression
   def expr_to_ir({:case, _, [subject, [do: clauses]]}) do
-    ir_clauses = Enum.map(clauses, fn {:->, _, [[pattern], body]} ->
-      {pattern_to_ir(pattern), nil, expr_to_ir(body)}
-    end)
+    ir_clauses =
+      Enum.map(clauses, fn {:->, _, [[pattern], body]} ->
+        {pattern_to_ir(pattern), nil, expr_to_ir(body)}
+      end)
+
     {:case, expr_to_ir(subject), ir_clauses}
   end
 
@@ -439,11 +487,11 @@ defmodule Firebird.Compiler.IRGen do
   def expr_to_ir({{:., _, [{:__aliases__, _, [:Bitwise]}, func]}, _, args}) do
     case {func, args} do
       {:band, [left, right]} -> {:binop, :band, expr_to_ir(left), expr_to_ir(right)}
-      {:bor, [left, right]}  -> {:binop, :bor, expr_to_ir(left), expr_to_ir(right)}
+      {:bor, [left, right]} -> {:binop, :bor, expr_to_ir(left), expr_to_ir(right)}
       {:bxor, [left, right]} -> {:binop, :bxor, expr_to_ir(left), expr_to_ir(right)}
-      {:bsl, [left, right]}  -> {:binop, :shl, expr_to_ir(left), expr_to_ir(right)}
-      {:bsr, [left, right]}  -> {:binop, :shr_s, expr_to_ir(left), expr_to_ir(right)}
-      {:bnot, [expr]}        -> {:unaryop, :bnot, expr_to_ir(expr)}
+      {:bsl, [left, right]} -> {:binop, :shl, expr_to_ir(left), expr_to_ir(right)}
+      {:bsr, [left, right]} -> {:binop, :shr_s, expr_to_ir(left), expr_to_ir(right)}
+      {:bnot, [expr]} -> {:unaryop, :bnot, expr_to_ir(expr)}
       _ -> {:error_node, {:unsupported_bitwise, func}}
     end
   end
diff --git a/lib/firebird/compiler/licm.ex b/lib/firebird/compiler/licm.ex
index b85eb07..6fd454c 100644
--- a/lib/firebird/compiler/licm.ex
+++ b/lib/firebird/compiler/licm.ex
@@ -131,8 +131,7 @@ defmodule Firebird.Compiler.LICM do
   end
 
   def licm_expr({:if, c, t, e}, func_params, opts) do
-    {:if, licm_expr(c, func_params, opts),
-     licm_expr(t, func_params, opts),
+    {:if, licm_expr(c, func_params, opts), licm_expr(t, func_params, opts),
      licm_expr(e, func_params, opts)}
   end
 
@@ -213,6 +212,7 @@ defmodule Firebird.Compiler.LICM do
 
   defp do_collect({:case, subject, clauses}, ni, ms, acc) do
     acc = do_collect(subject, ni, ms, acc)
+
     Enum.reduce(clauses, acc, fn {_pat, _guard, body}, a ->
       do_collect(body, ni, ms, a)
     end)
@@ -279,20 +279,30 @@ defmodule Firebird.Compiler.LICM do
   end
 
   defp collect_let_names({:if, c, t, e}) do
-    [c, t, e] |> Enum.reduce(MapSet.new(), fn e, acc -> MapSet.union(acc, collect_let_names(e)) end)
+    [c, t, e]
+    |> Enum.reduce(MapSet.new(), fn e, acc -> MapSet.union(acc, collect_let_names(e)) end)
   end
 
   defp collect_let_names({:case, subject, clauses}) do
-    clause_lets = Enum.reduce(clauses, MapSet.new(), fn {_, _, body}, acc ->
-      MapSet.union(acc, collect_let_names(body))
-    end)
+    clause_lets =
+      Enum.reduce(clauses, MapSet.new(), fn {_, _, body}, acc ->
+        MapSet.union(acc, collect_let_names(body))
+      end)
+
     MapSet.union(collect_let_names(subject), clause_lets)
   end
 
-  defp collect_let_names({:binop, _, l, r}), do: MapSet.union(collect_let_names(l), collect_let_names(r))
+  defp collect_let_names({:binop, _, l, r}),
+    do: MapSet.union(collect_let_names(l), collect_let_names(r))
+
   defp collect_let_names({:unaryop, _, e}), do: collect_let_names(e)
-  defp collect_let_names({:call, _, args}), do: Enum.reduce(args, MapSet.new(), fn a, acc -> MapSet.union(acc, collect_let_names(a)) end)
-  defp collect_let_names({:tail_call, _, args}), do: Enum.reduce(args, MapSet.new(), fn a, acc -> MapSet.union(acc, collect_let_names(a)) end)
+
+  defp collect_let_names({:call, _, args}),
+    do: Enum.reduce(args, MapSet.new(), fn a, acc -> MapSet.union(acc, collect_let_names(a)) end)
+
+  defp collect_let_names({:tail_call, _, args}),
+    do: Enum.reduce(args, MapSet.new(), fn a, acc -> MapSet.union(acc, collect_let_names(a)) end)
+
   defp collect_let_names(_), do: MapSet.new()
 
   # Check if an expression tree contains a specific subexpression
@@ -314,7 +324,8 @@ defmodule Firebird.Compiler.LICM do
   end
 
   defp contains_expr?({:case, s, clauses}, target) do
-    contains_expr?(s, target) or Enum.any?(clauses, fn {_, _, body} -> contains_expr?(body, target) end)
+    contains_expr?(s, target) or
+      Enum.any?(clauses, fn {_, _, body} -> contains_expr?(body, target) end)
   end
 
   defp contains_expr?({:let, _, v}, target), do: contains_expr?(v, target)
@@ -336,22 +347,26 @@ defmodule Firebird.Compiler.LICM do
   defp replace_expr(expr, target, replacement) when expr == target, do: replacement
 
   defp replace_expr({:binop, op, l, r} = expr, target, repl) do
-    if expr == target, do: repl,
-    else: {:binop, op, replace_expr(l, target, repl), replace_expr(r, target, repl)}
+    if expr == target,
+      do: repl,
+      else: {:binop, op, replace_expr(l, target, repl), replace_expr(r, target, repl)}
   end
 
   defp replace_expr({:unaryop, op, e} = expr, target, repl) do
-    if expr == target, do: repl,
-    else: {:unaryop, op, replace_expr(e, target, repl)}
+    if expr == target,
+      do: repl,
+      else: {:unaryop, op, replace_expr(e, target, repl)}
   end
 
   defp replace_expr({:call, name, args} = expr, target, repl) do
-    if expr == target, do: repl,
-    else: {:call, name, Enum.map(args, &replace_expr(&1, target, repl))}
+    if expr == target,
+      do: repl,
+      else: {:call, name, Enum.map(args, &replace_expr(&1, target, repl))}
   end
 
   defp replace_expr({:if, c, t, e}, target, repl) do
-    {:if, replace_expr(c, target, repl), replace_expr(t, target, repl), replace_expr(e, target, repl)}
+    {:if, replace_expr(c, target, repl), replace_expr(t, target, repl),
+     replace_expr(e, target, repl)}
   end
 
   defp replace_expr({:case, s, clauses}, target, repl) do
diff --git a/lib/firebird/compiler/optimizer.ex b/lib/firebird/compiler/optimizer.ex
index 8cdc952..dc4b43e 100644
--- a/lib/firebird/compiler/optimizer.ex
+++ b/lib/firebird/compiler/optimizer.ex
@@ -35,10 +35,24 @@ defmodule Firebird.Compiler.Optimizer do
 
   alias Firebird.Compiler.IR
 
-  @type pass :: :constant_fold | :dead_code | :strength_reduce | :identity_elim | :dead_let_elim | :algebraic_simplify | :cse
+  @type pass ::
+          :constant_fold
+          | :dead_code
+          | :strength_reduce
+          | :identity_elim
+          | :dead_let_elim
+          | :algebraic_simplify
+          | :cse
   @type opts :: [passes: [pass()]]
 
-  @all_passes [:constant_fold, :dead_code, :strength_reduce, :identity_elim, :algebraic_simplify, :dead_let_elim]
+  @all_passes [
+    :constant_fold,
+    :dead_code,
+    :strength_reduce,
+    :identity_elim,
+    :algebraic_simplify,
+    :dead_let_elim
+  ]
 
   @doc """
   Run optimization passes on a module IR.
@@ -74,9 +88,10 @@ defmodule Firebird.Compiler.Optimizer do
 
   # Run all requested passes, iterating until fixpoint
   defp run_passes(expr, passes) do
-    optimized = Enum.reduce(passes, expr, fn pass, acc ->
-      apply_pass(acc, pass)
-    end)
+    optimized =
+      Enum.reduce(passes, expr, fn pass, acc ->
+        apply_pass(acc, pass)
+      end)
 
     # Run again if something changed (fixpoint iteration)
     if optimized != expr do
@@ -121,8 +136,12 @@ defmodule Firebird.Compiler.Optimizer do
   end
 
   def constant_fold({:unaryop, :not, {:literal, 0}}), do: {:literal, 1}
-  def constant_fold({:unaryop, :not, {:literal, n}}) when is_integer(n) and n != 0, do: {:literal, 0}
-  def constant_fold({:unaryop, :bnot, {:literal, n}}) when is_integer(n), do: {:literal, Bitwise.bnot(n)}
+
+  def constant_fold({:unaryop, :not, {:literal, n}}) when is_integer(n) and n != 0,
+    do: {:literal, 0}
+
+  def constant_fold({:unaryop, :bnot, {:literal, n}}) when is_integer(n),
+    do: {:literal, Bitwise.bnot(n)}
 
   def constant_fold({:unaryop, op, expr}) do
     {:unaryop, op, constant_fold(expr)}
@@ -165,9 +184,11 @@ defmodule Firebird.Compiler.Optimizer do
   defp eval_binop(:add, a, b), do: {:ok, a + b}
   defp eval_binop(:sub, a, b), do: {:ok, a - b}
   defp eval_binop(:mul, a, b), do: {:ok, a * b}
-  defp eval_binop(:div_s, _, 0), do: :error  # Don't fold division by zero
+  # Don't fold division by zero
+  defp eval_binop(:div_s, _, 0), do: :error
   defp eval_binop(:div_s, a, b), do: {:ok, div(a, b)}
-  defp eval_binop(:rem_s, _, 0), do: :error  # Don't fold rem by zero
+  # Don't fold rem by zero
+  defp eval_binop(:rem_s, _, 0), do: :error
   defp eval_binop(:rem_s, a, b), do: {:ok, rem(a, b)}
   defp eval_binop(:eq, a, b), do: {:ok, if(a == b, do: 1, else: 0)}
   defp eval_binop(:ne, a, b), do: {:ok, if(a != b, do: 1, else: 0)}
@@ -256,6 +277,7 @@ defmodule Firebird.Compiler.Optimizer do
   # x * power_of_2 → x << log2(power_of_2)
   def strength_reduce({:binop, :mul, left, {:literal, n}}) when is_integer(n) and n > 1 do
     left = strength_reduce(left)
+
     case power_of_two?(n) do
       {:ok, shift} -> {:binop, :shl, left, {:literal, shift}}
       :no -> {:binop, :mul, left, {:literal, n}}
@@ -264,6 +286,7 @@ defmodule Firebird.Compiler.Optimizer do
 
   def strength_reduce({:binop, :mul, {:literal, n}, right}) when is_integer(n) and n > 1 do
     right = strength_reduce(right)
+
     case power_of_two?(n) do
       {:ok, shift} -> {:binop, :shl, right, {:literal, shift}}
       :no -> {:binop, :mul, {:literal, n}, right}
@@ -276,6 +299,7 @@ defmodule Firebird.Compiler.Optimizer do
   # cases (e.g. collatz: div(n, 2) where n is always positive).
   def strength_reduce({:binop, :div_s, left, {:literal, n}}) when is_integer(n) and n > 1 do
     left = strength_reduce(left)
+
     case power_of_two?(n) do
       {:ok, shift} -> {:binop, :shr_s, left, {:literal, shift}}
       :no -> {:binop, :div_s, left, {:literal, n}}
@@ -287,6 +311,7 @@ defmodule Firebird.Compiler.Optimizer do
   # in parity checks (rem(n, 2) == 0) and modular arithmetic.
   def strength_reduce({:binop, :rem_s, left, {:literal, n}}) when is_integer(n) and n > 1 do
     left = strength_reduce(left)
+
     case power_of_two?(n) do
       {:ok, _shift} -> {:binop, :band, left, {:literal, n - 1}}
       :no -> {:binop, :rem_s, left, {:literal, n}}
@@ -630,13 +655,21 @@ defmodule Firebird.Compiler.Optimizer do
   # x and false → 0
   def algebraic_simplify({:binop, :and_, _, {:literal, 0}}), do: {:literal, 0}
   # true and x → x (identity for truthiness conversion via i32)
-  def algebraic_simplify({:binop, :and_, {:literal, n}, expr}) when is_integer(n) and n != 0, do: algebraic_simplify(expr)
+  def algebraic_simplify({:binop, :and_, {:literal, n}, expr}) when is_integer(n) and n != 0,
+    do: algebraic_simplify(expr)
+
   # x and true → x
-  def algebraic_simplify({:binop, :and_, expr, {:literal, n}}) when is_integer(n) and n != 0, do: algebraic_simplify(expr)
+  def algebraic_simplify({:binop, :and_, expr, {:literal, n}}) when is_integer(n) and n != 0,
+    do: algebraic_simplify(expr)
+
   # true or x → 1 (short-circuit)
-  def algebraic_simplify({:binop, :or_, {:literal, n}, _}) when is_integer(n) and n != 0, do: {:literal, 1}
+  def algebraic_simplify({:binop, :or_, {:literal, n}, _}) when is_integer(n) and n != 0,
+    do: {:literal, 1}
+
   # x or true → 1
-  def algebraic_simplify({:binop, :or_, _, {:literal, n}}) when is_integer(n) and n != 0, do: {:literal, 1}
+  def algebraic_simplify({:binop, :or_, _, {:literal, n}}) when is_integer(n) and n != 0,
+    do: {:literal, 1}
+
   # false or x → x
   def algebraic_simplify({:binop, :or_, {:literal, 0}, expr}), do: algebraic_simplify(expr)
   # x or false → x
@@ -702,7 +735,7 @@ defmodule Firebird.Compiler.Optimizer do
 
   # Check if n is a power of 2, return the exponent
   defp power_of_two?(n) when n > 0 do
-    if (n &&& (n - 1)) == 0 do
+    if (n &&& n - 1) == 0 do
       {:ok, round(:math.log2(n))}
     else
       :no
diff --git a/lib/firebird/compiler/source_map.ex b/lib/firebird/compiler/source_map.ex
index 9b419b2..147282e 100644
--- a/lib/firebird/compiler/source_map.ex
+++ b/lib/firebird/compiler/source_map.ex
@@ -95,15 +95,16 @@ defmodule Firebird.Compiler.SourceMap do
       "module" => Atom.to_string(sm.module),
       "source" => sm.source,
       "compiled_at" => DateTime.to_iso8601(sm.compiled_at),
-      "exports" => Enum.map(sm.entries, fn e ->
-        %{
-          "function" => Atom.to_string(e.function),
-          "arity" => e.arity,
-          "export_name" => e.export_name,
-          "params" => Enum.map(e.params, &Atom.to_string/1),
-          "tail_recursive" => e.tail_recursive
-        }
-      end)
+      "exports" =>
+        Enum.map(sm.entries, fn e ->
+          %{
+            "function" => Atom.to_string(e.function),
+            "arity" => e.arity,
+            "export_name" => e.export_name,
+            "params" => Enum.map(e.params, &Atom.to_string/1),
+            "tail_recursive" => e.tail_recursive
+          }
+        end)
     }
   end
 
diff --git a/lib/firebird/compiler/summary.ex b/lib/firebird/compiler/summary.ex
index 8f384d8..55a0cda 100644
--- a/lib/firebird/compiler/summary.ex
+++ b/lib/firebird/compiler/summary.ex
@@ -56,8 +56,7 @@ defmodule Firebird.Compiler.Summary do
           else: nil
         ),
       modules: modules,
-      errors:
-        Enum.map(failures, fn {:error, reason} -> inspect(reason) end)
+      errors: Enum.map(failures, fn {:error, reason} -> inspect(reason) end)
     }
   end
 
@@ -96,8 +95,7 @@ defmodule Firebird.Compiler.Summary do
 
     lines =
       if Enum.any?(summary.errors) do
-        error_lines =
-          Enum.map(summary.errors, fn e -> "     ❌ #{e}" end)
+        error_lines = Enum.map(summary.errors, fn e -> "     ❌ #{e}" end)
 
         lines ++ ["   Errors:"] ++ error_lines
       else
@@ -128,4 +126,3 @@ defmodule Firebird.Compiler.Summary do
   defp format_bytes(bytes) when bytes < 1_048_576, do: "#{Float.round(bytes / 1024, 1)}KB"
   defp format_bytes(bytes), do: "#{Float.round(bytes / 1_048_576, 1)}MB"
 end
-
diff --git a/lib/firebird/compiler/tco.ex b/lib/firebird/compiler/tco.ex
index 37f3c59..100f8f2 100644
--- a/lib/firebird/compiler/tco.ex
+++ b/lib/firebird/compiler/tco.ex
@@ -74,15 +74,24 @@ defmodule Firebird.Compiler.TCO do
   """
   @spec has_self_calls?(term(), atom()) :: boolean()
   def has_self_calls?({:call, name, _args}, name), do: true
-  def has_self_calls?({:call, _other, args}, name), do: Enum.any?(args, &has_self_calls?(&1, name))
-  def has_self_calls?({:binop, _, left, right}, name), do: has_self_calls?(left, name) or has_self_calls?(right, name)
+
+  def has_self_calls?({:call, _other, args}, name),
+    do: Enum.any?(args, &has_self_calls?(&1, name))
+
+  def has_self_calls?({:binop, _, left, right}, name),
+    do: has_self_calls?(left, name) or has_self_calls?(right, name)
+
   def has_self_calls?({:unaryop, _, expr}, name), do: has_self_calls?(expr, name)
+
   def has_self_calls?({:if, cond, then_b, else_b}, name) do
     has_self_calls?(cond, name) or has_self_calls?(then_b, name) or has_self_calls?(else_b, name)
   end
+
   def has_self_calls?({:case, subj, clauses}, name) do
-    has_self_calls?(subj, name) or Enum.any?(clauses, fn {_, _, body} -> has_self_calls?(body, name) end)
+    has_self_calls?(subj, name) or
+      Enum.any?(clauses, fn {_, _, body} -> has_self_calls?(body, name) end)
   end
+
   def has_self_calls?({:let, _, value}, name), do: has_self_calls?(value, name)
   def has_self_calls?({:block, exprs}, name), do: Enum.any?(exprs, &has_self_calls?(&1, name))
   def has_self_calls?(_, _), do: false
@@ -102,10 +111,12 @@ defmodule Firebird.Compiler.TCO do
   defp has_non_tail_self_calls?({:call, name, args}, name, in_tail) do
     # The call itself: if not in tail position, it's a non-tail call
     args_have_non_tail = Enum.any?(args, &has_non_tail_self_calls?(&1, name, false))
+
     if in_tail do
       args_have_non_tail
     else
-      true  # This self-call is not in tail position
+      # This self-call is not in tail position
+      true
     end
   end
 
@@ -147,6 +158,7 @@ defmodule Firebird.Compiler.TCO do
 
   defp has_non_tail_self_calls?({:block, exprs}, name, in_tail) do
     {init, [last]} = Enum.split(exprs, -1)
+
     Enum.any?(init, &has_non_tail_self_calls?(&1, name, false)) or
       has_non_tail_self_calls?(last, name, in_tail)
   end
@@ -170,9 +182,11 @@ defmodule Firebird.Compiler.TCO do
   end
 
   defp mark_tail_calls({:case, subj, clauses}, name, params) do
-    clauses = Enum.map(clauses, fn {pat, guard, body} ->
-      {pat, guard, mark_tail_calls(body, name, params)}
-    end)
+    clauses =
+      Enum.map(clauses, fn {pat, guard, body} ->
+        {pat, guard, mark_tail_calls(body, name, params)}
+      end)
+
     {:case, subj, clauses}
   end
 
diff --git a/lib/firebird/compiler/type_inference.ex b/lib/firebird/compiler/type_inference.ex
index bab20e5..be39593 100644
--- a/lib/firebird/compiler/type_inference.ex
+++ b/lib/firebird/compiler/type_inference.ex
@@ -37,10 +37,11 @@ defmodule Firebird.Compiler.TypeInference do
   def infer(%IR.Module{} = module) do
     typed_functions = Enum.map(module.functions, &infer_function/1)
 
-    errors = Enum.filter(typed_functions, fn
-      {:error, _} -> true
-      _ -> false
-    end)
+    errors =
+      Enum.filter(typed_functions, fn
+        {:error, _} -> true
+        _ -> false
+      end)
 
     if Enum.empty?(errors) do
       {:ok, %{module | functions: typed_functions}}
@@ -57,24 +58,29 @@ defmodule Firebird.Compiler.TypeInference do
     # Check if any clause has float literals in patterns
     has_floats = check_for_floats(func.body)
 
-    param_types = if has_floats do
-      List.duplicate(:f64, func.arity)
-    else
-      List.duplicate(:i64, func.arity)
-    end
+    param_types =
+      if has_floats do
+        List.duplicate(:f64, func.arity)
+      else
+        List.duplicate(:i64, func.arity)
+      end
 
-    env = if has_floats do
-      Map.new(func.params, fn p -> {p, :f64} end)
-    else
-      env
-    end
+    env =
+      if has_floats do
+        Map.new(func.params, fn p -> {p, :f64} end)
+      else
+        env
+      end
 
     return_type = infer_expr_type(func.body, env)
 
-    %{func | type: %IR.FunctionType{
-      params: param_types,
-      return: return_type
-    }}
+    %{
+      func
+      | type: %IR.FunctionType{
+          params: param_types,
+          return: return_type
+        }
+    }
   end
 
   @doc """
@@ -154,8 +160,13 @@ defmodule Firebird.Compiler.TypeInference do
   defp widen_type(_, _), do: :i64
 
   defp check_for_floats({:literal, n}) when is_float(n), do: true
-  defp check_for_floats({:binop, _, left, right}), do: check_for_floats(left) or check_for_floats(right)
-  defp check_for_floats({:if, c, t, e}), do: check_for_floats(c) or check_for_floats(t) or check_for_floats(e)
+
+  defp check_for_floats({:binop, _, left, right}),
+    do: check_for_floats(left) or check_for_floats(right)
+
+  defp check_for_floats({:if, c, t, e}),
+    do: check_for_floats(c) or check_for_floats(t) or check_for_floats(e)
+
   defp check_for_floats({:call, _, args}), do: Enum.any?(args, &check_for_floats/1)
   defp check_for_floats({:let, _, value}), do: check_for_floats(value)
   defp check_for_floats({:block, exprs}), do: Enum.any?(exprs, &check_for_floats/1)
diff --git a/lib/firebird/compiler/validator.ex b/lib/firebird/compiler/validator.ex
index be4bba8..c7718f3 100644
--- a/lib/firebird/compiler/validator.ex
+++ b/lib/firebird/compiler/validator.ex
@@ -67,9 +67,26 @@ defmodule Firebird.Compiler.Validator do
   def validate_expr({:var, _name}, _ctx), do: []
 
   def validate_expr({:binop, op, left, right}, ctx)
-      when op in [:add, :sub, :mul, :div_s, :rem_s,
-                  :eq, :ne, :lt_s, :gt_s, :le_s, :ge_s,
-                  :and_, :or_, :shl, :shr_s, :band, :bor, :bxor] do
+      when op in [
+             :add,
+             :sub,
+             :mul,
+             :div_s,
+             :rem_s,
+             :eq,
+             :ne,
+             :lt_s,
+             :gt_s,
+             :le_s,
+             :ge_s,
+             :and_,
+             :or_,
+             :shl,
+             :shr_s,
+             :band,
+             :bor,
+             :bxor
+           ] do
     validate_expr(left, ctx) ++ validate_expr(right, ctx)
   end
 
@@ -87,9 +104,12 @@ defmodule Firebird.Compiler.Validator do
 
   def validate_expr({:case, subject, clauses}, ctx) do
     subject_errors = validate_expr(subject, ctx)
-    clause_errors = Enum.flat_map(clauses, fn {_pat, _guard, body} ->
-      validate_expr(body, ctx)
-    end)
+
+    clause_errors =
+      Enum.flat_map(clauses, fn {_pat, _guard, body} ->
+        validate_expr(body, ctx)
+      end)
+
     subject_errors ++ clause_errors
   end
 
diff --git a/lib/firebird/compiler/wat_gen.ex b/lib/firebird/compiler/wat_gen.ex
index 662e914..a5b8888 100644
--- a/lib/firebird/compiler/wat_gen.ex
+++ b/lib/firebird/compiler/wat_gen.ex
@@ -62,10 +62,13 @@ defmodule Firebird.Compiler.WATGen do
   # Build a map of function name → %IR.FunctionType{} for all module functions
   defp build_func_type_map(functions) do
     Map.new(functions, fn func ->
-      type = func.type || %IR.FunctionType{
-        params: List.duplicate(:i64, func.arity),
-        return: :i64
-      }
+      type =
+        func.type ||
+          %IR.FunctionType{
+            params: List.duplicate(:i64, func.arity),
+            return: :i64
+          }
+
       {func.name, type}
     end)
   end
@@ -75,10 +78,12 @@ defmodule Firebird.Compiler.WATGen do
   """
   @spec generate_function(IR.Function.t(), map()) :: String.t()
   def generate_function(%IR.Function{} = func, func_types \\ %{}) do
-    type = func.type || %IR.FunctionType{
-      params: List.duplicate(:i64, func.arity),
-      return: :i64
-    }
+    type =
+      func.type ||
+        %IR.FunctionType{
+          params: List.duplicate(:i64, func.arity),
+          return: :i64
+        }
 
     # Build type environment: param name → wasm type
     type_env = Map.new(Enum.zip(func.params, type.params))
@@ -148,6 +153,7 @@ defmodule Firebird.Compiler.WATGen do
 
   defp collect_let_vars({:let, name, value}, params) do
     inner = collect_let_vars(value, params)
+
     if name in params do
       inner
     else
@@ -183,9 +189,12 @@ defmodule Firebird.Compiler.WATGen do
 
   defp collect_let_vars({:case, subject, clauses}, params) do
     subject_locals = collect_let_vars(subject, params)
-    clause_locals = Enum.reduce(clauses, MapSet.new(), fn {_, _, body}, acc ->
-      MapSet.union(acc, collect_let_vars(body, params))
-    end)
+
+    clause_locals =
+      Enum.reduce(clauses, MapSet.new(), fn {_, _, body}, acc ->
+        MapSet.union(acc, collect_let_vars(body, params))
+      end)
+
     # Also need __case_subject local
     MapSet.union(subject_locals, clause_locals)
     |> MapSet.put(:__case_subject)
@@ -238,10 +247,13 @@ defmodule Firebird.Compiler.WATGen do
 
   defp collect_local_types_acc({:case, subject, clauses}, te, ftm, acc) do
     {_, acc} = collect_local_types_acc(subject, te, ftm, acc)
-    acc = Enum.reduce(clauses, acc, fn {_, _, body}, cur_acc ->
-      {_, cur_acc} = collect_local_types_acc(body, te, ftm, cur_acc)
-      cur_acc
-    end)
+
+    acc =
+      Enum.reduce(clauses, acc, fn {_, _, body}, cur_acc ->
+        {_, cur_acc} = collect_local_types_acc(body, te, ftm, cur_acc)
+        cur_acc
+      end)
+
     {te, acc}
   end
 
@@ -251,10 +263,12 @@ defmodule Firebird.Compiler.WATGen do
   end
 
   defp collect_local_types_acc({:tail_call, _, args}, te, ftm, acc) do
-    acc = Enum.reduce(args, acc, fn arg, cur_acc ->
-      {_, cur_acc} = collect_local_types_acc(arg, te, ftm, cur_acc)
-      cur_acc
-    end)
+    acc =
+      Enum.reduce(args, acc, fn arg, cur_acc ->
+        {_, cur_acc} = collect_local_types_acc(arg, te, ftm, cur_acc)
+        cur_acc
+      end)
+
     {te, acc}
   end
 
@@ -269,10 +283,12 @@ defmodule Firebird.Compiler.WATGen do
   end
 
   defp collect_local_types_acc({:call, _, args}, te, ftm, acc) do
-    acc = Enum.reduce(args, acc, fn arg, cur_acc ->
-      {_, cur_acc} = collect_local_types_acc(arg, te, ftm, cur_acc)
-      cur_acc
-    end)
+    acc =
+      Enum.reduce(args, acc, fn arg, cur_acc ->
+        {_, cur_acc} = collect_local_types_acc(arg, te, ftm, cur_acc)
+        cur_acc
+      end)
+
     {te, acc}
   end
 
@@ -287,10 +303,8 @@ defmodule Firebird.Compiler.WATGen do
   #   - type_env: map of variable name → WASM type (for locals/params)
   #   - func_types: map of function name → %IR.FunctionType{} (for calls)
 
-  defp generate_expr(expr, target_type, ft) do
-    # Backward-compatible 3-arity entry point (no type_env/func_types)
-    generate_expr(expr, target_type, ft, %{}, %{})
-  end
+  # NOTE: generate_expr/3 removed — use generate_expr/5 directly with
+  # explicit type_env and func_types maps.
 
   defp generate_expr({:literal, n}, target_type, _ft, _te, _ftm) when is_integer(n) do
     case target_type do
@@ -347,6 +361,7 @@ defmodule Firebird.Compiler.WATGen do
 
   defp generate_expr({:unaryop, :negate, expr}, target_type, ft, te, ftm) do
     expr_type = infer_expr_wasm_type(expr, te, ftm)
+
     if expr_type == :f64 do
       inner = generate_expr(expr, :f64, ft, te, ftm)
       result = "#{inner}\nf64.neg"
@@ -384,11 +399,12 @@ defmodule Firebird.Compiler.WATGen do
 
     return_type = if callee_type, do: callee_type.return, else: :i64
 
-    result = if args_wat == "" do
-      "call $#{name}"
-    else
-      "#{args_wat}\ncall $#{name}"
-    end
+    result =
+      if args_wat == "" do
+        "call $#{name}"
+      else
+        "#{args_wat}\ncall $#{name}"
+      end
 
     coerce(result, return_type, target_type)
   end
@@ -430,6 +446,7 @@ defmodule Firebird.Compiler.WATGen do
   defp generate_expr({:tail_loop, _loop_params, body}, target_type, ft, te, ftm) do
     body_wat = generate_tco_body(body, target_type, ft, te, ftm)
     result_type = wasm_type(target_type)
+
     """
     (block $__tco_exit (result #{result_type})
     (loop $__tco_loop
@@ -534,7 +551,8 @@ defmodule Firebird.Compiler.WATGen do
   end
 
   # Blocks in TCO bodies: init exprs are normal, last expr may be a tail_call
-  defp generate_tco_body({:block, exprs}, target_type, ft, te, ftm) when is_list(exprs) and length(exprs) > 0 do
+  defp generate_tco_body({:block, exprs}, target_type, ft, te, ftm)
+       when is_list(exprs) and length(exprs) > 0 do
     {init, [last]} = Enum.split(exprs, -1)
 
     init_wat =
@@ -584,6 +602,7 @@ defmodule Firebird.Compiler.WATGen do
 
   defp generate_tco_body(expr, target_type, ft, te, ftm) do
     result_wat = generate_expr(expr, target_type, ft, te, ftm)
+
     """
     #{result_wat}
     br $__tco_exit\
@@ -630,8 +649,19 @@ defmodule Firebird.Compiler.WATGen do
       range = max_val - min_val + 1
 
       if range <= count * @br_table_density_factor and range <= 256 and min_val >= 0 do
-        {:ok, gen_br_table(literal_clauses, default_clause, min_val, range,
-                           subject_local, target_type, ft, te, ftm, mode)}
+        {:ok,
+         gen_br_table(
+           literal_clauses,
+           default_clause,
+           min_val,
+           range,
+           subject_local,
+           target_type,
+           ft,
+           te,
+           ftm,
+           mode
+         )}
       else
         :fallback
       end
@@ -686,8 +716,18 @@ defmodule Firebird.Compiler.WATGen do
   #   )
   #
   # br_table index 0 → innermost block ($__jt_0), index N → $__jt_default.
-  defp gen_br_table(literal_clauses, default_body, min_val, _range,
-                    subject_local, target_type, ft, te, ftm, mode) do
+  defp gen_br_table(
+         literal_clauses,
+         default_body,
+         min_val,
+         _range,
+         subject_local,
+         target_type,
+         ft,
+         te,
+         ftm,
+         mode
+       ) do
     value_to_idx =
       literal_clauses
       |> Enum.with_index()
@@ -701,7 +741,7 @@ defmodule Firebird.Compiler.WATGen do
       Enum.map(literal_clauses, fn {_val, body} ->
         case mode do
           :expr -> generate_expr(body, target_type, ft, te, ftm)
-          :tco  -> generate_tco_body(body, target_type, ft, te, ftm)
+          :tco -> generate_tco_body(body, target_type, ft, te, ftm)
         end
       end)
 
@@ -709,9 +749,9 @@ defmodule Firebird.Compiler.WATGen do
     default_body_wat =
       case {default_body, mode} do
         {nil, :expr} -> "#{wasm_type(target_type)}.const 0  ;; unreachable default"
-        {nil, :tco}  -> "unreachable  ;; no matching case clause"
+        {nil, :tco} -> "unreachable  ;; no matching case clause"
         {body, :expr} -> generate_expr(body, target_type, ft, te, ftm)
-        {body, :tco}  -> generate_tco_body(body, target_type, ft, te, ftm)
+        {body, :tco} -> generate_tco_body(body, target_type, ft, te, ftm)
       end
 
     # Build the br_table label list for each slot in [min_val .. max_val]
@@ -722,6 +762,7 @@ defmodule Firebird.Compiler.WATGen do
       0..(range - 1)
       |> Enum.map(fn offset ->
         val = min_val + offset
+
         case Map.get(value_to_idx, val) do
           nil -> "$__jt_default"
           idx -> "$__jt_#{idx}"
@@ -732,18 +773,20 @@ defmodule Firebird.Compiler.WATGen do
     # Dispatch: normalize subject to 0-based index, then br_table
     subtract_wat = if min_val == 0, do: "", else: "i64.const #{min_val}\ni64.sub\n"
 
-    dispatch = String.trim("""
-    local.get #{subject_local}
-    #{subtract_wat}i32.wrap_i64
-    br_table #{br_labels} $__jt_default\
-    """)
+    dispatch =
+      String.trim("""
+      local.get #{subject_local}
+      #{subtract_wat}i32.wrap_i64
+      br_table #{br_labels} $__jt_default\
+      """)
 
     # Build from innermost outward: start with dispatch, wrap in blocks,
     # interleave clause bodies after each block close.
-    exit_br = case mode do
-      :expr -> "\nbr $__jt_exit"
-      :tco  -> ""
-    end
+    exit_br =
+      case mode do
+        :expr -> "\nbr $__jt_exit"
+        :tco -> ""
+      end
 
     result =
       Enum.reduce(0..(n - 1), dispatch, fn idx, code ->
@@ -757,7 +800,7 @@ defmodule Firebird.Compiler.WATGen do
     # For expr mode, wrap in typed $__jt_exit block
     case mode do
       :expr -> "(block $__jt_exit (result #{result_type_str})\n#{result}\n)"
-      :tco  -> result
+      :tco -> result
     end
   end
 
@@ -771,6 +814,7 @@ defmodule Firebird.Compiler.WATGen do
       {:literal_pat, val} ->
         body_wat = generate_expr(body, target_type, ft, te, ftm)
         else_wat = generate_case_clauses(rest, subject, target_type, ft, te, ftm)
+
         """
         local.get #{subject}
         i64.const #{val}
@@ -797,11 +841,19 @@ defmodule Firebird.Compiler.WATGen do
     "unreachable  ;; no matching case clause"
   end
 
-  defp generate_tco_case_clauses([{pattern, _guard, body} | rest], subject, target_type, ft, te, ftm) do
+  defp generate_tco_case_clauses(
+         [{pattern, _guard, body} | rest],
+         subject,
+         target_type,
+         ft,
+         te,
+         ftm
+       ) do
     case pattern do
       {:literal_pat, val} ->
         body_wat = generate_tco_body(body, target_type, ft, te, ftm)
         else_wat = generate_tco_case_clauses(rest, subject, target_type, ft, te, ftm)
+
         """
         local.get #{subject}
         i64.const #{val}
@@ -844,7 +896,9 @@ defmodule Firebird.Compiler.WATGen do
 
   defp infer_expr_wasm_type({:unaryop, :not, _}, _te, _ftm), do: :i32
   defp infer_expr_wasm_type({:unaryop, :bnot, _}, _te, _ftm), do: :i64
-  defp infer_expr_wasm_type({:unaryop, :negate, expr}, te, ftm), do: infer_expr_wasm_type(expr, te, ftm)
+
+  defp infer_expr_wasm_type({:unaryop, :negate, expr}, te, ftm),
+    do: infer_expr_wasm_type(expr, te, ftm)
 
   defp infer_expr_wasm_type({:call, name, _args}, _te, ftm) do
     case Map.get(ftm, name) do
@@ -853,15 +907,21 @@ defmodule Firebird.Compiler.WATGen do
     end
   end
 
-  defp infer_expr_wasm_type({:if, _, then_b, _}, te, ftm), do: infer_expr_wasm_type(then_b, te, ftm)
-  defp infer_expr_wasm_type({:case, _, [{_, _, body} | _]}, te, ftm), do: infer_expr_wasm_type(body, te, ftm)
+  defp infer_expr_wasm_type({:if, _, then_b, _}, te, ftm),
+    do: infer_expr_wasm_type(then_b, te, ftm)
+
+  defp infer_expr_wasm_type({:case, _, [{_, _, body} | _]}, te, ftm),
+    do: infer_expr_wasm_type(body, te, ftm)
+
   defp infer_expr_wasm_type({:let, _, value}, te, ftm), do: infer_expr_wasm_type(value, te, ftm)
 
   defp infer_expr_wasm_type({:block, exprs}, te, ftm) when is_list(exprs) and length(exprs) > 0 do
     infer_expr_wasm_type(List.last(exprs), te, ftm)
   end
 
-  defp infer_expr_wasm_type({:tail_loop, _, body}, te, ftm), do: infer_expr_wasm_type(body, te, ftm)
+  defp infer_expr_wasm_type({:tail_loop, _, body}, te, ftm),
+    do: infer_expr_wasm_type(body, te, ftm)
+
   defp infer_expr_wasm_type({:tail_call, name, _}, _te, ftm) do
     case Map.get(ftm, name) do
       %{return: ret} -> ret
@@ -934,6 +994,7 @@ defmodule Firebird.Compiler.WATGen do
 
   defp indent(text, spaces) do
     pad = String.duplicate(" ", spaces)
+
     text
     |> String.split("\n")
     |> Enum.map(fn line ->
diff --git a/lib/firebird/errors.ex b/lib/firebird/errors.ex
index a7dfbb0..8a1be3a 100644
--- a/lib/firebird/errors.ex
+++ b/lib/firebird/errors.ex
@@ -18,11 +18,11 @@ defmodule Firebird.WasmError do
   defexception [:message, :reason, :function, :wasm_path]
 
   @type t :: %__MODULE__{
-    message: String.t(),
-    reason: term(),
-    function: String.t() | atom() | nil,
-    wasm_path: String.t() | nil
-  }
+          message: String.t(),
+          reason: term(),
+          function: String.t() | atom() | nil,
+          wasm_path: String.t() | nil
+        }
 
   @impl true
   def message(%{message: message}), do: message
diff --git a/lib/firebird/fast_nif.ex b/lib/firebird/fast_nif.ex
index 04fc8c0..bf7312a 100644
--- a/lib/firebird/fast_nif.ex
+++ b/lib/firebird/fast_nif.ex
@@ -18,33 +18,39 @@ defmodule Firebird.FastNif do
   @on_load :load_nif
 
   def load_nif do
-    nif_path = Path.join([
-      Application.app_dir(:firebird, "priv"),
-      "native",
-      "libfirebird_nif"
-    ])
+    nif_path =
+      Path.join([
+        Application.app_dir(:firebird, "priv"),
+        "native",
+        "libfirebird_nif"
+      ])
 
     # Also check the build directory
-    build_path = Path.join([
-      File.cwd!(),
-      "native",
-      "firebird_nif",
-      "target",
-      "release",
-      "libfirebird_nif"
-    ])
-
-    path = if File.exists?(nif_path <> ".so") or File.exists?(nif_path <> ".dylib") do
-      nif_path
-    else
-      build_path
-    end
+    build_path =
+      Path.join([
+        File.cwd!(),
+        "native",
+        "firebird_nif",
+        "target",
+        "release",
+        "libfirebird_nif"
+      ])
+
+    path =
+      if File.exists?(nif_path <> ".so") or File.exists?(nif_path <> ".dylib") do
+        nif_path
+      else
+        build_path
+      end
 
     case :erlang.load_nif(String.to_charlist(path), 0) do
-      :ok -> :ok
+      :ok ->
+        :ok
+
       {:error, reason} ->
         IO.warn("Failed to load Firebird FastNif: #{inspect(reason)}")
-        :ok  # Don't crash - fall back to Wasmex
+        # Don't crash - fall back to Wasmex
+        :ok
     end
   end
 
@@ -79,10 +85,12 @@ defmodule Firebird.FastNif do
       load_wasm(<<>>)
       false
     rescue
-      ErlangError -> false  # NIF loaded but bad args
+      # NIF loaded but bad args
+      ErlangError -> false
     catch
       :error, :nif_not_loaded -> false
-      :error, _ -> true  # NIF loaded
+      # NIF loaded
+      :error, _ -> true
     end
   end
 end
diff --git a/lib/firebird/hot_reload.ex b/lib/firebird/hot_reload.ex
index 30f4b52..4df3108 100644
--- a/lib/firebird/hot_reload.ex
+++ b/lib/firebird/hot_reload.ex
@@ -37,7 +37,8 @@ defmodule Firebird.HotReload do
 
   defstruct [:path, :opts, :callback, :instance, :last_modified, :interval]
 
-  @default_interval 2_000  # 2 seconds
+  # 2 seconds
+  @default_interval 2_000
 
   @doc """
   Start a hot-reload watcher for a WASM file.
@@ -52,6 +53,7 @@ defmodule Firebird.HotReload do
   """
   def start_link(opts) do
     path = Keyword.fetch!(opts, :path)
+
     unless File.exists?(path) do
       raise ArgumentError, "WASM file not found: #{path}"
     end
@@ -117,14 +119,15 @@ defmodule Firebird.HotReload do
       {:ok, instance, mtime} ->
         schedule_check(interval)
 
-        {:ok, %__MODULE__{
-          path: path,
-          opts: load_opts,
-          callback: callback,
-          instance: instance,
-          last_modified: mtime,
-          interval: interval
-        }}
+        {:ok,
+         %__MODULE__{
+           path: path,
+           opts: load_opts,
+           callback: callback,
+           instance: instance,
+           last_modified: mtime,
+           interval: interval
+         }}
 
       {:error, reason} ->
         {:stop, reason}
@@ -154,6 +157,7 @@ defmodule Firebird.HotReload do
       instance_alive: state.instance != nil && Process.alive?(state.instance),
       interval: state.interval
     }
+
     {:reply, stats, state}
   end
 
@@ -166,6 +170,7 @@ defmodule Firebird.HotReload do
 
   def handle_info({:DOWN, _ref, :process, pid, _reason}, %{instance: pid} = state) do
     Logger.warning("[Firebird.HotReload] WASM instance crashed, reloading...")
+
     case do_reload(state) do
       {:ok, new_state} -> {:noreply, new_state}
       {:error, _} -> {:noreply, %{state | instance: nil}}
@@ -179,6 +184,7 @@ defmodule Firebird.HotReload do
     if state.instance && Process.alive?(state.instance) do
       Firebird.stop(state.instance)
     end
+
     :ok
   end
 
@@ -201,8 +207,11 @@ defmodule Firebird.HotReload do
     case File.stat(state.path) do
       {:ok, %{mtime: mtime}} when mtime != state.last_modified ->
         Logger.info("[Firebird.HotReload] #{state.path} changed, reloading...")
+
         case do_reload(state) do
-          {:ok, new_state} -> new_state
+          {:ok, new_state} ->
+            new_state
+
           {:error, reason} ->
             Logger.error("[Firebird.HotReload] Reload failed: #{inspect(reason)}")
             state
diff --git a/lib/firebird/inspector.ex b/lib/firebird/inspector.ex
index 77ef71d..f1916f8 100644
--- a/lib/firebird/inspector.ex
+++ b/lib/firebird/inspector.ex
@@ -122,8 +122,14 @@ defmodule Firebird.Inspector do
         }
 
       _ ->
-        %{functions: [], memories: [], globals: [], size_bytes: byte_size(bytes),
-          export_count: 0, function_count: 0}
+        %{
+          functions: [],
+          memories: [],
+          globals: [],
+          size_bytes: byte_size(bytes),
+          export_count: 0,
+          function_count: 0
+        }
     end
   end
 
diff --git a/lib/firebird/lazy.ex b/lib/firebird/lazy.ex
index 97ed1d8..c34ec4b 100644
--- a/lib/firebird/lazy.ex
+++ b/lib/firebird/lazy.ex
@@ -67,6 +67,7 @@ defmodule Firebird.Lazy do
   @spec child_spec([option()]) :: Supervisor.child_spec()
   def child_spec(opts) do
     name = Keyword.get(opts, :name, __MODULE__)
+
     %{
       id: name,
       start: {__MODULE__, :start_link, [opts]},
@@ -91,7 +92,8 @@ defmodule Firebird.Lazy do
   end
 
   @doc "Call a WASM function and return an unwrapped single value."
-  @spec call_one(GenServer.server(), atom() | String.t(), list()) :: {:ok, term()} | {:error, term()}
+  @spec call_one(GenServer.server(), atom() | String.t(), list()) ::
+          {:ok, term()} | {:error, term()}
   def call_one(server, function, args) do
     case call(server, function, args) do
       {:ok, [single]} -> {:ok, single}
diff --git a/lib/firebird/memory.ex b/lib/firebird/memory.ex
index fe7ce19..78ff829 100644
--- a/lib/firebird/memory.ex
+++ b/lib/firebird/memory.ex
@@ -95,15 +95,15 @@ defmodule Firebird.Memory do
   @type allocation :: {non_neg_integer(), non_neg_integer()}
 
   @type t :: %__MODULE__{
-    instance: pid(),
-    alignment: pos_integer(),
-    base_offset: non_neg_integer(),
-    cursor: non_neg_integer(),
-    known_memory_size: non_neg_integer() | nil,
-    memory_ref: term() | nil,
-    store_ref: term() | nil,
-    allocations: [allocation()]
-  }
+          instance: pid(),
+          alignment: pos_integer(),
+          base_offset: non_neg_integer(),
+          cursor: non_neg_integer(),
+          known_memory_size: non_neg_integer() | nil,
+          memory_ref: term() | nil,
+          store_ref: term() | nil,
+          allocations: [allocation()]
+        }
 
   # ── Constructor ──────────────────────────────────────────────────────────
 
@@ -139,6 +139,7 @@ defmodule Firebird.Memory do
         {:ok, %{memory: mem, store: store}} ->
           size = Wasmex.Memory.size(store, mem)
           {mem, store, size}
+
         _ ->
           {nil, nil, nil}
       end
@@ -178,10 +179,7 @@ defmodule Firebird.Memory do
     mem = ensure_capacity(mem, new_cursor)
 
     entry = {offset, byte_size}
-    mem = %{mem |
-      cursor: new_cursor,
-      allocations: [entry | mem.allocations]
-    }
+    mem = %{mem | cursor: new_cursor, allocations: [entry | mem.allocations]}
 
     {mem, offset}
   end
@@ -205,7 +203,8 @@ defmodule Firebird.Memory do
   This is a thin convenience over `Firebird.read_memory/3` that uses
   the allocator's bound instance.
   """
-  @spec read_bytes(t(), non_neg_integer(), non_neg_integer()) :: {:ok, binary()} | {:error, term()}
+  @spec read_bytes(t(), non_neg_integer(), non_neg_integer()) ::
+          {:ok, binary()} | {:error, term()}
   def read_bytes(%__MODULE__{} = mem, offset, length) do
     read_memory_direct(mem, offset, length)
   end
@@ -232,7 +231,8 @@ defmodule Firebird.Memory do
   def write_string(%__MODULE__{} = mem, string, opts \\ []) when is_binary(string) do
     null_term = Keyword.get(opts, :null_terminated, false)
     data = if null_term, do: string <> <<0>>, else: string
-    logical_len = byte_size(string)  # length without NUL terminator
+    # length without NUL terminator
+    logical_len = byte_size(string)
     {mem, offset, _raw_size} = write_bytes(mem, data)
     {mem, offset, logical_len}
   end
@@ -244,7 +244,8 @@ defmodule Firebird.Memory do
 
       {:ok, str} = Firebird.Memory.read_string(alloc, ptr, len)
   """
-  @spec read_string(t(), non_neg_integer(), non_neg_integer()) :: {:ok, String.t()} | {:error, term()}
+  @spec read_string(t(), non_neg_integer(), non_neg_integer()) ::
+          {:ok, String.t()} | {:error, term()}
   def read_string(%__MODULE__{} = mem, offset, length) do
     case read_bytes(mem, offset, length) do
       {:ok, bytes} ->
@@ -253,7 +254,9 @@ defmodule Firebird.Memory do
         else
           {:error, :invalid_utf8}
         end
-      error -> error
+
+      error ->
+        error
     end
   end
 
@@ -283,13 +286,16 @@ defmodule Firebird.Memory do
 
       {:ok, [1, 2, 3]} = Firebird.Memory.read_i32_array(alloc, ptr, 3)
   """
-  @spec read_i32_array(t(), non_neg_integer(), non_neg_integer()) :: {:ok, [integer()]} | {:error, term()}
+  @spec read_i32_array(t(), non_neg_integer(), non_neg_integer()) ::
+          {:ok, [integer()]} | {:error, term()}
   def read_i32_array(%__MODULE__{} = mem, offset, count) when is_integer(count) and count >= 0 do
     case read_bytes(mem, offset, count * 4) do
       {:ok, bytes} ->
         values = for <<v::little-signed-32 <- bytes>>, do: v
         {:ok, values}
-      error -> error
+
+      error ->
+        error
     end
   end
 
@@ -310,13 +316,16 @@ defmodule Firebird.Memory do
   @doc """
   Read a list of 32-bit unsigned integers from linear memory (little-endian).
   """
-  @spec read_u32_array(t(), non_neg_integer(), non_neg_integer()) :: {:ok, [non_neg_integer()]} | {:error, term()}
+  @spec read_u32_array(t(), non_neg_integer(), non_neg_integer()) ::
+          {:ok, [non_neg_integer()]} | {:error, term()}
   def read_u32_array(%__MODULE__{} = mem, offset, count) when is_integer(count) and count >= 0 do
     case read_bytes(mem, offset, count * 4) do
       {:ok, bytes} ->
         values = for <<v::little-unsigned-32 <- bytes>>, do: v
         {:ok, values}
-      error -> error
+
+      error ->
+        error
     end
   end
 
@@ -337,13 +346,16 @@ defmodule Firebird.Memory do
   @doc """
   Read a list of 64-bit signed integers from linear memory (little-endian).
   """
-  @spec read_i64_array(t(), non_neg_integer(), non_neg_integer()) :: {:ok, [integer()]} | {:error, term()}
+  @spec read_i64_array(t(), non_neg_integer(), non_neg_integer()) ::
+          {:ok, [integer()]} | {:error, term()}
   def read_i64_array(%__MODULE__{} = mem, offset, count) when is_integer(count) and count >= 0 do
     case read_bytes(mem, offset, count * 8) do
       {:ok, bytes} ->
         values = for <<v::little-signed-64 <- bytes>>, do: v
         {:ok, values}
-      error -> error
+
+      error ->
+        error
     end
   end
 
@@ -364,13 +376,16 @@ defmodule Firebird.Memory do
   @doc """
   Read a list of 32-bit floats from linear memory (little-endian IEEE 754).
   """
-  @spec read_f32_array(t(), non_neg_integer(), non_neg_integer()) :: {:ok, [float()]} | {:error, term()}
+  @spec read_f32_array(t(), non_neg_integer(), non_neg_integer()) ::
+          {:ok, [float()]} | {:error, term()}
   def read_f32_array(%__MODULE__{} = mem, offset, count) when is_integer(count) and count >= 0 do
     case read_bytes(mem, offset, count * 4) do
       {:ok, bytes} ->
         values = for <<v::little-float-32 <- bytes>>, do: v
         {:ok, values}
-      error -> error
+
+      error ->
+        error
     end
   end
 
@@ -399,13 +414,16 @@ defmodule Firebird.Memory do
 
       {:ok, [3.14, 2.718]} = Firebird.Memory.read_f64_array(alloc, ptr, 2)
   """
-  @spec read_f64_array(t(), non_neg_integer(), non_neg_integer()) :: {:ok, [float()]} | {:error, term()}
+  @spec read_f64_array(t(), non_neg_integer(), non_neg_integer()) ::
+          {:ok, [float()]} | {:error, term()}
   def read_f64_array(%__MODULE__{} = mem, offset, count) when is_integer(count) and count >= 0 do
     case read_bytes(mem, offset, count * 8) do
       {:ok, bytes} ->
         values = for <<v::little-float-64 <- bytes>>, do: v
         {:ok, values}
-      error -> error
+
+      error ->
+        error
     end
   end
 
@@ -499,10 +517,12 @@ defmodule Firebird.Memory do
   @spec free_all_secure(t()) :: t()
   def free_all_secure(%__MODULE__{} = mem) do
     used = mem.cursor - mem.base_offset
+
     if used > 0 do
       zeros = :binary.copy(<<0>>, used)
       write_memory_direct(mem, mem.base_offset, zeros)
     end
+
     free_all(mem)
   end
 
@@ -692,9 +712,13 @@ defmodule Firebird.Memory do
           Enum.reduce(fields, %{}, fn {name, type}, acc ->
             field_offset = Map.fetch!(offsets, name)
             field_size = type_size(type)
-            <<_::binary-size(field_offset), field_bytes::binary-size(field_size), _::binary>> = buf
+
+            <<_::binary-size(field_offset), field_bytes::binary-size(field_size), _::binary>> =
+              buf
+
             Map.put(acc, name, decode_field(type, field_bytes))
           end)
+
         {:ok, result}
 
       {:error, _} = err ->
@@ -743,7 +767,7 @@ defmodule Firebird.Memory do
       # => {:ok, [%{x: 1.0, y: 2.0}, %{x: 3.0, y: 4.0}]}
   """
   @spec read_struct_array(t(), map(), non_neg_integer(), non_neg_integer()) ::
-    {:ok, [map()]} | {:error, term()}
+          {:ok, [map()]} | {:error, term()}
   def read_struct_array(%__MODULE__{} = mem, layout, offset, count)
       when is_integer(count) and count >= 0 do
     if count == 0 do
@@ -765,7 +789,10 @@ defmodule Firebird.Memory do
               Enum.reduce(fields, %{}, fn {name, type}, acc ->
                 field_offset = Map.fetch!(offsets, name)
                 field_size = type_size(type)
-                <<_::binary-size(field_offset), field_bytes::binary-size(field_size), _::binary>> = chunk
+
+                <<_::binary-size(field_offset), field_bytes::binary-size(field_size), _::binary>> =
+                  chunk
+
                 Map.put(acc, name, decode_field(type, field_bytes))
               end)
             end
@@ -813,6 +840,7 @@ defmodule Firebird.Memory do
 
     # Pad to full struct size (for array-of-structs alignment)
     trailing = struct_size - cursor
+
     final =
       if trailing > 0,
         do: [iodata, :binary.copy(<<0>>, trailing)],
@@ -842,8 +870,8 @@ defmodule Firebird.Memory do
   defp encode_field(:u32, v), do: <<v::little-unsigned-32>>
   defp encode_field(:i64, v), do: <<v::little-signed-64>>
   defp encode_field(:u64, v), do: <<v::little-unsigned-64>>
-  defp encode_field(:f32, v), do: <<(v * 1.0)::little-float-32>>
-  defp encode_field(:f64, v), do: <<(v * 1.0)::little-float-64>>
+  defp encode_field(:f32, v), do: <<v * 1.0::little-float-32>>
+  defp encode_field(:f64, v), do: <<v * 1.0::little-float-64>>
 
   defp decode_field(:i8, <<v::little-signed-8>>), do: v
   defp decode_field(:u8, <<v::little-unsigned-8>>), do: v
diff --git a/lib/firebird/metrics.ex b/lib/firebird/metrics.ex
index 9358150..64b2ab4 100644
--- a/lib/firebird/metrics.ex
+++ b/lib/firebird/metrics.ex
@@ -108,14 +108,15 @@ defmodule Firebird.Metrics do
       |> Map.new(fn {func_name, calls, errors, total_us, min_us, max_us} ->
         avg = if calls > 0, do: Float.round(total_us / calls, 1), else: 0.0
 
-        {func_name, %{
-          calls: calls,
-          errors: errors,
-          avg_us: avg,
-          min_us: if(min_us == :infinity, do: 0, else: min_us),
-          max_us: max_us,
-          total_us: total_us
-        }}
+        {func_name,
+         %{
+           calls: calls,
+           errors: errors,
+           avg_us: avg,
+           min_us: if(min_us == :infinity, do: 0, else: min_us),
+           max_us: max_us,
+           total_us: total_us
+         }}
       end)
     else
       %{}
@@ -158,6 +159,7 @@ defmodule Firebird.Metrics do
     if :ets.whereis(@table_name) != :undefined do
       :ets.delete_all_objects(@table_name)
     end
+
     :ok
   end
 
@@ -236,13 +238,15 @@ defmodule Firebird.Metrics do
 
   @impl true
   def init(_opts) do
-    table = :ets.new(@table_name, [
-      :named_table,
-      :set,
-      :public,
-      read_concurrency: true,
-      write_concurrency: true
-    ])
+    table =
+      :ets.new(@table_name, [
+        :named_table,
+        :set,
+        :public,
+        read_concurrency: true,
+        write_concurrency: true
+      ])
+
     {:ok, %{table: table}}
   end
 
@@ -299,7 +303,7 @@ defmodule Firebird.Metrics do
     # to min, which is acceptable for metrics (eventual consistency).
     case :ets.lookup(@table_name, func_name) do
       [{^func_name, _calls, _errors, _total, current_min, _max}]
-        when elapsed_us < current_min ->
+      when elapsed_us < current_min ->
         :ets.update_element(@table_name, func_name, {@pos_min_us, elapsed_us})
 
       _ ->
@@ -311,7 +315,7 @@ defmodule Firebird.Metrics do
   defp update_max(func_name, elapsed_us) do
     case :ets.lookup(@table_name, func_name) do
       [{^func_name, _calls, _errors, _total, _min, current_max}]
-        when elapsed_us > current_max ->
+      when elapsed_us > current_max ->
         :ets.update_element(@table_name, func_name, {@pos_max_us, elapsed_us})
 
       _ ->
diff --git a/lib/firebird/module.ex b/lib/firebird/module.ex
index 4368439..b5cd63c 100644
--- a/lib/firebird/module.ex
+++ b/lib/firebird/module.ex
@@ -71,11 +71,12 @@ defmodule Firebird.Module do
     auto = Keyword.get(opts, :auto, false)
 
     # Auto-discover functions at compile time
-    auto_fns = if auto do
-      Firebird.Module.__discover_functions__(wasm_path, wasm_opts)
-    else
-      []
-    end
+    auto_fns =
+      if auto do
+        Firebird.Module.__discover_functions__(wasm_path, wasm_opts)
+      else
+        []
+      end
 
     quote do
       use GenServer
@@ -88,11 +89,13 @@ defmodule Firebird.Module do
       Module.register_attribute(__MODULE__, :wasm_functions, accumulate: true)
 
       # Auto-discovered function wrappers
-      unquote(for {name, arity} <- auto_fns do
-        quote do
-          wasm_fn unquote(name), args: unquote(arity)
+      unquote(
+        for {name, arity} <- auto_fns do
+          quote do
+            wasm_fn unquote(name), args: unquote(arity)
+          end
         end
-      end)
+      )
 
       @before_compile Firebird.Module
 
@@ -142,12 +145,14 @@ defmodule Firebird.Module do
 
           {:error, {:file_error, :enoent, path}} ->
             require Logger
+
             Logger.error("""
             [#{inspect(__MODULE__)}] WASM file not found: #{path}
 
             Make sure the file exists before starting the module.
             Common locations: priv/wasm/, wasm/
             """)
+
             {:stop, {:wasm_file_not_found, path}}
 
           {:error, reason} ->
@@ -162,6 +167,7 @@ defmodule Firebird.Module do
         for {_elixir_name, wasm_name, _arity} <- declared do
           unless wasm_name in exports do
             require Logger
+
             Logger.warning("""
             [#{inspect(__MODULE__)}] Declared function '#{wasm_name}' not found in WASM module.
             Available exports: #{Enum.join(exports, ", ")}
diff --git a/lib/firebird/module_cache.ex b/lib/firebird/module_cache.ex
index 4781c28..13aebfe 100644
--- a/lib/firebird/module_cache.ex
+++ b/lib/firebird/module_cache.ex
@@ -67,12 +67,14 @@ defmodule Firebird.ModuleCache do
             bump_counter(@misses_counter)
 
             # Auto-detect WASI if not explicitly set (matches WasmRunner behavior)
-            wasi = case Keyword.get(opts, :wasi) do
-              nil ->
-                Firebird.WasmRunner.detect_wasi(wasm_bytes)
-              other ->
-                other
-            end
+            wasi =
+              case Keyword.get(opts, :wasi) do
+                nil ->
+                  Firebird.WasmRunner.detect_wasi(wasm_bytes)
+
+                other ->
+                  other
+              end
 
             compile_opts = if wasi, do: [wasi: wasi], else: []
 
@@ -109,24 +111,32 @@ defmodule Firebird.ModuleCache do
     if :ets.whereis(@table_name) != :undefined do
       :ets.delete_all_objects(@table_name)
     end
+
     if :ets.whereis(@hits_counter) != :undefined do
       :ets.insert(@hits_counter, {:count, 0})
     end
+
     if :ets.whereis(@misses_counter) != :undefined do
       :ets.insert(@misses_counter, {:count, 0})
     end
+
     :ok
   end
 
   @doc """
   Get cache statistics including hit/miss counts.
   """
-  @spec stats() :: %{entries: non_neg_integer(), memory_bytes: non_neg_integer(),
-                      hits: non_neg_integer(), misses: non_neg_integer()}
+  @spec stats() :: %{
+          entries: non_neg_integer(),
+          memory_bytes: non_neg_integer(),
+          hits: non_neg_integer(),
+          misses: non_neg_integer()
+        }
   def stats do
     base =
       if :ets.whereis(@table_name) != :undefined do
         info = :ets.info(@table_name)
+
         %{
           entries: Keyword.get(info, :size, 0),
           memory_bytes: Keyword.get(info, :memory, 0)
@@ -181,6 +191,7 @@ defmodule Firebird.ModuleCache do
               # Upgrade the cache entry
               :ets.insert(@table_name, {hash, precompiled})
               {:ok, precompiled}
+
             {:error, _} ->
               # Still can't compile; treat as miss so caller falls back
               :miss
diff --git a/lib/firebird/phoenix.ex b/lib/firebird/phoenix.ex
index ec5456e..f21a4bc 100644
--- a/lib/firebird/phoenix.ex
+++ b/lib/firebird/phoenix.ex
@@ -147,6 +147,7 @@ defmodule Firebird.Phoenix do
     for {_key, pid} <- components, is_pid(pid) and Process.alive?(pid) do
       Firebird.stop(pid)
     end
+
     :ok
   end
 
@@ -200,7 +201,8 @@ defmodule Firebird.Phoenix do
     cond do
       endpoint && plugs != [] ->
         # Pipeline execution + dispatch
-        with {:ok, conn} <- Firebird.Phoenix.Endpoint.execute_pipeline(endpoint, raw_request, plugs) do
+        with {:ok, conn} <-
+               Firebird.Phoenix.Endpoint.execute_pipeline(endpoint, raw_request, plugs) do
           if conn.halted do
             {:ok, %{status: conn.status, headers: conn.resp_headers, body: ""}}
           else
@@ -226,15 +228,20 @@ defmodule Firebird.Phoenix do
             {:ok, %{handler: handler, params: params}} ->
               case Map.get(actions, handler) do
                 {status, content_type, template_body} ->
-                  rendered = Enum.reduce(params, template_body, fn {k, v}, acc ->
-                    String.replace(acc, "{{#{k}}}", v)
-                  end)
+                  rendered =
+                    Enum.reduce(params, template_body, fn {k, v}, acc ->
+                      String.replace(acc, "{{#{k}}}", v)
+                    end)
+
                   {:ok, %{status: status, content_type: content_type, body: rendered}}
+
                 nil ->
                   {:error, :no_action_for_handler}
               end
+
             {:ok, :not_found} ->
               {:ok, %{status: 404, content_type: "text/plain", body: "Not Found"}}
+
             {:error, reason} ->
               {:error, reason}
           end
@@ -258,6 +265,7 @@ defmodule Firebird.Phoenix do
       case Map.get(components, key) do
         pid when is_pid(pid) ->
           {key, if(Process.alive?(pid), do: :running, else: :stopped)}
+
         nil ->
           {key, :not_loaded}
       end
@@ -284,12 +292,14 @@ defmodule Firebird.Phoenix do
       [header_section, body] ->
         [status_line | header_lines] = String.split(header_section, "\r\n")
 
-        status = case Regex.run(~r/HTTP\/\d\.\d (\d+)/, status_line) do
-          [_, code] -> String.to_integer(code)
-          _ -> 200
-        end
+        status =
+          case Regex.run(~r/HTTP\/\d\.\d (\d+)/, status_line) do
+            [_, code] -> String.to_integer(code)
+            _ -> 200
+          end
 
-        headers = header_lines
+        headers =
+          header_lines
           |> Enum.into(%{}, fn line ->
             case String.split(line, ": ", parts: 2) do
               [k, v] -> {String.downcase(k), v}
@@ -306,10 +316,11 @@ defmodule Firebird.Phoenix do
   end
 
   defp resolve_fixtures_dir do
-    priv_dir = case :code.priv_dir(:firebird) do
-      {:error, _} -> nil
-      dir -> to_string(dir)
-    end
+    priv_dir =
+      case :code.priv_dir(:firebird) do
+        {:error, _} -> nil
+        dir -> to_string(dir)
+      end
 
     priv_wasm = if priv_dir, do: Path.join(priv_dir, "wasm"), else: nil
     project_fixtures = Path.join([__DIR__, "..", "..", "fixtures"]) |> Path.expand()
@@ -318,18 +329,22 @@ defmodule Firebird.Phoenix do
       # priv/wasm with Phoenix files (installed as dependency)
       priv_wasm && File.exists?(Path.join(priv_wasm, "phoenix_router.wasm")) ->
         priv_wasm
+
       # Development: source tree fixtures/
-      File.dir?(project_fixtures) && File.exists?(Path.join(project_fixtures, "phoenix_router.wasm")) ->
+      File.dir?(project_fixtures) &&
+          File.exists?(Path.join(project_fixtures, "phoenix_router.wasm")) ->
         project_fixtures
+
       # Fallback: current directory fixtures/
       File.dir?("fixtures") ->
         Path.expand("fixtures")
+
       # Last resort
       priv_wasm && File.dir?(priv_wasm) ->
         priv_wasm
+
       true ->
         project_fixtures
     end
   end
 end
-
diff --git a/lib/firebird/phoenix/app.ex b/lib/firebird/phoenix/app.ex
index 4e8fca8..664952e 100644
--- a/lib/firebird/phoenix/app.ex
+++ b/lib/firebird/phoenix/app.ex
@@ -59,10 +59,17 @@ defmodule Firebird.Phoenix.App do
 
   defmacro __using__(_opts) do
     quote do
-      import Firebird.Phoenix.App, only: [
-        routes: 1, action: 4, config: 2,
-        get: 2, post: 2, put: 2, patch: 2, delete: 2
-      ]
+      import Firebird.Phoenix.App,
+        only: [
+          routes: 1,
+          action: 4,
+          config: 2,
+          get: 2,
+          post: 2,
+          put: 2,
+          patch: 2,
+          delete: 2
+        ]
 
       Module.register_attribute(__MODULE__, :firebird_app_routes, accumulate: true)
       Module.register_attribute(__MODULE__, :firebird_app_actions, accumulate: true)
@@ -179,7 +186,8 @@ defmodule Firebird.Phoenix.App do
   @doc false
   defmacro action(handler, status, content_type, body) do
     quote do
-      @firebird_app_actions {unquote(handler), {unquote(status), unquote(content_type), unquote(body)}}
+      @firebird_app_actions {unquote(handler),
+                             {unquote(status), unquote(content_type), unquote(body)}}
     end
   end
 
diff --git a/lib/firebird/phoenix/application.ex b/lib/firebird/phoenix/application.ex
index 0b6ad0b..5cac09a 100644
--- a/lib/firebird/phoenix/application.ex
+++ b/lib/firebird/phoenix/application.ex
@@ -48,6 +48,7 @@ defmodule Firebird.Phoenix.Application do
   """
   def child_spec(opts) do
     name = Keyword.fetch!(opts, :name)
+
     %{
       id: {__MODULE__, name},
       start: {__MODULE__, :start_link, [opts]},
@@ -104,6 +105,7 @@ defmodule Firebird.Phoenix.Application do
     case Firebird.Phoenix.start(only: component_keys) do
       {:ok, components} ->
         {:ok, %{components: components, opts: opts}}
+
       {:error, reason} ->
         {:stop, reason}
     end
diff --git a/lib/firebird/phoenix/auth.ex b/lib/firebird/phoenix/auth.ex
index 05b2258..e520cfb 100644
--- a/lib/firebird/phoenix/auth.ex
+++ b/lib/firebird/phoenix/auth.ex
@@ -80,11 +80,13 @@ defmodule Firebird.Phoenix.Auth do
       end)
   """
   @spec api_key(String.t(), (String.t() -> :ok | :unauthorized)) :: Middleware.middleware_fn()
-  def api_key(header_name, validate_fn) when is_binary(header_name) and is_function(validate_fn, 1) do
+  def api_key(header_name, validate_fn)
+      when is_binary(header_name) and is_function(validate_fn, 1) do
     fn conn ->
       case Conn.get_req_header(conn, header_name) do
         nil ->
           {:halt, Conn.send_resp(conn, 401, unauthorized_json())}
+
         key ->
           case validate_fn.(key) do
             :ok -> conn
@@ -118,9 +120,11 @@ defmodule Firebird.Phoenix.Auth do
                     :ok -> Conn.assign(conn, :current_user, username)
                     :unauthorized -> {:halt, Conn.send_resp(conn, 401, unauthorized_json())}
                   end
+
                 _ ->
                   {:halt, Conn.send_resp(conn, 401, unauthorized_json())}
               end
+
             :error ->
               {:halt, Conn.send_resp(conn, 401, unauthorized_json())}
           end
@@ -142,11 +146,13 @@ defmodule Firebird.Phoenix.Auth do
       Auth.require_role(:admin, fn user -> user.role end)
   """
   @spec require_role(atom(), (term() -> atom())) :: Middleware.middleware_fn()
-  def require_role(required_role, role_fn) when is_atom(required_role) and is_function(role_fn, 1) do
+  def require_role(required_role, role_fn)
+      when is_atom(required_role) and is_function(role_fn, 1) do
     fn conn ->
       case conn.assigns[:current_user] do
         nil ->
           {:halt, Conn.send_resp(conn, 401, unauthorized_json())}
+
         user ->
           if role_fn.(user) == required_role do
             conn
@@ -177,8 +183,8 @@ defmodule Firebird.Phoenix.Auth do
       case :ets.lookup(table, key) do
         [{^key, count, window_start}] when now - window_start < window_ms ->
           if count >= max_requests do
-            {:halt, Conn.send_resp(conn, 429,
-              ~s({"error":{"status":429,"message":"Too Many Requests"}}))}
+            {:halt,
+             Conn.send_resp(conn, 429, ~s({"error":{"status":429,"message":"Too Many Requests"}}))}
           else
             :ets.insert(table, {key, count + 1, window_start})
             conn
@@ -197,11 +203,14 @@ defmodule Firebird.Phoenix.Auth do
     case :ets.whereis(table) do
       :undefined ->
         :ets.new(table, [:named_table, :public, :set])
+
       _ ->
         table
     end
   rescue
-    ArgumentError -> table = :firebird_rate_limits; table
+    ArgumentError ->
+      table = :firebird_rate_limits
+      table
   end
 
   defp unauthorized_json do
diff --git a/lib/firebird/phoenix/benchmark.ex b/lib/firebird/phoenix/benchmark.ex
index 7f6ac6e..380d924 100644
--- a/lib/firebird/phoenix/benchmark.ex
+++ b/lib/firebird/phoenix/benchmark.ex
@@ -72,39 +72,48 @@ defmodule Firebird.Phoenix.Benchmark do
       {"GET", "/posts/:post_id/comments/:id", "CommentController.show"},
       {"GET", "/api/v1/products", "ProductController.index"},
       {"GET", "/api/v1/products/:id", "ProductController.show"},
-      {"GET", "/admin/dashboard", "AdminController.dashboard"},
+      {"GET", "/admin/dashboard", "AdminController.dashboard"}
     ]
 
     # Benchmark: non-compiled match
-    non_compiled = benchmark_fn(iterations, fn ->
-      Router.match(router, "GET", "/users/42", routes)
-    end)
+    non_compiled =
+      benchmark_fn(iterations, fn ->
+        Router.match(router, "GET", "/users/42", routes)
+      end)
+
     print_result("Non-compiled match", non_compiled)
 
     # Compile routes
     Router.compile(router, routes)
 
     # Benchmark: compiled match
-    compiled = benchmark_fn(iterations, fn ->
-      Router.match_compiled(router, "GET", "/users/42")
-    end)
+    compiled =
+      benchmark_fn(iterations, fn ->
+        Router.match_compiled(router, "GET", "/users/42")
+      end)
+
     print_result("Compiled match", compiled)
 
     # Benchmark: nested params
-    nested = benchmark_fn(iterations, fn ->
-      Router.match_compiled(router, "GET", "/posts/7/comments/3")
-    end)
+    nested =
+      benchmark_fn(iterations, fn ->
+        Router.match_compiled(router, "GET", "/posts/7/comments/3")
+      end)
+
     print_result("Nested params match", nested)
 
     # Benchmark: pure Elixir baseline
-    elixir_routes = Enum.map(routes, fn {m, p, h} ->
-      segments = String.split(p, "/", trim: true)
-      {m, segments, h}
-    end)
+    elixir_routes =
+      Enum.map(routes, fn {m, p, h} ->
+        segments = String.split(p, "/", trim: true)
+        {m, segments, h}
+      end)
+
+    elixir_baseline =
+      benchmark_fn(iterations, fn ->
+        elixir_match("GET", "/users/42", elixir_routes)
+      end)
 
-    elixir_baseline = benchmark_fn(iterations, fn ->
-      elixir_match("GET", "/users/42", elixir_routes)
-    end)
     print_result("Pure Elixir match", elixir_baseline)
 
     speedup = if compiled.avg_us > 0, do: elixir_baseline.avg_us / compiled.avg_us, else: 0
@@ -112,9 +121,12 @@ defmodule Firebird.Phoenix.Benchmark do
 
     # Batch matching
     batch_input = Enum.map(1..100, fn i -> {"GET", "/users/#{i}"} end)
-    batch = benchmark_fn(div(iterations, 10), fn ->
-      Router.match_batch(router, batch_input)
-    end)
+
+    batch =
+      benchmark_fn(div(iterations, 10), fn ->
+        Router.match_batch(router, batch_input)
+      end)
+
     print_result("Batch match (100 reqs)", batch)
 
     Firebird.stop(router)
@@ -137,9 +149,11 @@ defmodule Firebird.Phoenix.Benchmark do
     {:ok, template} = Firebird.load(Path.join(@fixtures_dir, "phoenix_template.wasm"))
 
     # Simple template
-    simple = benchmark_fn(iterations, fn ->
-      Template.render(template, "<h1>Hello {{name}}</h1>", %{"name" => "World"})
-    end)
+    simple =
+      benchmark_fn(iterations, fn ->
+        Template.render(template, "<h1>Hello {{name}}</h1>", %{"name" => "World"})
+      end)
+
     print_result("Simple 1-var render", simple)
 
     # Complex template
@@ -154,6 +168,7 @@ defmodule Firebird.Phoenix.Benchmark do
     </body>
     </html>
     """
+
     complex_vars = %{
       "title" => "My Page",
       "heading" => "Welcome",
@@ -163,25 +178,36 @@ defmodule Firebird.Phoenix.Benchmark do
       "footer" => "Copyright 2025"
     }
 
-    complex = benchmark_fn(iterations, fn ->
-      Template.render(template, complex_tmpl, complex_vars)
-    end)
+    complex =
+      benchmark_fn(iterations, fn ->
+        Template.render(template, complex_tmpl, complex_vars)
+      end)
+
     print_result("Complex 6-var render", complex)
 
     # Pure Elixir baseline
-    elixir_simple = benchmark_fn(iterations, fn ->
-      elixir_template_render("<h1>Hello {{name}}</h1>", %{"name" => "World"})
-    end)
+    elixir_simple =
+      benchmark_fn(iterations, fn ->
+        elixir_template_render("<h1>Hello {{name}}</h1>", %{"name" => "World"})
+      end)
+
     print_result("Pure Elixir 1-var", elixir_simple)
 
-    elixir_complex = benchmark_fn(iterations, fn ->
-      elixir_template_render(complex_tmpl, complex_vars)
-    end)
+    elixir_complex =
+      benchmark_fn(iterations, fn ->
+        elixir_template_render(complex_tmpl, complex_vars)
+      end)
+
     print_result("Pure Elixir 6-var", elixir_complex)
 
     Firebird.stop(template)
 
-    %{simple: simple, complex: complex, elixir_simple: elixir_simple, elixir_complex: elixir_complex}
+    %{
+      simple: simple,
+      complex: complex,
+      elixir_simple: elixir_simple,
+      elixir_complex: elixir_complex
+    }
   end
 
   def run(:plug, opts) do
@@ -191,16 +217,21 @@ defmodule Firebird.Phoenix.Benchmark do
 
     {:ok, plug} = Firebird.load(Path.join(@fixtures_dir, "phoenix_plug.wasm"))
 
-    raw_request = "GET /api/users HTTP/1.1\r\nHost: example.com\r\nAccept: application/json\r\nContent-Type: text/html\r\n\r\n"
+    raw_request =
+      "GET /api/users HTTP/1.1\r\nHost: example.com\r\nAccept: application/json\r\nContent-Type: text/html\r\n\r\n"
+
+    parse =
+      benchmark_fn(iterations, fn ->
+        Plug.parse_request(plug, raw_request)
+      end)
 
-    parse = benchmark_fn(iterations, fn ->
-      Plug.parse_request(plug, raw_request)
-    end)
     print_result("Parse HTTP request", parse)
 
-    build = benchmark_fn(iterations, fn ->
-      Plug.build_response(plug, 200, "application/json", ~s({"status":"ok"}))
-    end)
+    build =
+      benchmark_fn(iterations, fn ->
+        Plug.build_response(plug, 200, "application/json", ~s({"status":"ok"}))
+      end)
+
     print_result("Build HTTP response", build)
 
     Firebird.stop(plug)
@@ -217,24 +248,28 @@ defmodule Firebird.Phoenix.Benchmark do
 
     routes = [
       {"GET", "/users/:id", "UserController.show"},
-      {"GET", "/users", "UserController.index"},
+      {"GET", "/users", "UserController.index"}
     ]
 
     actions = %{
       "UserController.show" => {200, "application/json", ~s({"id":"{{id}}"})},
-      "UserController.index" => {200, "application/json", ~s([])},
+      "UserController.index" => {200, "application/json", ~s([])}
     }
 
     raw_request = "GET /users/42 HTTP/1.1\r\nHost: example.com\r\n\r\n"
 
-    dispatch = benchmark_fn(iterations, fn ->
-      Endpoint.dispatch(endpoint, raw_request, routes, actions)
-    end)
+    dispatch =
+      benchmark_fn(iterations, fn ->
+        Endpoint.dispatch(endpoint, raw_request, routes, actions)
+      end)
+
     print_result("Full dispatch", dispatch)
 
-    parse_conn = benchmark_fn(iterations, fn ->
-      Endpoint.parse_conn(endpoint, raw_request)
-    end)
+    parse_conn =
+      benchmark_fn(iterations, fn ->
+        Endpoint.parse_conn(endpoint, raw_request)
+      end)
+
     print_result("Parse conn", parse_conn)
 
     Firebird.stop(endpoint)
@@ -249,15 +284,19 @@ defmodule Firebird.Phoenix.Benchmark do
 
     {:ok, json} = Firebird.load(Path.join(@fixtures_dir, "phoenix_json.wasm"))
 
-    encode = benchmark_fn(iterations, fn ->
-      JSON.encode_object(json, %{"id" => 1, "name" => "Alice", "email" => "alice@example.com"})
-    end)
+    encode =
+      benchmark_fn(iterations, fn ->
+        JSON.encode_object(json, %{"id" => 1, "name" => "Alice", "email" => "alice@example.com"})
+      end)
+
     print_result("JSON encode (3 fields)", encode)
 
     # Pure Elixir (Jason) baseline
-    elixir_json = benchmark_fn(iterations, fn ->
-      Jason.encode!(%{"id" => 1, "name" => "Alice", "email" => "alice@example.com"})
-    end)
+    elixir_json =
+      benchmark_fn(iterations, fn ->
+        Jason.encode!(%{"id" => 1, "name" => "Alice", "email" => "alice@example.com"})
+      end)
+
     print_result("Jason encode (3 fields)", elixir_json)
 
     Firebird.stop(json)
@@ -272,9 +311,11 @@ defmodule Firebird.Phoenix.Benchmark do
 
     {:ok, session} = Firebird.load(Path.join(@fixtures_dir, "phoenix_session.wasm"))
 
-    parse = benchmark_fn(iterations, fn ->
-      Session.parse_cookies(session, "session_id=abc123; theme=dark; lang=en")
-    end)
+    parse =
+      benchmark_fn(iterations, fn ->
+        Session.parse_cookies(session, "session_id=abc123; theme=dark; lang=en")
+      end)
+
     print_result("Parse cookies", parse)
 
     Firebird.stop(session)
@@ -289,9 +330,11 @@ defmodule Firebird.Phoenix.Benchmark do
 
     {:ok, channel} = Firebird.load(Path.join(@fixtures_dir, "phoenix_channel.wasm"))
 
-    match = benchmark_fn(iterations, fn ->
-      Channel.match_topic(channel, "room:lobby", "room:*")
-    end)
+    match =
+      benchmark_fn(iterations, fn ->
+        Channel.match_topic(channel, "room:lobby", "room:*")
+      end)
+
     print_result("Topic match", match)
 
     Firebird.stop(channel)
@@ -304,26 +347,29 @@ defmodule Firebird.Phoenix.Benchmark do
 
     IO.puts("\n═══ Server Throughput Benchmark ═══")
 
-    {:ok, server} = Firebird.Phoenix.Server.start_link(
-      port: 0,
-      routes: [
-        {"GET", "/", "PageController.index"},
-        {"GET", "/users/:id", "UserController.show"},
-        {"GET", "/health", "HealthController.check"},
-      ],
-      actions: %{
-        "PageController.index" => {200, "text/html", "<h1>Hello!</h1>"},
-        "UserController.show" => {200, "application/json", ~s({"id":"{{id}}"})},
-        "HealthController.check" => {200, "application/json", ~s({"ok":true})},
-      }
-    )
+    {:ok, server} =
+      Firebird.Phoenix.Server.start_link(
+        port: 0,
+        routes: [
+          {"GET", "/", "PageController.index"},
+          {"GET", "/users/:id", "UserController.show"},
+          {"GET", "/health", "HealthController.check"}
+        ],
+        actions: %{
+          "PageController.index" => {200, "text/html", "<h1>Hello!</h1>"},
+          "UserController.show" => {200, "application/json", ~s({"id":"{{id}}"})},
+          "HealthController.check" => {200, "application/json", ~s({"ok":true})}
+        }
+      )
 
     port = Firebird.Phoenix.Server.port(server)
 
     # Sequential throughput
-    sequential = benchmark_fn(iterations, fn ->
-      {:ok, _} = http_get("127.0.0.1", port, "/users/42")
-    end)
+    sequential =
+      benchmark_fn(iterations, fn ->
+        {:ok, _} = http_get("127.0.0.1", port, "/users/42")
+      end)
+
     print_result("Sequential request", sequential)
 
     # Concurrent throughput
@@ -331,13 +377,16 @@ defmodule Firebird.Phoenix.Benchmark do
     concurrent_iterations = div(iterations, concurrency)
 
     start_time = System.monotonic_time(:microsecond)
-    tasks = for _ <- 1..concurrency do
-      Task.async(fn ->
-        for _ <- 1..concurrent_iterations do
-          http_get("127.0.0.1", port, "/users/42")
-        end
-      end)
-    end
+
+    tasks =
+      for _ <- 1..concurrency do
+        Task.async(fn ->
+          for _ <- 1..concurrent_iterations do
+            http_get("127.0.0.1", port, "/users/42")
+          end
+        end)
+      end
+
     Task.await_many(tasks, 30_000)
     end_time = System.monotonic_time(:microsecond)
 
@@ -345,7 +394,9 @@ defmodule Firebird.Phoenix.Benchmark do
     total_us = end_time - start_time
     rps = if total_us > 0, do: total_requests * 1_000_000 / total_us, else: 0
 
-    IO.puts("  Concurrent (#{concurrency} workers): #{Float.round(rps, 0)} req/s (#{total_requests} reqs in #{div(total_us, 1000)}ms)")
+    IO.puts(
+      "  Concurrent (#{concurrency} workers): #{Float.round(rps, 0)} req/s (#{total_requests} reqs in #{div(total_us, 1000)}ms)"
+    )
 
     Firebird.Phoenix.Server.stop(server)
 
@@ -364,11 +415,12 @@ defmodule Firebird.Phoenix.Benchmark do
     for _ <- 1..min(iterations, 100), do: fun.()
 
     # Collect timings
-    timings = for _ <- 1..iterations do
-      start = System.monotonic_time(:microsecond)
-      fun.()
-      System.monotonic_time(:microsecond) - start
-    end
+    timings =
+      for _ <- 1..iterations do
+        start = System.monotonic_time(:microsecond)
+        fun.()
+        System.monotonic_time(:microsecond) - start
+      end
 
     sorted = Enum.sort(timings)
     total = Enum.sum(timings)
@@ -394,7 +446,11 @@ defmodule Firebird.Phoenix.Benchmark do
 
   defp print_result(label, result) do
     IO.puts("  #{label}:")
-    IO.puts("    avg=#{Float.round(result.avg_us, 1)}µs  p50=#{result.p50_us}µs  p95=#{result.p95_us}µs  p99=#{result.p99_us}µs")
+
+    IO.puts(
+      "    avg=#{Float.round(result.avg_us, 1)}µs  p50=#{result.p50_us}µs  p95=#{result.p95_us}µs  p99=#{result.p99_us}µs"
+    )
+
     IO.puts("    ops/sec=#{Float.round(result.ops_per_sec, 0)}")
   end
 
@@ -416,12 +472,15 @@ defmodule Firebird.Phoenix.Benchmark do
   defp match_segments([], [], params), do: {:ok, params}
   defp match_segments(_, [], _), do: :no_match
   defp match_segments([], _, _), do: :no_match
+
   defp match_segments([":" <> name | rest_r], [value | rest_p], params) do
     match_segments(rest_r, rest_p, Map.put(params, name, value))
   end
+
   defp match_segments([seg | rest_r], [seg | rest_p], params) do
     match_segments(rest_r, rest_p, params)
   end
+
   defp match_segments(_, _, _), do: :no_match
 
   defp elixir_template_render(template, vars) do
@@ -437,16 +496,19 @@ defmodule Firebird.Phoenix.Benchmark do
     |> String.replace(">", "&gt;")
     |> String.replace("\"", "&quot;")
   end
+
   defp html_escape(other), do: to_string(other)
 
   defp http_get(host, port, path) do
     request = "GET #{path} HTTP/1.1\r\nHost: #{host}\r\n\r\n"
+
     case :gen_tcp.connect(to_charlist(host), port, [:binary, active: false], 5000) do
       {:ok, socket} ->
         :gen_tcp.send(socket, request)
         result = recv_all(socket, <<>>)
         :gen_tcp.close(socket)
         result
+
       {:error, reason} ->
         {:error, reason}
     end
diff --git a/lib/firebird/phoenix/config.ex b/lib/firebird/phoenix/config.ex
index 7f270ab..f9cbd49 100644
--- a/lib/firebird/phoenix/config.ex
+++ b/lib/firebird/phoenix/config.ex
@@ -26,11 +26,11 @@ defmodule Firebird.Phoenix.Config do
   """
 
   @type t :: %__MODULE__{
-    settings: map(),
-    pipelines: %{atom() => [String.t()]},
-    routes: [{String.t(), String.t(), String.t()}],
-    components: [atom()]
-  }
+          settings: map(),
+          pipelines: %{atom() => [String.t()]},
+          routes: [{String.t(), String.t(), String.t()}],
+          components: [atom()]
+        }
 
   defstruct settings: %{}, pipelines: %{}, routes: [], components: []
 
@@ -49,6 +49,7 @@ defmodule Firebird.Phoenix.Config do
   @spec new(keyword()) :: t()
   def new(opts \\ []) do
     settings = Map.merge(@defaults, Map.new(opts))
+
     %__MODULE__{
       settings: settings,
       components: settings[:components] || []
@@ -104,17 +105,19 @@ defmodule Firebird.Phoenix.Config do
   def validate(%__MODULE__{} = config) do
     errors = []
 
-    errors = if get(config, :secret_key_base) == nil do
-      ["secret_key_base is required" | errors]
-    else
-      errors
-    end
-
-    errors = if config.routes == [] do
-      ["no routes defined" | errors]
-    else
-      errors
-    end
+    errors =
+      if get(config, :secret_key_base) == nil do
+        ["secret_key_base is required" | errors]
+      else
+        errors
+      end
+
+    errors =
+      if config.routes == [] do
+        ["no routes defined" | errors]
+      else
+        errors
+      end
 
     if errors == [] do
       :ok
diff --git a/lib/firebird/phoenix/conn.ex b/lib/firebird/phoenix/conn.ex
index 9922b27..69b57ab 100644
--- a/lib/firebird/phoenix/conn.ex
+++ b/lib/firebird/phoenix/conn.ex
@@ -28,38 +28,36 @@ defmodule Firebird.Phoenix.Conn do
   """
 
   @type t :: %__MODULE__{
-    method: String.t(),
-    path: String.t(),
-    query_string: String.t(),
-    req_headers: %{String.t() => String.t()},
-    resp_headers: %{String.t() => String.t()},
-    body: String.t(),
-    status: non_neg_integer() | nil,
-    resp_body: String.t() | nil,
-    assigns: map(),
-    params: map(),
-    halted: boolean(),
-    state: :unset | :set | :sent,
-    cookies: map(),
-    private: map()
-  }
-
-  defstruct [
-    method: "GET",
-    path: "/",
-    query_string: "",
-    req_headers: %{},
-    resp_headers: %{},
-    body: "",
-    status: nil,
-    resp_body: nil,
-    assigns: %{},
-    params: %{},
-    halted: false,
-    state: :unset,
-    cookies: %{},
-    private: %{}
-  ]
+          method: String.t(),
+          path: String.t(),
+          query_string: String.t(),
+          req_headers: %{String.t() => String.t()},
+          resp_headers: %{String.t() => String.t()},
+          body: String.t(),
+          status: non_neg_integer() | nil,
+          resp_body: String.t() | nil,
+          assigns: map(),
+          params: map(),
+          halted: boolean(),
+          state: :unset | :set | :sent,
+          cookies: map(),
+          private: map()
+        }
+
+  defstruct method: "GET",
+            path: "/",
+            query_string: "",
+            req_headers: %{},
+            resp_headers: %{},
+            body: "",
+            status: nil,
+            resp_body: nil,
+            assigns: %{},
+            params: %{},
+            halted: false,
+            state: :unset,
+            cookies: %{},
+            private: %{}
 
   @doc """
   Create a new connection.
@@ -71,10 +69,11 @@ defmodule Firebird.Phoenix.Conn do
   """
   @spec new(String.t(), String.t(), keyword()) :: t()
   def new(method, path, opts \\ []) do
-    {path_part, query} = case String.split(path, "?", parts: 2) do
-      [p, q] -> {p, q}
-      [p] -> {p, ""}
-    end
+    {path_part, query} =
+      case String.split(path, "?", parts: 2) do
+        [p, q] -> {p, q}
+        [p] -> {p, ""}
+      end
 
     %__MODULE__{
       method: String.upcase(method),
@@ -103,25 +102,32 @@ defmodule Firebird.Phoenix.Conn do
   """
   @spec to_raw_request(t()) :: String.t()
   def to_raw_request(%__MODULE__{} = conn) do
-    path_with_query = case conn.query_string do
-      "" -> conn.path
-      qs -> [conn.path, ??, qs]
-    end
+    path_with_query =
+      case conn.query_string do
+        "" -> conn.path
+        qs -> [conn.path, ??, qs]
+      end
 
     # Auto-add Content-Length for non-empty bodies when not already present
-    headers = if conn.body != "" and not Map.has_key?(conn.req_headers, "content-length") do
-      Map.put(conn.req_headers, "content-length", Integer.to_string(byte_size(conn.body)))
-    else
-      conn.req_headers
-    end
+    headers =
+      if conn.body != "" and not Map.has_key?(conn.req_headers, "content-length") do
+        Map.put(conn.req_headers, "content-length", Integer.to_string(byte_size(conn.body)))
+      else
+        conn.req_headers
+      end
 
-    header_iodata = headers
+    header_iodata =
+      headers
       |> Enum.map(fn {k, v} -> [k, ": ", v] end)
       |> Enum.intersperse("\r\n")
 
     IO.iodata_to_binary([
-      conn.method, " ", path_with_query, " HTTP/1.1\r\n",
-      header_iodata, "\r\n\r\n",
+      conn.method,
+      " ",
+      path_with_query,
+      " HTTP/1.1\r\n",
+      header_iodata,
+      "\r\n\r\n",
       conn.body
     ])
   end
@@ -212,6 +218,7 @@ defmodule Firebird.Phoenix.Conn do
   @spec json(t(), non_neg_integer(), term()) :: t()
   def json(%__MODULE__{} = conn, status, data) do
     body = Jason.encode!(data)
+
     conn
     |> put_resp_header("content-type", "application/json; charset=utf-8")
     |> send_resp(status, body)
@@ -266,6 +273,7 @@ defmodule Firebird.Phoenix.Conn do
   @spec redirect(t(), String.t(), keyword()) :: t()
   def redirect(%__MODULE__{} = conn, url, opts \\ []) when is_binary(url) do
     status = Keyword.get(opts, :status, 302)
+
     conn
     |> put_resp_header("location", url)
     |> send_resp(status, "")
@@ -319,15 +327,17 @@ defmodule Firebird.Phoenix.Conn do
   def fetch_query_params(%__MODULE__{} = conn, opts) do
     merge? = Keyword.get(opts, :merge, true)
 
-    query_params = case Keyword.get(opts, :wasm_instance) do
-      nil ->
-        parse_query_string_elixir(conn.query_string)
-      instance ->
-        case Firebird.Phoenix.Router.parse_query(instance, conn.query_string) do
-          {:ok, params} -> params
-          {:error, _} -> parse_query_string_elixir(conn.query_string)
-        end
-    end
+    query_params =
+      case Keyword.get(opts, :wasm_instance) do
+        nil ->
+          parse_query_string_elixir(conn.query_string)
+
+        instance ->
+          case Firebird.Phoenix.Router.parse_query(instance, conn.query_string) do
+            {:ok, params} -> params
+            {:error, _} -> parse_query_string_elixir(conn.query_string)
+          end
+      end
 
     if merge? do
       %{conn | params: Map.merge(conn.params, query_params)}
@@ -346,6 +356,7 @@ defmodule Firebird.Phoenix.Conn do
           key = binary_part(pair, 0, pos)
           value = binary_part(pair, pos + 1, byte_size(pair) - pos - 1)
           Map.put(acc, URI.decode_www_form(key), URI.decode_www_form(value))
+
         :nomatch ->
           if pair != "", do: Map.put(acc, URI.decode_www_form(pair), ""), else: acc
       end
@@ -435,43 +446,56 @@ defmodule Firebird.Phoenix.Conn do
     # Uses a single IO.iodata_to_binary call at the end — zero
     # intermediate string allocations regardless of field count.
     iodata = [
-      "method=", conn.method,
-      "\npath=", conn.path,
-      "\nquery=", conn.query_string,
-      "\nbody=", conn.body,
-      "\nhalted=", if(conn.halted, do: "true", else: "false"),
-      "\nstate=", Atom.to_string(conn.state)
+      "method=",
+      conn.method,
+      "\npath=",
+      conn.path,
+      "\nquery=",
+      conn.query_string,
+      "\nbody=",
+      conn.body,
+      "\nhalted=",
+      if(conn.halted, do: "true", else: "false"),
+      "\nstate=",
+      Atom.to_string(conn.state)
     ]
 
-    iodata = case conn.status do
-      nil -> iodata
-      s -> [iodata, "\nstatus=", Integer.to_string(s)]
-    end
-
-    iodata = Enum.reduce(conn.assigns, iodata, fn {k, v}, acc ->
-      [acc, "\nassign:", to_string(k), ?=, to_string(v)]
-    end)
-
-    iodata = Enum.reduce(conn.params, iodata, fn {k, v}, acc ->
-      [acc, "\nparam:", to_string(k), ?=, to_string(v)]
-    end)
-
-    iodata = Enum.reduce(conn.resp_headers, iodata, fn {k, v}, acc ->
-      [acc, "\nresp_header:", k, ?=, v]
-    end)
-
-    iodata = Enum.reduce(conn.req_headers, iodata, fn {k, v}, acc ->
-      [acc, "\nreq_header:", k, ?=, v]
-    end)
-
-    iodata = Enum.reduce(conn.cookies, iodata, fn {k, v}, acc ->
-      [acc, "\ncookie:", k, ?=, v]
-    end)
+    iodata =
+      case conn.status do
+        nil -> iodata
+        s -> [iodata, "\nstatus=", Integer.to_string(s)]
+      end
 
-    iodata = case conn.resp_body do
-      nil -> iodata
-      body when is_binary(body) -> [iodata, "\nresp_body=", body]
-    end
+    iodata =
+      Enum.reduce(conn.assigns, iodata, fn {k, v}, acc ->
+        [acc, "\nassign:", to_string(k), ?=, to_string(v)]
+      end)
+
+    iodata =
+      Enum.reduce(conn.params, iodata, fn {k, v}, acc ->
+        [acc, "\nparam:", to_string(k), ?=, to_string(v)]
+      end)
+
+    iodata =
+      Enum.reduce(conn.resp_headers, iodata, fn {k, v}, acc ->
+        [acc, "\nresp_header:", k, ?=, v]
+      end)
+
+    iodata =
+      Enum.reduce(conn.req_headers, iodata, fn {k, v}, acc ->
+        [acc, "\nreq_header:", k, ?=, v]
+      end)
+
+    iodata =
+      Enum.reduce(conn.cookies, iodata, fn {k, v}, acc ->
+        [acc, "\ncookie:", k, ?=, v]
+      end)
+
+    iodata =
+      case conn.resp_body do
+        nil -> iodata
+        body when is_binary(body) -> [iodata, "\nresp_body=", body]
+      end
 
     IO.iodata_to_binary(iodata)
   end
diff --git a/lib/firebird/phoenix/csrf.ex b/lib/firebird/phoenix/csrf.ex
index 59e9d05..1bc17b3 100644
--- a/lib/firebird/phoenix/csrf.ex
+++ b/lib/firebird/phoenix/csrf.ex
@@ -29,7 +29,8 @@ defmodule Firebird.Phoenix.CSRF do
   """
 
   @token_size 24
-  @max_age_seconds 86400  # 24 hours
+  # 24 hours
+  @max_age_seconds 86400
 
   @doc """
   Generate a new CSRF token.
@@ -48,6 +49,7 @@ defmodule Firebird.Phoenix.CSRF do
   @spec generate_token(keyword()) :: String.t()
   def generate_token(opts \\ []) do
     size = Keyword.get(opts, :size, @token_size)
+
     :crypto.strong_rand_bytes(size)
     |> Base.url_encode64(padding: false)
   end
@@ -122,7 +124,6 @@ defmodule Firebird.Phoenix.CSRF do
     with {:ok, decoded} <- Base.url_decode64(signed_token, padding: false),
          [token, timestamp_str, signature] <- String.split(decoded, "|", parts: 3),
          {timestamp, ""} <- Integer.parse(timestamp_str) do
-
       payload = "#{token}|#{timestamp_str}"
       expected_sig = compute_signature(secret, payload)
 
@@ -175,8 +176,9 @@ defmodule Firebird.Phoenix.CSRF do
       if conn.method in ["GET", "HEAD", "OPTIONS"] do
         conn
       else
-        request_token = Map.get(conn.params, param_key) ||
-                        Map.get(conn.req_headers, header_key)
+        request_token =
+          Map.get(conn.params, param_key) ||
+            Map.get(conn.req_headers, header_key)
 
         if expected_token && request_token && constant_time_compare(request_token, expected_token) do
           conn
@@ -206,10 +208,11 @@ defmodule Firebird.Phoenix.CSRF do
       a_bytes = :binary.bin_to_list(a)
       b_bytes = :binary.bin_to_list(b)
 
-      result = Enum.zip(a_bytes, b_bytes)
-      |> Enum.reduce(0, fn {x, y}, acc ->
-        Bitwise.bor(acc, Bitwise.bxor(x, y))
-      end)
+      result =
+        Enum.zip(a_bytes, b_bytes)
+        |> Enum.reduce(0, fn {x, y}, acc ->
+          Bitwise.bor(acc, Bitwise.bxor(x, y))
+        end)
 
       result == 0
     end
@@ -228,6 +231,7 @@ defmodule Firebird.Phoenix.CSRF do
         secret = :crypto.strong_rand_bytes(32) |> Base.encode64()
         Process.put(:firebird_csrf_secret, secret)
         secret
+
       secret ->
         secret
     end
diff --git a/lib/firebird/phoenix/csrf_wasm.ex b/lib/firebird/phoenix/csrf_wasm.ex
index 08ad2c4..4b52666 100644
--- a/lib/firebird/phoenix/csrf_wasm.ex
+++ b/lib/firebird/phoenix/csrf_wasm.ex
@@ -43,6 +43,7 @@ defmodule Firebird.Phoenix.CsrfWasm do
   @spec verify_token(pid(), String.t(), String.t()) :: {:ok, :valid | :invalid} | {:error, term()}
   def verify_token(instance, token, secret_key) when is_binary(token) and is_binary(secret_key) do
     input = "#{token}|#{secret_key}"
+
     case WasmHelper.call_string(instance, "verify_token", input) do
       {:ok, "valid"} -> {:ok, :valid}
       {:ok, "invalid" <> _} -> {:ok, :invalid}
@@ -70,6 +71,7 @@ defmodule Firebird.Phoenix.CsrfWasm do
   @spec constant_compare(pid(), String.t(), String.t()) :: {:ok, boolean()} | {:error, term()}
   def constant_compare(instance, a, b) when is_binary(a) and is_binary(b) do
     input = "#{a}|#{b}"
+
     case WasmHelper.call_string(instance, "constant_compare", input) do
       {:ok, "match"} -> {:ok, true}
       {:ok, "no_match"} -> {:ok, false}
diff --git a/lib/firebird/phoenix/eex_compiler.ex b/lib/firebird/phoenix/eex_compiler.ex
index f6ef7d8..63e9362 100644
--- a/lib/firebird/phoenix/eex_compiler.ex
+++ b/lib/firebird/phoenix/eex_compiler.ex
@@ -132,26 +132,29 @@ defmodule Firebird.Phoenix.EExCompiler do
     errors = []
 
     # Check for unsupported function calls
-    errors = if Regex.match?(~r/<%=\s*[a-z_]+\((?!@)/, eex_template) and
-                not Regex.match?(~r/<%=\s*raw\(@/, eex_template) do
-      ["Unsupported: function calls (only @var and raw(@var) are supported)" | errors]
-    else
-      errors
-    end
+    errors =
+      if Regex.match?(~r/<%=\s*[a-z_]+\((?!@)/, eex_template) and
+           not Regex.match?(~r/<%=\s*raw\(@/, eex_template) do
+        ["Unsupported: function calls (only @var and raw(@var) are supported)" | errors]
+      else
+        errors
+      end
 
     # Check for complex expressions
-    errors = if Regex.match?(~r/<%=.*[\+\-\*\/].*%>/, eex_template) do
-      ["Unsupported: arithmetic expressions in templates" | errors]
-    else
-      errors
-    end
+    errors =
+      if Regex.match?(~r/<%=.*[\+\-\*\/].*%>/, eex_template) do
+        ["Unsupported: arithmetic expressions in templates" | errors]
+      else
+        errors
+      end
 
     # Check for pipeline operator
-    errors = if Regex.match?(~r/<%=.*\|>.*%>/, eex_template) do
-      ["Unsupported: pipeline operator in templates" | errors]
-    else
-      errors
-    end
+    errors =
+      if Regex.match?(~r/<%=.*\|>.*%>/, eex_template) do
+        ["Unsupported: pipeline operator in templates" | errors]
+      else
+        errors
+      end
 
     if errors == [] do
       :ok
diff --git a/lib/firebird/phoenix/endpoint.ex b/lib/firebird/phoenix/endpoint.ex
index 0f714cc..4ff63a5 100644
--- a/lib/firebird/phoenix/endpoint.ex
+++ b/lib/firebird/phoenix/endpoint.ex
@@ -72,8 +72,10 @@ defmodule Firebird.Phoenix.Endpoint do
     case FastHelper.call_string(instance, "parse_conn", raw_request) do
       {:ok, "error|" <> reason} ->
         {:error, reason}
+
       {:ok, result} ->
         {:ok, deserialize_conn(result)}
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -110,15 +112,18 @@ defmodule Firebird.Phoenix.Endpoint do
       conn.resp_headers["access-control-allow-origin"]  # => "*"
   """
   @spec execute_pipeline(pid(), String.t(), list(String.t())) :: {:ok, map()} | {:error, term()}
-  def execute_pipeline(instance, raw_request, plugs) when is_binary(raw_request) and is_list(plugs) do
+  def execute_pipeline(instance, raw_request, plugs)
+      when is_binary(raw_request) and is_list(plugs) do
     plug_lines = Enum.join(plugs, "\n")
     input = "#{raw_request}\n---PIPELINE---\n#{plug_lines}"
 
     case FastHelper.call_string(instance, "execute_pipeline", input) do
       {:ok, "error|" <> reason} ->
         {:error, reason}
+
       {:ok, result} ->
         {:ok, deserialize_conn(result)}
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -166,13 +171,17 @@ defmodule Firebird.Phoenix.Endpoint do
   @spec dispatch(pid(), String.t(), list(tuple()), map()) :: {:ok, String.t()} | {:error, term()}
   def dispatch(instance, raw_request, routes, actions)
       when is_binary(raw_request) and is_list(routes) and is_map(actions) do
-    route_lines = Enum.map(routes, fn {method, pattern, handler} ->
-      "#{method}|#{pattern}|#{handler}"
-    end) |> Enum.join("\n")
-
-    action_lines = Enum.map(actions, fn {handler, {status, content_type, body}} ->
-      "#{handler}=#{status}:#{content_type}:#{body}"
-    end) |> Enum.join("\n")
+    route_lines =
+      Enum.map(routes, fn {method, pattern, handler} ->
+        "#{method}|#{pattern}|#{handler}"
+      end)
+      |> Enum.join("\n")
+
+    action_lines =
+      Enum.map(actions, fn {handler, {status, content_type, body}} ->
+        "#{handler}=#{status}:#{content_type}:#{body}"
+      end)
+      |> Enum.join("\n")
 
     input = "#{raw_request}\n---ROUTES---\n#{route_lines}\n---ACTIONS---\n#{action_lines}"
 
@@ -236,9 +245,10 @@ defmodule Firebird.Phoenix.Endpoint do
       )
   """
   @spec render_response(pid(), integer(), String.t(), String.t(), map()) ::
-    {:ok, String.t()} | {:error, term()}
+          {:ok, String.t()} | {:error, term()}
   def render_response(instance, status, content_type, template, assigns \\ %{})
-      when is_integer(status) and is_binary(content_type) and is_binary(template) and is_map(assigns) do
+      when is_integer(status) and is_binary(content_type) and is_binary(template) and
+             is_map(assigns) do
     assign_lines = Enum.map(assigns, fn {k, v} -> "#{k}=#{v}" end) |> Enum.join("\n")
     input = "#{status}\n#{content_type}\n#{template}\n---ASSIGNS---\n#{assign_lines}"
 
@@ -274,9 +284,11 @@ defmodule Firebird.Phoenix.Endpoint do
   """
   @spec serve_static(pid(), String.t(), map()) :: {:ok, String.t()} | {:error, term()}
   def serve_static(instance, path, files) when is_binary(path) and is_map(files) do
-    file_lines = Enum.map(files, fn {file_path, {content_type, body}} ->
-      "#{file_path}=#{content_type}:#{body}"
-    end) |> Enum.join("\n")
+    file_lines =
+      Enum.map(files, fn {file_path, {content_type, body}} ->
+        "#{file_path}=#{content_type}:#{body}"
+      end)
+      |> Enum.join("\n")
 
     input = "#{path}\n---FILES---\n#{file_lines}"
 
@@ -330,15 +342,19 @@ defmodule Firebird.Phoenix.Endpoint do
   # Recursive line parser using binary matching — no intermediate list allocations
   defp deserialize_lines([], conn), do: conn
   defp deserialize_lines([<<>> | rest], conn), do: deserialize_lines(rest, conn)
+
   defp deserialize_lines([line | rest], conn) do
-    conn = case :binary.match(line, <<"=">>) do
-      {pos, 1} ->
-        key = binary_part(line, 0, pos)
-        val = binary_part(line, pos + 1, byte_size(line) - pos - 1)
-        apply_conn_field(conn, key, val)
-      :nomatch ->
-        conn
-    end
+    conn =
+      case :binary.match(line, <<"=">>) do
+        {pos, 1} ->
+          key = binary_part(line, 0, pos)
+          val = binary_part(line, pos + 1, byte_size(line) - pos - 1)
+          apply_conn_field(conn, key, val)
+
+        :nomatch ->
+          conn
+      end
+
     deserialize_lines(rest, conn)
   end
 
@@ -346,6 +362,7 @@ defmodule Firebird.Phoenix.Endpoint do
   defp apply_conn_field(conn, <<"status">>, val) do
     %{conn | status: parse_integer_safe(val, 200)}
   end
+
   defp apply_conn_field(conn, <<"method">>, val), do: %{conn | method: val}
   defp apply_conn_field(conn, <<"path">>, val), do: %{conn | path: val}
   defp apply_conn_field(conn, <<"query">>, val), do: %{conn | query: val}
@@ -353,24 +370,31 @@ defmodule Firebird.Phoenix.Endpoint do
   defp apply_conn_field(conn, <<"halted">>, <<"true">>), do: %{conn | halted: true}
   defp apply_conn_field(conn, <<"halted">>, <<"false">>), do: %{conn | halted: false}
   defp apply_conn_field(conn, <<"state">>, val), do: %{conn | state: val}
+
   defp apply_conn_field(conn, <<"assign:", key::binary>>, val) do
     %{conn | assigns: Map.put(conn.assigns, key, val)}
   end
+
   defp apply_conn_field(conn, <<"param:", key::binary>>, val) do
     %{conn | params: Map.put(conn.params, key, val)}
   end
+
   defp apply_conn_field(conn, <<"resp_header:", key::binary>>, val) do
     %{conn | resp_headers: Map.put(conn.resp_headers, key, val)}
   end
+
   defp apply_conn_field(conn, <<"req_header:", key::binary>>, val) do
     %{conn | req_headers: Map.put(conn.req_headers, key, val)}
   end
+
   defp apply_conn_field(conn, <<"cookie:", key::binary>>, val) do
     %{conn | cookies: Map.put(conn.cookies, key, val)}
   end
+
   defp apply_conn_field(conn, <<"resp_body">>, val) do
     %{conn | resp_body: val}
   end
+
   defp apply_conn_field(conn, _key, _val), do: conn
 
   # ─── Batch Operations ──────────────────────────────────────
@@ -413,30 +437,40 @@ defmodule Firebird.Phoenix.Endpoint do
       # => 3 HTTP response strings
   """
   @spec batch_dispatch(pid(), list(String.t()), list(tuple()), map()) ::
-    {:ok, list(String.t())} | {:error, term()}
+          {:ok, list(String.t())} | {:error, term()}
   def batch_dispatch(instance, requests, routes, actions)
       when is_list(requests) and is_list(routes) and is_map(actions) do
-    route_lines = Enum.map(routes, fn {method, pattern, handler} ->
-      [method, "|", pattern, "|", handler]
-    end) |> Enum.intersperse("\n")
-
-    action_lines = Enum.map(actions, fn {handler, {status, content_type, body}} ->
-      [handler, "=", Integer.to_string(status), ":", content_type, ":", body]
-    end) |> Enum.intersperse("\n")
+    route_lines =
+      Enum.map(routes, fn {method, pattern, handler} ->
+        [method, "|", pattern, "|", handler]
+      end)
+      |> Enum.intersperse("\n")
+
+    action_lines =
+      Enum.map(actions, fn {handler, {status, content_type, body}} ->
+        [handler, "=", Integer.to_string(status), ":", content_type, ":", body]
+      end)
+      |> Enum.intersperse("\n")
 
     request_data = Enum.intersperse(requests, <<0>>)
 
-    input = IO.iodata_to_binary([
-      "---ROUTES---\n", route_lines,
-      "\n---ACTIONS---\n", action_lines,
-      "\n---REQUESTS---\n", request_data
-    ])
+    input =
+      IO.iodata_to_binary([
+        "---ROUTES---\n",
+        route_lines,
+        "\n---ACTIONS---\n",
+        action_lines,
+        "\n---REQUESTS---\n",
+        request_data
+      ])
 
     case FastHelper.call_string(instance, "batch_dispatch", input) do
       {:ok, <<"error|", reason::binary>>} ->
         {:error, reason}
+
       {:ok, result} ->
         {:ok, :binary.split(result, <<0>>, [:global])}
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -471,24 +505,31 @@ defmodule Firebird.Phoenix.Endpoint do
       # => 3 conn maps, last one halted (OPTIONS preflight)
   """
   @spec batch_execute_pipeline(pid(), list(String.t()), list(String.t())) ::
-    {:ok, list(map())} | {:error, term()}
+          {:ok, list(map())} | {:error, term()}
   def batch_execute_pipeline(instance, requests, plugs)
       when is_list(requests) and is_list(plugs) do
     plug_lines = Enum.intersperse(plugs, "\n")
     request_data = Enum.intersperse(requests, <<0>>)
 
-    input = IO.iodata_to_binary([
-      plug_lines, "\n---REQUESTS---\n", request_data
-    ])
+    input =
+      IO.iodata_to_binary([
+        plug_lines,
+        "\n---REQUESTS---\n",
+        request_data
+      ])
 
     case FastHelper.call_string(instance, "batch_execute_pipeline", input) do
       {:ok, <<"error|", reason::binary>>} ->
         {:error, reason}
+
       {:ok, result} ->
-        conns = result
+        conns =
+          result
           |> :binary.split(<<0>>, [:global])
           |> Enum.map(&deserialize_conn/1)
+
         {:ok, conns}
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -517,20 +558,23 @@ defmodule Firebird.Phoenix.Endpoint do
       ])
   """
   @spec batch_json_response(pid(), list({integer(), map()})) ::
-    {:ok, list(String.t())} | {:error, term()}
+          {:ok, list(String.t())} | {:error, term()}
   def batch_json_response(instance, responses) when is_list(responses) do
-    blocks = Enum.map(responses, fn {status, data} ->
-      lines = [Integer.to_string(status) | Enum.map(data, fn {k, v} -> [k, "=", v] end)]
-      Enum.intersperse(lines, "\n")
-    end)
+    blocks =
+      Enum.map(responses, fn {status, data} ->
+        lines = [Integer.to_string(status) | Enum.map(data, fn {k, v} -> [k, "=", v] end)]
+        Enum.intersperse(lines, "\n")
+      end)
 
     input = blocks |> Enum.intersperse(<<0>>) |> IO.iodata_to_binary()
 
     case FastHelper.call_string(instance, "batch_json_response", input) do
       {:ok, <<"error|", reason::binary>>} ->
         {:error, reason}
+
       {:ok, result} ->
         {:ok, :binary.split(result, <<0>>, [:global])}
+
       {:error, reason} ->
         {:error, reason}
     end
diff --git a/lib/firebird/phoenix/error_handler.ex b/lib/firebird/phoenix/error_handler.ex
index 15ac3dc..7fef74f 100644
--- a/lib/firebird/phoenix/error_handler.ex
+++ b/lib/firebird/phoenix/error_handler.ex
@@ -24,9 +24,9 @@ defmodule Firebird.Phoenix.ErrorHandler do
   alias Firebird.Phoenix.Conn
 
   @type t :: %__MODULE__{
-    templates: %{integer() => String.t()},
-    format: :html | :json
-  }
+          templates: %{integer() => String.t()},
+          format: :html | :json
+        }
 
   defstruct templates: %{}, format: :html
 
@@ -81,6 +81,7 @@ defmodule Firebird.Phoenix.ErrorHandler do
 
       template ->
         all_assigns = Map.merge(%{"status" => "#{status}", "message" => message}, assigns)
+
         Enum.reduce(all_assigns, template, fn {k, v}, acc ->
           String.replace(acc, "{{#{k}}}", to_string(v))
         end)
@@ -101,10 +102,15 @@ defmodule Firebird.Phoenix.ErrorHandler do
   @doc "Build an error connection response."
   @spec error_conn(integer(), :html | :json) :: Conn.t()
   def error_conn(status, format \\ :html) do
-    {content_type, body} = case format do
-      :json -> {"application/json", default_json_error(status, Map.get(@default_messages, status, "Error"))}
-      :html -> {"text/html", default_html_error(status, Map.get(@default_messages, status, "Error"))}
-    end
+    {content_type, body} =
+      case format do
+        :json ->
+          {"application/json",
+           default_json_error(status, Map.get(@default_messages, status, "Error"))}
+
+        :html ->
+          {"text/html", default_html_error(status, Map.get(@default_messages, status, "Error"))}
+      end
 
     Conn.new("GET", "/")
     |> Conn.put_status(status)
diff --git a/lib/firebird/phoenix/form.ex b/lib/firebird/phoenix/form.ex
index 79ed69a..2146690 100644
--- a/lib/firebird/phoenix/form.ex
+++ b/lib/firebird/phoenix/form.ex
@@ -43,12 +43,14 @@ defmodule Firebird.Phoenix.Form do
     csrf_token = Keyword.get(opts, :csrf_token, generate_csrf_token())
     multipart = Keyword.get(opts, :multipart, false)
 
-    {actual_method, method_input} = case method do
-      m when m in [:put, :patch, :delete] ->
-        {"post", ~s(<input type="hidden" name="_method" value="#{m}"/>)}
-      m ->
-        {to_string(m), ""}
-    end
+    {actual_method, method_input} =
+      case method do
+        m when m in [:put, :patch, :delete] ->
+          {"post", ~s(<input type="hidden" name="_method" value="#{m}"/>)}
+
+        m ->
+          {to_string(m), ""}
+      end
 
     attrs = [
       ~s(action="#{escape(action)}"),
@@ -59,11 +61,12 @@ defmodule Firebird.Phoenix.Form do
     attrs = maybe_add_attr(attrs, opts, :class, "class")
     attrs = maybe_add_attr(attrs, opts, :id, "id")
 
-    csrf_input = if csrf_token do
-      ~s(<input type="hidden" name="_csrf_token" value="#{escape(csrf_token)}"/>)
-    else
-      ""
-    end
+    csrf_input =
+      if csrf_token do
+        ~s(<input type="hidden" name="_csrf_token" value="#{escape(csrf_token)}"/>)
+      else
+        ""
+      end
 
     "<form #{Enum.join(attrs, " ")}>#{csrf_input}#{method_input}"
   end
@@ -188,19 +191,24 @@ defmodule Firebird.Phoenix.Form do
     attrs = maybe_add_bool_attr(attrs, opts, :required, "required")
     attrs = maybe_add_bool_attr(attrs, opts, :disabled, "disabled")
 
-    prompt_option = case Keyword.get(opts, :prompt) do
-      nil -> ""
-      text -> ~s(<option value="">#{escape(text)}</option>)
-    end
+    prompt_option =
+      case Keyword.get(opts, :prompt) do
+        nil -> ""
+        text -> ~s(<option value="">#{escape(text)}</option>)
+      end
 
-    option_tags = Enum.map(options, fn
-      {label, value} ->
-        sel = if to_string(value) == to_string(selected), do: ~s( selected), else: ""
-        ~s(<option value="#{escape(to_string(value))}"#{sel}>#{escape(to_string(label))}</option>)
-      value ->
-        sel = if to_string(value) == to_string(selected), do: ~s( selected), else: ""
-        ~s(<option value="#{escape(to_string(value))}"#{sel}>#{escape(to_string(value))}</option>)
-    end)
+    option_tags =
+      Enum.map(options, fn
+        {label, value} ->
+          sel = if to_string(value) == to_string(selected), do: ~s( selected), else: ""
+
+          ~s(<option value="#{escape(to_string(value))}"#{sel}>#{escape(to_string(label))}</option>)
+
+        value ->
+          sel = if to_string(value) == to_string(selected), do: ~s( selected), else: ""
+
+          ~s(<option value="#{escape(to_string(value))}"#{sel}>#{escape(to_string(value))}</option>)
+      end)
 
     "<select #{Enum.join(attrs, " ")}>#{prompt_option}#{Enum.join(option_tags)}</select>"
   end
@@ -231,6 +239,7 @@ defmodule Firebird.Phoenix.Form do
       ~s(id="#{escape(id)}"),
       ~s(value="#{escape(to_string(value))}")
     ]
+
     attrs = maybe_add_attr(attrs, opts, :class, "class")
 
     # Hidden field for unchecked state (Phoenix convention)
@@ -259,6 +268,7 @@ defmodule Firebird.Phoenix.Form do
       ~s(id="#{escape(id)}"),
       ~s(value="#{escape(to_string(value))}")
     ]
+
     attrs = maybe_add_attr(attrs, opts, :class, "class")
 
     "<input #{Enum.join(attrs, " ")}#{checked_attr}/>"
diff --git a/lib/firebird/phoenix/form_wasm.ex b/lib/firebird/phoenix/form_wasm.ex
index a055210..50417d6 100644
--- a/lib/firebird/phoenix/form_wasm.ex
+++ b/lib/firebird/phoenix/form_wasm.ex
@@ -37,7 +37,8 @@ defmodule Firebird.Phoenix.FormWasm do
   - `:class` - CSS class
   - `:id` - HTML id attribute
   """
-  @spec build_form(pid(), String.t(), String.t(), keyword()) :: {:ok, String.t()} | {:error, term()}
+  @spec build_form(pid(), String.t(), String.t(), keyword()) ::
+          {:ok, String.t()} | {:error, term()}
   def build_form(instance, scope, action, opts \\ []) do
     method = Keyword.get(opts, :method, :post) |> to_string()
     csrf = Keyword.get(opts, :csrf_token, "")
@@ -60,31 +61,36 @@ defmodule Firebird.Phoenix.FormWasm do
   - `:placeholder` - Placeholder text
   - `:required` - Whether field is required
   """
-  @spec text_input(pid(), String.t(), String.t(), keyword()) :: {:ok, String.t()} | {:error, term()}
+  @spec text_input(pid(), String.t(), String.t(), keyword()) ::
+          {:ok, String.t()} | {:error, term()}
   def text_input(instance, scope, field, opts \\ []) do
     build_input(instance, "text", scope, field, opts)
   end
 
   @doc "Build an email input field."
-  @spec email_input(pid(), String.t(), String.t(), keyword()) :: {:ok, String.t()} | {:error, term()}
+  @spec email_input(pid(), String.t(), String.t(), keyword()) ::
+          {:ok, String.t()} | {:error, term()}
   def email_input(instance, scope, field, opts \\ []) do
     build_input(instance, "email", scope, field, opts)
   end
 
   @doc "Build a password input field."
-  @spec password_input(pid(), String.t(), String.t(), keyword()) :: {:ok, String.t()} | {:error, term()}
+  @spec password_input(pid(), String.t(), String.t(), keyword()) ::
+          {:ok, String.t()} | {:error, term()}
   def password_input(instance, scope, field, opts \\ []) do
     build_input(instance, "password", scope, field, opts)
   end
 
   @doc "Build a number input field."
-  @spec number_input(pid(), String.t(), String.t(), keyword()) :: {:ok, String.t()} | {:error, term()}
+  @spec number_input(pid(), String.t(), String.t(), keyword()) ::
+          {:ok, String.t()} | {:error, term()}
   def number_input(instance, scope, field, opts \\ []) do
     build_input(instance, "number", scope, field, opts)
   end
 
   @doc "Build a hidden input field."
-  @spec hidden_input(pid(), String.t(), String.t(), keyword()) :: {:ok, String.t()} | {:error, term()}
+  @spec hidden_input(pid(), String.t(), String.t(), keyword()) ::
+          {:ok, String.t()} | {:error, term()}
   def hidden_input(instance, scope, field, opts \\ []) do
     build_input(instance, "hidden", scope, field, opts)
   end
@@ -136,15 +142,18 @@ defmodule Firebird.Phoenix.FormWasm do
 
   - `:selected` - Currently selected value
   """
-  @spec select(pid(), String.t(), String.t(), list(), keyword()) :: {:ok, String.t()} | {:error, term()}
+  @spec select(pid(), String.t(), String.t(), list(), keyword()) ::
+          {:ok, String.t()} | {:error, term()}
   def select(instance, scope, field, options, opts \\ []) do
     selected = Keyword.get(opts, :selected, "") |> to_string()
 
     header = Enum.join([scope, field, selected], "|")
-    option_lines = Enum.map(options, fn
-      {value, label} -> "#{value}|#{label}"
-      value -> "#{value}|#{value}"
-    end)
+
+    option_lines =
+      Enum.map(options, fn
+        {value, label} -> "#{value}|#{label}"
+        value -> "#{value}|#{value}"
+      end)
 
     input = Enum.join([header | option_lines], "\n")
     WasmHelper.call_string(instance, "build_select", input)
diff --git a/lib/firebird/phoenix/health.ex b/lib/firebird/phoenix/health.ex
index 8fe23d6..a603de9 100644
--- a/lib/firebird/phoenix/health.ex
+++ b/lib/firebird/phoenix/health.ex
@@ -41,21 +41,24 @@ defmodule Firebird.Phoenix.Health do
     total = Enum.count(info, fn {_, v} -> v != :not_loaded end)
     stopped = Enum.count(info, fn {_, v} -> v == :stopped end)
 
-    status = cond do
-      total == 0 -> :healthy  # No components loaded = nothing to check
-      stopped == 0 and running > 0 -> :healthy
-      stopped > 0 and running > 0 -> :degraded
-      running == 0 and total > 0 -> :unhealthy
-      true -> :healthy
-    end
+    status =
+      cond do
+        # No components loaded = nothing to check
+        total == 0 -> :healthy
+        stopped == 0 and running > 0 -> :healthy
+        stopped > 0 and running > 0 -> :degraded
+        running == 0 and total > 0 -> :unhealthy
+        true -> :healthy
+      end
 
-    {:ok, %{
-      status: status,
-      healthy?: status == :healthy,
-      running: running,
-      total: total,
-      stopped: stopped
-    }}
+    {:ok,
+     %{
+       status: status,
+       healthy?: status == :healthy,
+       running: running,
+       total: total,
+       stopped: stopped
+     }}
   end
 
   @doc """
@@ -75,17 +78,19 @@ defmodule Firebird.Phoenix.Health do
       elixir_version: System.version()
     }
 
-    telemetry = try do
-      Firebird.Phoenix.Telemetry.get_metrics()
-    rescue
-      _ -> %{request_count: 0, error_count: 0}
-    end
+    telemetry =
+      try do
+        Firebird.Phoenix.Telemetry.get_metrics()
+      rescue
+        _ -> %{request_count: 0, error_count: 0}
+      end
 
-    {:ok, Map.merge(quick, %{
-      components: info,
-      system: system_info,
-      telemetry: telemetry
-    })}
+    {:ok,
+     Map.merge(quick, %{
+       components: info,
+       system: system_info,
+       telemetry: telemetry
+     })}
   end
 
   @doc """
@@ -96,9 +101,10 @@ defmodule Firebird.Phoenix.Health do
     {:ok, report} = detailed(components)
     info = Firebird.Phoenix.info(components)
 
-    components_json = info
-    |> Enum.map(fn {k, v} -> ~s("#{k}":"#{v}") end)
-    |> Enum.join(",")
+    components_json =
+      info
+      |> Enum.map(fn {k, v} -> ~s("#{k}":"#{v}") end)
+      |> Enum.join(",")
 
     ~s({"status":"#{report.status}","running":#{report.running},"total":#{report.total},"system":{"memory_mb":#{report.system.beam_memory_mb},"processes":#{report.system.process_count}},"components":{#{components_json}}})
   end
@@ -141,10 +147,12 @@ defmodule Firebird.Phoenix.Health do
   def readiness_action(components) do
     fn _params ->
       {:ok, health} = check(components)
+
       if health.healthy? do
         {200, "application/json", ~s({"status":"ready"})}
       else
-        {503, "application/json", ~s({"status":"not_ready","running":#{health.running},"total":#{health.total}})}
+        {503, "application/json",
+         ~s({"status":"not_ready","running":#{health.running},"total":#{health.total}})}
       end
     end
   end
diff --git a/lib/firebird/phoenix/live_component.ex b/lib/firebird/phoenix/live_component.ex
index fc46987..bc1f6c1 100644
--- a/lib/firebird/phoenix/live_component.ex
+++ b/lib/firebird/phoenix/live_component.ex
@@ -26,11 +26,11 @@ defmodule Firebird.Phoenix.LiveComponent do
   """
 
   @type component_state :: %{
-    module: module(),
-    assigns: map(),
-    rendered_html: String.t() | nil,
-    hash: String.t() | nil
-  }
+          module: module(),
+          assigns: map(),
+          rendered_html: String.t() | nil,
+          hash: String.t() | nil
+        }
 
   defmacro __using__(_opts) do
     quote do
@@ -47,9 +47,12 @@ defmodule Firebird.Phoenix.LiveComponent do
 
       def render(assigns) do
         template = template()
-        rendered = Enum.reduce(assigns, template, fn {k, v}, acc ->
-          String.replace(acc, "{{#{k}}}", html_escape(to_string(v)))
-        end)
+
+        rendered =
+          Enum.reduce(assigns, template, fn {k, v}, acc ->
+            String.replace(acc, "{{#{k}}}", html_escape(to_string(v)))
+          end)
+
         {:ok, rendered}
       end
 
@@ -60,11 +63,7 @@ defmodule Firebird.Phoenix.LiveComponent do
           {:unchanged, state}
         else
           {:ok, new_html} = render(merged)
-          new_state = %{state |
-            assigns: merged,
-            rendered_html: new_html,
-            hash: hash(new_html)
-          }
+          new_state = %{state | assigns: merged, rendered_html: new_html, hash: hash(new_html)}
 
           if state.rendered_html == nil do
             {:initial, new_state}
@@ -94,7 +93,7 @@ defmodule Firebird.Phoenix.LiveComponent do
         end
       end
 
-      defoverridable [render: 1, update: 2]
+      defoverridable render: 1, update: 2
     end
   end
 
diff --git a/lib/firebird/phoenix/middleware.ex b/lib/firebird/phoenix/middleware.ex
index 7e608df..7ca5395 100644
--- a/lib/firebird/phoenix/middleware.ex
+++ b/lib/firebird/phoenix/middleware.ex
@@ -110,6 +110,7 @@ defmodule Firebird.Phoenix.Middleware do
   def request_id do
     fn conn ->
       id = :rand.bytes(16) |> Base.hex_encode32(case: :lower, padding: false)
+
       conn
       |> Conn.assign(:request_id, id)
       |> Conn.put_resp_header("x-request-id", id)
@@ -503,18 +504,23 @@ defmodule Firebird.Phoenix.Middleware do
           # Convert params to string map for WASM template engine
           string_params = Map.new(conn.params, fn {k, v} -> {to_string(k), to_string(v)} end)
 
-          rendered_body = if has_mustache_vars?(body_template) do
-            try do
-              case Firebird.Phoenix.Template.render(template_instance, body_template, string_params) do
-                {:ok, rendered} -> rendered
-                {:error, _} -> render_elixir_fallback(body_template, string_params)
+          rendered_body =
+            if has_mustache_vars?(body_template) do
+              try do
+                case Firebird.Phoenix.Template.render(
+                       template_instance,
+                       body_template,
+                       string_params
+                     ) do
+                  {:ok, rendered} -> rendered
+                  {:error, _} -> render_elixir_fallback(body_template, string_params)
+                end
+              rescue
+                _ -> render_elixir_fallback(body_template, string_params)
               end
-            rescue
-              _ -> render_elixir_fallback(body_template, string_params)
+            else
+              body_template
             end
-          else
-            body_template
-          end
 
           conn
           |> Conn.put_status(status)
diff --git a/lib/firebird/phoenix/pipeline.ex b/lib/firebird/phoenix/pipeline.ex
index e415118..8d8737e 100644
--- a/lib/firebird/phoenix/pipeline.ex
+++ b/lib/firebird/phoenix/pipeline.ex
@@ -62,15 +62,19 @@ defmodule Firebird.Phoenix.Pipeline do
   - `{:error, reason}` - Pipeline execution failed
   """
   @spec execute(t(), pipeline_name(), pid(), String.t() | Conn.t()) ::
-    {:ok, Conn.t()} | {:error, term()}
+          {:ok, Conn.t()} | {:error, term()}
   def execute(%__MODULE__{} = builder, name, endpoint_instance, request) do
     case Map.get(builder.pipelines, name) do
-      nil -> {:error, :unknown_pipeline}
+      nil ->
+        {:error, :unknown_pipeline}
+
       plugs ->
-        raw = case request do
-          %Conn{} = conn -> Conn.to_raw_request(conn)
-          raw when is_binary(raw) -> raw
-        end
+        raw =
+          case request do
+            %Conn{} = conn -> Conn.to_raw_request(conn)
+            raw when is_binary(raw) -> raw
+          end
+
         case Endpoint.execute_pipeline(endpoint_instance, raw, plugs) do
           {:ok, map} -> {:ok, Conn.from_wasm(map)}
           {:error, reason} -> {:error, reason}
@@ -89,19 +93,22 @@ defmodule Firebird.Phoenix.Pipeline do
       {:ok, conn} = Pipeline.through(builder, [:api, :auth], endpoint, raw_request)
   """
   @spec through(t(), [pipeline_name()], pid(), String.t() | Conn.t()) ::
-    {:ok, Conn.t()} | {:error, term()}
+          {:ok, Conn.t()} | {:error, term()}
   def through(%__MODULE__{} = builder, names, endpoint_instance, request) when is_list(names) do
-    all_plugs = Enum.flat_map(names, fn name ->
-      Map.get(builder.pipelines, name, [])
-    end)
+    all_plugs =
+      Enum.flat_map(names, fn name ->
+        Map.get(builder.pipelines, name, [])
+      end)
 
     if all_plugs == [] do
       {:error, :empty_pipeline}
     else
-      raw = case request do
-        %Conn{} = conn -> Conn.to_raw_request(conn)
-        raw when is_binary(raw) -> raw
-      end
+      raw =
+        case request do
+          %Conn{} = conn -> Conn.to_raw_request(conn)
+          raw when is_binary(raw) -> raw
+        end
+
       case Endpoint.execute_pipeline(endpoint_instance, raw, all_plugs) do
         {:ok, map} -> {:ok, Conn.from_wasm(map)}
         {:error, reason} -> {:error, reason}
diff --git a/lib/firebird/phoenix/plug.ex b/lib/firebird/phoenix/plug.ex
index 1a02421..14192e9 100644
--- a/lib/firebird/phoenix/plug.ex
+++ b/lib/firebird/phoenix/plug.ex
@@ -46,8 +46,10 @@ defmodule Firebird.Phoenix.Plug do
     case FastHelper.call_string(instance, "parse_request", raw_request) do
       {:ok, "error|" <> reason} ->
         {:error, reason}
+
       {:ok, result} ->
         parse_request_result(result)
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -73,7 +75,8 @@ defmodule Firebird.Phoenix.Plug do
       {:ok, resp} = Firebird.Phoenix.Plug.build_response(instance, 200, "application/json", ~s({"ok": true}))
       {:ok, resp} = Firebird.Phoenix.Plug.build_response(instance, 404, "text/html", "<h1>Not Found</h1>")
   """
-  @spec build_response(pid(), integer(), String.t(), String.t()) :: {:ok, String.t()} | {:error, term()}
+  @spec build_response(pid(), integer(), String.t(), String.t()) ::
+          {:ok, String.t()} | {:error, term()}
   def build_response(instance, status, content_type, body)
       when is_integer(status) and is_binary(content_type) and is_binary(body) do
     input = IO.iodata_to_binary([Integer.to_string(status), "\n", content_type, "\n", body])
@@ -104,6 +107,7 @@ defmodule Firebird.Phoenix.Plug do
   def validate_csrf(instance, token, expected)
       when is_binary(token) and is_binary(expected) do
     input = IO.iodata_to_binary([token, "|", expected])
+
     case FastHelper.call_string(instance, "validate_csrf", input) do
       {:ok, "valid"} -> :valid
       {:ok, "invalid"} -> :invalid
@@ -135,10 +139,11 @@ defmodule Firebird.Phoenix.Plug do
       )
   """
   @spec negotiate_content_type(pid(), String.t(), list(String.t())) ::
-    {:ok, String.t()} | {:ok, :not_acceptable} | {:error, term()}
+          {:ok, String.t()} | {:ok, :not_acceptable} | {:error, term()}
   def negotiate_content_type(instance, accept_header, supported)
       when is_binary(accept_header) and is_list(supported) do
     input = Enum.join([accept_header | supported], "\n")
+
     case FastHelper.call_string(instance, "negotiate_content_type", input) do
       {:ok, "not_acceptable"} -> {:ok, :not_acceptable}
       {:ok, content_type} -> {:ok, content_type}
@@ -170,7 +175,8 @@ defmodule Firebird.Phoenix.Plug do
   """
   @spec encode_json(pid(), map()) :: {:ok, String.t()} | {:error, term()}
   def encode_json(instance, data) when is_map(data) do
-    input = data
+    input =
+      data
       |> Enum.map(fn {key, value} -> [key, "=", value] end)
       |> Enum.intersperse("\n")
       |> IO.iodata_to_binary()
@@ -194,7 +200,8 @@ defmodule Firebird.Phoenix.Plug do
   """
   @spec batch_encode_json(pid(), list(map())) :: {:ok, list(String.t())} | {:error, term()}
   def batch_encode_json(instance, data_list) when is_list(data_list) do
-    input = data_list
+    input =
+      data_list
       |> Enum.map(fn data ->
         data
         |> Enum.map(fn {key, value} -> [key, "=", value] end)
@@ -206,6 +213,7 @@ defmodule Firebird.Phoenix.Plug do
     case FastHelper.call_string(instance, "batch_encode_json", input) do
       {:ok, result} ->
         {:ok, :binary.split(result, <<0>>, [:global])}
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -226,16 +234,20 @@ defmodule Firebird.Phoenix.Plug do
   """
   @spec batch_parse_request(pid(), list(String.t())) :: {:ok, list(map())} | {:error, term()}
   def batch_parse_request(instance, requests) when is_list(requests) do
-    input = requests
+    input =
+      requests
       |> Enum.intersperse(<<0>>)
       |> IO.iodata_to_binary()
 
     case FastHelper.call_string(instance, "batch_parse_request", input) do
       {:ok, result} ->
-        results = result
+        results =
+          result
           |> :binary.split(<<0>>, [:global])
           |> Enum.map(&parse_request_result/1)
+
         {:ok, results}
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -254,9 +266,11 @@ defmodule Firebird.Phoenix.Plug do
   - `{:ok, [response_strings]}` - List of HTTP response strings
   - `{:error, reason}` - Build failed
   """
-  @spec batch_build_response(pid(), list({integer(), String.t(), String.t()})) :: {:ok, list(String.t())} | {:error, term()}
+  @spec batch_build_response(pid(), list({integer(), String.t(), String.t()})) ::
+          {:ok, list(String.t())} | {:error, term()}
   def batch_build_response(instance, responses) when is_list(responses) do
-    input = responses
+    input =
+      responses
       |> Enum.map(fn {status, content_type, body} ->
         [Integer.to_string(status), "\n", content_type, "\n", body]
       end)
@@ -266,6 +280,7 @@ defmodule Firebird.Phoenix.Plug do
     case FastHelper.call_string(instance, "batch_build_response", input) do
       {:ok, result} ->
         {:ok, :binary.split(result, <<0>>, [:global])}
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -273,17 +288,21 @@ defmodule Firebird.Phoenix.Plug do
 
   # Parse the structured request result using binary operations (no String.split)
   defp parse_request_result(<<"error|", reason::binary>>), do: {:error, reason}
+
   defp parse_request_result(result) when is_binary(result) do
     case split_pipes(result) do
       {method, path, query, headers_str, body} ->
         headers = parse_headers_fast(headers_str)
-        {:ok, %{
-          method: method,
-          path: path,
-          query: query,
-          headers: headers,
-          body: body
-        }}
+
+        {:ok,
+         %{
+           method: method,
+           path: path,
+           query: query,
+           headers: headers,
+           body: body
+         }}
+
       _ ->
         {:error, {:parse_error, result}}
     end
@@ -294,30 +313,40 @@ defmodule Firebird.Phoenix.Plug do
     case :binary.match(data, <<"|">>) do
       {p1, 1} ->
         rest1 = binary_part(data, p1 + 1, byte_size(data) - p1 - 1)
+
         case :binary.match(rest1, <<"|">>) do
           {p2, 1} ->
             rest2 = binary_part(rest1, p2 + 1, byte_size(rest1) - p2 - 1)
+
             case :binary.match(rest2, <<"|">>) do
               {p3, 1} ->
                 rest3 = binary_part(rest2, p3 + 1, byte_size(rest2) - p3 - 1)
+
                 case :binary.match(rest3, <<"|">>) do
                   {p4, 1} ->
-                    {binary_part(data, 0, p1),
-                     binary_part(rest1, 0, p2),
-                     binary_part(rest2, 0, p3),
-                     binary_part(rest3, 0, p4),
+                    {binary_part(data, 0, p1), binary_part(rest1, 0, p2),
+                     binary_part(rest2, 0, p3), binary_part(rest3, 0, p4),
                      binary_part(rest3, p4 + 1, byte_size(rest3) - p4 - 1)}
-                  :nomatch -> nil
+
+                  :nomatch ->
+                    nil
                 end
-              :nomatch -> nil
+
+              :nomatch ->
+                nil
             end
-          :nomatch -> nil
+
+          :nomatch ->
+            nil
         end
-      :nomatch -> nil
+
+      :nomatch ->
+        nil
     end
   end
 
   defp parse_headers_fast(<<>>), do: %{}
+
   defp parse_headers_fast(headers_str) do
     headers_str
     |> :binary.split(<<"\n">>, [:global])
@@ -326,12 +355,14 @@ defmodule Firebird.Phoenix.Plug do
 
   defp parse_header_pairs([], acc), do: acc
   defp parse_header_pairs([<<>> | rest], acc), do: parse_header_pairs(rest, acc)
+
   defp parse_header_pairs([line | rest], acc) do
     case :binary.match(line, <<":">>) do
       {pos, 1} ->
         key = binary_part(line, 0, pos)
         value = String.trim_leading(binary_part(line, pos + 1, byte_size(line) - pos - 1))
         parse_header_pairs(rest, Map.put(acc, key, value))
+
       :nomatch ->
         parse_header_pairs(rest, Map.put(acc, String.trim(line), ""))
     end
diff --git a/lib/firebird/phoenix/rate_limiter.ex b/lib/firebird/phoenix/rate_limiter.ex
index 80843af..ec10f2c 100644
--- a/lib/firebird/phoenix/rate_limiter.ex
+++ b/lib/firebird/phoenix/rate_limiter.ex
@@ -25,23 +25,21 @@ defmodule Firebird.Phoenix.RateLimiter do
   """
 
   @type t :: %__MODULE__{
-    rate: pos_integer(),
-    period_ms: pos_integer(),
-    buckets: %{String.t() => bucket()},
-    max_tokens: pos_integer()
-  }
+          rate: pos_integer(),
+          period_ms: pos_integer(),
+          buckets: %{String.t() => bucket()},
+          max_tokens: pos_integer()
+        }
 
   @type bucket :: %{
-    tokens: float(),
-    last_refill: integer()
-  }
+          tokens: float(),
+          last_refill: integer()
+        }
 
-  defstruct [
-    rate: 100,
-    period_ms: 60_000,
-    buckets: %{},
-    max_tokens: 100
-  ]
+  defstruct rate: 100,
+            period_ms: 60_000,
+            buckets: %{},
+            max_tokens: 100
 
   @doc """
   Create a new rate limiter.
@@ -58,12 +56,13 @@ defmodule Firebird.Phoenix.RateLimiter do
     period = Keyword.get(opts, :period, :minute)
     burst = Keyword.get(opts, :burst, rate)
 
-    period_ms = case period do
-      :second -> 1_000
-      :minute -> 60_000
-      :hour -> 3_600_000
-      ms when is_integer(ms) -> ms
-    end
+    period_ms =
+      case period do
+        :second -> 1_000
+        :minute -> 60_000
+        :hour -> 3_600_000
+        ms when is_integer(ms) -> ms
+      end
 
     %__MODULE__{
       rate: rate,
@@ -86,7 +85,8 @@ defmodule Firebird.Phoenix.RateLimiter do
   - `{:ok, new_limiter, remaining}` - Request allowed, tokens remaining
   - `{:error, :rate_limited, new_limiter, retry_after_ms}` - Rate limited
   """
-  @spec check(t(), String.t()) :: {:ok, t(), non_neg_integer()} | {:error, :rate_limited, t(), non_neg_integer()}
+  @spec check(t(), String.t()) ::
+          {:ok, t(), non_neg_integer()} | {:error, :rate_limited, t(), non_neg_integer()}
   def check(%__MODULE__{} = limiter, key) when is_binary(key) do
     now = System.monotonic_time(:millisecond)
     bucket = get_bucket(limiter, key, now)
@@ -98,7 +98,12 @@ defmodule Firebird.Phoenix.RateLimiter do
     else
       # Calculate when next token will be available
       tokens_per_ms = limiter.rate / limiter.period_ms
-      retry_after = if tokens_per_ms > 0, do: trunc((1.0 - bucket.tokens) / tokens_per_ms), else: limiter.period_ms
+
+      retry_after =
+        if tokens_per_ms > 0,
+          do: trunc((1.0 - bucket.tokens) / tokens_per_ms),
+          else: limiter.period_ms
+
       {:error, :rate_limited, limiter, retry_after}
     end
   end
@@ -160,21 +165,24 @@ defmodule Firebird.Phoenix.RateLimiter do
 
       limiter = Process.get(limiter_key) || initial
 
-      client_key = cond do
-        key_header -> Map.get(conn.req_headers, key_header, "unknown")
-        conn.assigns[:remote_ip] -> conn.assigns[:remote_ip]
-        true -> "unknown"
-      end
+      client_key =
+        cond do
+          key_header -> Map.get(conn.req_headers, key_header, "unknown")
+          conn.assigns[:remote_ip] -> conn.assigns[:remote_ip]
+          true -> "unknown"
+        end
 
       case check(limiter, client_key) do
         {:ok, new_limiter, remaining} ->
           Process.put(limiter_key, new_limiter)
+
           conn
           |> Conn.put_resp_header("x-ratelimit-remaining", to_string(remaining))
           |> Conn.put_resp_header("x-ratelimit-limit", to_string(limiter.rate))
 
         {:error, :rate_limited, new_limiter, retry_after} ->
           Process.put(limiter_key, new_limiter)
+
           conn
           |> Conn.put_status(429)
           |> Conn.put_resp_header("retry-after", to_string(div(retry_after, 1000)))
@@ -194,10 +202,13 @@ defmodule Firebird.Phoenix.RateLimiter do
       bucket ->
         elapsed = now - bucket.last_refill
         tokens_per_ms = limiter.rate / limiter.period_ms
-        new_tokens = min(
-          bucket.tokens + elapsed * tokens_per_ms,
-          limiter.max_tokens * 1.0
-        )
+
+        new_tokens =
+          min(
+            bucket.tokens + elapsed * tokens_per_ms,
+            limiter.max_tokens * 1.0
+          )
+
         %{bucket | tokens: new_tokens, last_refill: now}
     end
   end
diff --git a/lib/firebird/phoenix/rate_limiter_wasm.ex b/lib/firebird/phoenix/rate_limiter_wasm.ex
index 487efa6..be7bfc2 100644
--- a/lib/firebird/phoenix/rate_limiter_wasm.ex
+++ b/lib/firebird/phoenix/rate_limiter_wasm.ex
@@ -42,6 +42,7 @@ defmodule Firebird.Phoenix.RateLimiterWasm do
     burst = Keyword.get(opts, :burst, 100.0)
 
     input = "#{rate}|#{burst}"
+
     case WasmHelper.call_string(instance, "configure", input) do
       {:ok, "ok"} -> :ok
       {:ok, "error|" <> reason} -> {:error, reason}
@@ -75,8 +76,10 @@ defmodule Firebird.Phoenix.RateLimiterWasm do
     case WasmHelper.call_string(instance, "check", client_key) do
       {:ok, "allowed|" <> remaining} ->
         {:ok, :allowed, parse_number(remaining)}
+
       {:ok, "denied|" <> retry_ms} ->
         {:ok, :denied, parse_number(retry_ms)}
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -95,15 +98,18 @@ defmodule Firebird.Phoenix.RateLimiterWasm do
   - `{:ok, :allowed, remaining_tokens}` - Request allowed, tokens consumed
   - `{:ok, :denied, retry_after_ms}` - Rate limited, try again later
   """
-  @spec consume(pid(), String.t(), number()) :: {:ok, :allowed | :denied, number()} | {:error, term()}
+  @spec consume(pid(), String.t(), number()) ::
+          {:ok, :allowed | :denied, number()} | {:error, term()}
   def consume(instance, client_key, count \\ 1) when is_binary(client_key) do
     input = if count == 1, do: client_key, else: "#{client_key}|#{count}"
 
     case WasmHelper.call_string(instance, "consume", input) do
       {:ok, "allowed|" <> remaining} ->
         {:ok, :allowed, parse_number(remaining)}
+
       {:ok, "denied|" <> retry_ms} ->
         {:ok, :denied, parse_number(retry_ms)}
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -142,14 +148,17 @@ defmodule Firebird.Phoenix.RateLimiterWasm do
       {:ok, result} ->
         case String.split(result, "|") do
           [active, rate, burst] ->
-            {:ok, %{
-              active_clients: parse_number(active),
-              rate: parse_number(rate),
-              burst: parse_number(burst)
-            }}
+            {:ok,
+             %{
+               active_clients: parse_number(active),
+               rate: parse_number(rate),
+               burst: parse_number(burst)
+             }}
+
           _ ->
             {:error, :invalid_stats}
         end
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -157,12 +166,14 @@ defmodule Firebird.Phoenix.RateLimiterWasm do
 
   defp parse_number(str) do
     str = String.trim(str)
+
     cond do
       String.contains?(str, ".") ->
         case Float.parse(str) do
           {f, _} -> f
           :error -> 0.0
         end
+
       true ->
         case Integer.parse(str) do
           {i, _} -> i
diff --git a/lib/firebird/phoenix/request_handler.ex b/lib/firebird/phoenix/request_handler.ex
index 66f3bfa..3767a10 100644
--- a/lib/firebird/phoenix/request_handler.ex
+++ b/lib/firebird/phoenix/request_handler.ex
@@ -51,28 +51,26 @@ defmodule Firebird.Phoenix.RequestHandler do
 
   @type action_fn :: (map() -> {integer(), String.t(), String.t()})
   @type t :: %__MODULE__{
-    routes: [{String.t(), String.t(), String.t()}],
-    actions: %{String.t() => action_fn()},
-    templates: %{String.t() => {integer(), String.t(), String.t()}},
-    middleware: Middleware.t(),
-    pipelines: %{atom() => [String.t()]},
-    active_pipelines: [atom()],
-    components: map() | nil,
-    error_handler: ErrorHandler.t(),
-    routes_compiled: boolean()
-  }
-
-  defstruct [
-    routes: [],
-    actions: %{},
-    templates: %{},
-    middleware: %Middleware{},
-    pipelines: %{},
-    active_pipelines: [],
-    components: nil,
-    error_handler: %ErrorHandler{},
-    routes_compiled: false
-  ]
+          routes: [{String.t(), String.t(), String.t()}],
+          actions: %{String.t() => action_fn()},
+          templates: %{String.t() => {integer(), String.t(), String.t()}},
+          middleware: Middleware.t(),
+          pipelines: %{atom() => [String.t()]},
+          active_pipelines: [atom()],
+          components: map() | nil,
+          error_handler: ErrorHandler.t(),
+          routes_compiled: boolean()
+        }
+
+  defstruct routes: [],
+            actions: %{},
+            templates: %{},
+            middleware: %Middleware{},
+            pipelines: %{},
+            active_pipelines: [],
+            components: nil,
+            error_handler: %ErrorHandler{},
+            routes_compiled: false
 
   @doc """
   Create a new request handler with WASM components.
@@ -87,19 +85,23 @@ defmodule Firebird.Phoenix.RequestHandler do
     components = Keyword.get(opts, :components)
     format = Keyword.get(opts, :format, :json)
 
-    components = case components do
-      nil ->
-        case Firebird.Phoenix.start(only: [:router, :endpoint, :template, :json]) do
-          {:ok, c} -> c
-          {:error, _} -> %{}
-        end
-      c -> c
-    end
+    components =
+      case components do
+        nil ->
+          case Firebird.Phoenix.start(only: [:router, :endpoint, :template, :json]) do
+            {:ok, c} -> c
+            {:error, _} -> %{}
+          end
+
+        c ->
+          c
+      end
 
-    {:ok, %__MODULE__{
-      components: components,
-      error_handler: ErrorHandler.new(format: format)
-    }}
+    {:ok,
+     %__MODULE__{
+       components: components,
+       error_handler: ErrorHandler.new(format: format)
+     }}
   end
 
   @doc """
@@ -115,7 +117,11 @@ defmodule Firebird.Phoenix.RequestHandler do
   """
   @spec route(t(), String.t(), String.t(), String.t()) :: t()
   def route(%__MODULE__{} = handler, method, pattern, action_name) do
-    %{handler | routes: handler.routes ++ [{method, pattern, action_name}], routes_compiled: false}
+    %{
+      handler
+      | routes: handler.routes ++ [{method, pattern, action_name}],
+        routes_compiled: false
+    }
   end
 
   @doc """
@@ -148,6 +154,7 @@ defmodule Firebird.Phoenix.RequestHandler do
       case Firebird.Phoenix.Router.compile(router, routes) do
         {:ok, _count} ->
           {:ok, %{handler | routes_compiled: true}}
+
         {:error, reason} ->
           {:error, reason}
       end
@@ -237,8 +244,7 @@ defmodule Firebird.Phoenix.RequestHandler do
                 dispatch_action(handler, conn, action_name)
 
               {:ok, :not_found} ->
-                {:ok, Conn.send_resp(conn, 404,
-                  ErrorHandler.render(handler.error_handler, 404))}
+                {:ok, Conn.send_resp(conn, 404, ErrorHandler.render(handler.error_handler, 404))}
 
               {:error, reason} ->
                 {:error, reason}
@@ -255,10 +261,15 @@ defmodule Firebird.Phoenix.RequestHandler do
   # the WASM Endpoint.execute_pipeline in a single call, and merges the
   # resulting response headers/assigns/status back into the Conn.
   defp execute_active_pipelines(%__MODULE__{active_pipelines: []}, conn), do: {:ok, conn}
-  defp execute_active_pipelines(%__MODULE__{active_pipelines: names, pipelines: pipelines, components: components}, conn) do
-    all_plugs = Enum.flat_map(names, fn name ->
-      Map.get(pipelines, name, [])
-    end)
+
+  defp execute_active_pipelines(
+         %__MODULE__{active_pipelines: names, pipelines: pipelines, components: components},
+         conn
+       ) do
+    all_plugs =
+      Enum.flat_map(names, fn name ->
+        Map.get(pipelines, name, [])
+      end)
 
     if all_plugs == [] do
       {:ok, conn}
@@ -302,12 +313,17 @@ defmodule Firebird.Phoenix.RequestHandler do
   defp maybe_put(conn, _field, _val), do: conn
 
   defp merge_map_field(conn, _field, new_map) when map_size(new_map) == 0, do: conn
+
   defp merge_map_field(conn, field, new_map) do
     existing = Map.get(conn, field, %{})
     Map.put(conn, field, Map.merge(existing, new_map))
   end
 
-  defp match_route(%__MODULE__{components: components, routes: routes, routes_compiled: compiled}, method, path) do
+  defp match_route(
+         %__MODULE__{components: components, routes: routes, routes_compiled: compiled},
+         method,
+         path
+       ) do
     router = Map.get(components || %{}, :router)
 
     if router do
@@ -330,6 +346,7 @@ defmodule Firebird.Phoenix.RequestHandler do
     Enum.find_value(routes, {:ok, :not_found}, fn {route_method, pattern, handler_name} ->
       if route_method == "*" || route_method == method do
         pattern_segments = String.split(pattern, "/", trim: true)
+
         case match_segments(pattern_segments, path_segments) do
           {:ok, params} -> {:ok, %{handler: handler_name, params: params}}
           :no_match -> nil
@@ -340,12 +357,14 @@ defmodule Firebird.Phoenix.RequestHandler do
 
   defp match_segments([], []), do: {:ok, %{}}
   defp match_segments(["*" | _], rest), do: {:ok, %{"glob" => Enum.join(rest, "/")}}
+
   defp match_segments([":" <> name | ps], [s | ss]) do
     case match_segments(ps, ss) do
       {:ok, params} -> {:ok, Map.put(params, name, s)}
       :no_match -> :no_match
     end
   end
+
   defp match_segments([p | ps], [s | ss]) when p == s, do: match_segments(ps, ss)
   defp match_segments(_, _), do: :no_match
 
@@ -354,23 +373,32 @@ defmodule Firebird.Phoenix.RequestHandler do
       # Dynamic action function
       fun = Map.get(handler.actions, action_name) ->
         {status, content_type, body} = fun.(conn.params)
-        {:ok, conn
-          |> Conn.put_status(status)
-          |> Conn.put_resp_header("content-type", content_type)
-          |> Conn.put_resp_body(render_template_body(handler, body, conn.params))}
+
+        {:ok,
+         conn
+         |> Conn.put_status(status)
+         |> Conn.put_resp_header("content-type", content_type)
+         |> Conn.put_resp_body(render_template_body(handler, body, conn.params))}
 
       # Static template
       template = Map.get(handler.templates, action_name) ->
         {status, content_type, body} = template
-        {:ok, conn
-          |> Conn.put_status(status)
-          |> Conn.put_resp_header("content-type", content_type)
-          |> Conn.put_resp_body(render_template_body(handler, body, conn.params))}
+
+        {:ok,
+         conn
+         |> Conn.put_status(status)
+         |> Conn.put_resp_header("content-type", content_type)
+         |> Conn.put_resp_body(render_template_body(handler, body, conn.params))}
 
       true ->
-        {:ok, Conn.send_resp(conn, 500,
-          ErrorHandler.render(handler.error_handler, 500,
-            %{"message" => "No action defined for #{action_name}"}))}
+        {:ok,
+         Conn.send_resp(
+           conn,
+           500,
+           ErrorHandler.render(handler.error_handler, 500, %{
+             "message" => "No action defined for #{action_name}"
+           })
+         )}
     end
   end
 
@@ -415,6 +443,7 @@ defmodule Firebird.Phoenix.RequestHandler do
   # On failure, silently falls back to per-request match/4.
   defp maybe_auto_compile_routes(%__MODULE__{routes_compiled: true} = handler), do: handler
   defp maybe_auto_compile_routes(%__MODULE__{routes: []} = handler), do: handler
+
   defp maybe_auto_compile_routes(%__MODULE__{} = handler) do
     case compile_routes(handler) do
       {:ok, compiled_handler} -> compiled_handler
diff --git a/lib/firebird/phoenix/router.ex b/lib/firebird/phoenix/router.ex
index d71ea82..54a0252 100644
--- a/lib/firebird/phoenix/router.ex
+++ b/lib/firebird/phoenix/router.ex
@@ -72,9 +72,11 @@ defmodule Firebird.Phoenix.Router do
   def compile(instance, routes) when is_list(routes) do
     ensure_compiled_table()
 
-    route_lines = Enum.map(routes, fn {m, pattern, handler} ->
-      "#{m}|#{pattern}|#{handler}"
-    end)
+    route_lines =
+      Enum.map(routes, fn {m, pattern, handler} ->
+        "#{m}|#{pattern}|#{handler}"
+      end)
+
     input = Enum.join(route_lines, "\n")
 
     # Fast path: SyncNif reference
@@ -82,15 +84,18 @@ defmodule Firebird.Phoenix.Router do
       {:ok, count} ->
         :ets.insert(@compiled_table, {instance, true})
         {:ok, count}
+
       {:error, :use_wasmex_path} ->
         # Wasmex PID path
         case write_and_call_compile(instance, input) do
           {:ok, count} ->
             :ets.insert(@compiled_table, {instance, true})
             {:ok, count}
+
           {:error, reason} ->
             {:error, reason}
         end
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -117,12 +122,18 @@ defmodule Firebird.Phoenix.Router do
   # Method string to integer mapping for match_method fast path
   # Must match the Rust Method enum: GET=0, POST=1, PUT=2, DELETE=3, PATCH=4, HEAD=5, OPTIONS=6, ANY=7
   @method_ids %{
-    "GET" => 0, "POST" => 1, "PUT" => 2, "DELETE" => 3,
-    "PATCH" => 4, "HEAD" => 5, "OPTIONS" => 6, "*" => 7
+    "GET" => 0,
+    "POST" => 1,
+    "PUT" => 2,
+    "DELETE" => 3,
+    "PATCH" => 4,
+    "HEAD" => 5,
+    "OPTIONS" => 6,
+    "*" => 7
   }
 
   @spec match_compiled(pid() | reference(), String.t(), String.t()) ::
-    {:ok, %{handler: String.t(), params: map()}} | {:ok, :not_found} | {:error, term()}
+          {:ok, %{handler: String.t(), params: map()}} | {:ok, :not_found} | {:error, term()}
   def match_compiled(instance, method, path) when is_binary(method) and is_binary(path) do
     # Fast path: use match_method with integer method arg
     # Avoids: string concatenation, memchr to find space, method string parsing
@@ -130,6 +141,7 @@ defmodule Firebird.Phoenix.Router do
       nil ->
         # Unknown method: fall back to string-based match_compiled
         input = IO.iodata_to_binary([method, " ", path])
+
         case FastHelper.call_string(instance, "match_compiled", input) do
           {:ok, result} -> parse_match_result(result)
           {:error, reason} -> {:error, reason}
@@ -163,9 +175,11 @@ defmodule Firebird.Phoenix.Router do
           {:ok, ctx} ->
             Process.put({:firebird_wasm_ctx, instance}, ctx)
             do_call_match_method(method_id, path, ctx)
+
           {:error, reason} ->
             {:error, reason}
         end
+
       ctx ->
         do_call_match_method(method_id, path, ctx)
     end
@@ -189,21 +203,29 @@ defmodule Firebird.Phoenix.Router do
     ref = make_ref()
     from = {self(), ref}
 
-    :ok = Wasmex.Native.instance_call_exported_function(
-      store_resource,
-      instance_resource,
-      "match_method",
-      [method_id, input_ptr, input_len, output_ptr],
-      from
-    )
+    :ok =
+      Wasmex.Native.instance_call_exported_function(
+        store_resource,
+        instance_resource,
+        "match_method",
+        [method_id, input_ptr, input_len, output_ptr],
+        from
+      )
 
     receive do
       {^ref, {:ok, [output_len]}} ->
         if output_len == 0 do
           {:ok, ""}
         else
-          {:ok, Wasmex.Native.memory_read_binary(store_resource, memory_resource, output_ptr, output_len)}
+          {:ok,
+           Wasmex.Native.memory_read_binary(
+             store_resource,
+             memory_resource,
+             output_ptr,
+             output_len
+           )}
         end
+
       {^ref, {:error, reason}} ->
         {:error, reason}
     after
@@ -228,19 +250,23 @@ defmodule Firebird.Phoenix.Router do
   - `{:ok, [result]}` - List of match results (same order as requests)
   """
   @spec match_batch(pid() | reference(), list({String.t(), String.t()})) ::
-    {:ok, list({:ok, map()} | {:ok, :not_found})} | {:error, term()}
+          {:ok, list({:ok, map()} | {:ok, :not_found})} | {:error, term()}
   def match_batch(instance, requests) when is_list(requests) do
-    input = requests
+    input =
+      requests
       |> Enum.map(fn {method, path} -> [method, " ", path] end)
       |> Enum.intersperse("\n")
       |> IO.iodata_to_binary()
 
     case FastHelper.call_string(instance, "match_batch", input) do
       {:ok, result} ->
-        results = result
+        results =
+          result
           |> :binary.split(<<0>>, [:global])
           |> Enum.map(&parse_match_result/1)
+
         {:ok, results}
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -263,22 +289,25 @@ defmodule Firebird.Phoenix.Router do
   - `{:error, reason}` - Error during matching
   """
   @spec match(pid() | reference(), String.t(), String.t(), list()) ::
-    {:ok, %{handler: String.t(), params: map()}} | {:ok, :not_found} | {:error, term()}
-  def match(instance, method, path, routes) when is_binary(method) and is_binary(path) and is_list(routes) do
+          {:ok, %{handler: String.t(), params: map()}} | {:ok, :not_found} | {:error, term()}
+  def match(instance, method, path, routes)
+      when is_binary(method) and is_binary(path) and is_list(routes) do
     # Empty routes always means not found
     if routes == [] do
       {:ok, :not_found}
     else
       # Build input using IO lists to avoid intermediate string allocations
-      route_iodata = Enum.map(routes, fn {m, pattern, handler} ->
-        ["\n", m, "|", pattern, "|", handler]
-      end)
+      route_iodata =
+        Enum.map(routes, fn {m, pattern, handler} ->
+          ["\n", m, "|", pattern, "|", handler]
+        end)
 
       input = IO.iodata_to_binary([method, " ", path | route_iodata])
 
       case FastHelper.call_string(instance, "match_route", input) do
         {:ok, result} ->
           parse_match_result(result)
+
         {:error, reason} ->
           {:error, reason}
       end
@@ -310,7 +339,9 @@ defmodule Firebird.Phoenix.Router do
     case :ets.whereis(@compiled_table) do
       :undefined ->
         :ets.new(@compiled_table, [:named_table, :public, :set])
-      _ -> :ok
+
+      _ ->
+        :ok
     end
   rescue
     ArgumentError -> :ok
@@ -329,14 +360,19 @@ defmodule Firebird.Phoenix.Router do
     case FastHelper.call_string(instance, "parse_query_string", query_string) do
       {:ok, ""} ->
         {:ok, %{}}
+
       {:ok, result} ->
         # Result is null-separated key\0value\0key\0value
         parts = String.split(result, <<0>>)
-        params = parts
+
+        params =
+          parts
           |> Enum.chunk_every(2)
           |> Enum.filter(&(length(&1) == 2))
           |> Enum.into(%{}, fn [k, v] -> {k, v} end)
+
         {:ok, params}
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -367,6 +403,7 @@ defmodule Firebird.Phoenix.Router do
         params_str = binary_part(rest, pos + 1, byte_size(rest) - pos - 1)
         params = parse_params_fast(params_str)
         {:ok, %{handler: handler, params: params}}
+
       :nomatch ->
         {:ok, %{handler: rest, params: %{}}}
     end
@@ -376,6 +413,7 @@ defmodule Firebird.Phoenix.Router do
 
   # Fast params parsing using :binary.split (single pass, no intermediate lists)
   defp parse_params_fast(<<>>), do: %{}
+
   defp parse_params_fast(params_str) do
     params_str
     |> :binary.split(<<"&">>, [:global])
@@ -384,12 +422,14 @@ defmodule Firebird.Phoenix.Router do
 
   defp parse_pairs_into_map([], acc), do: acc
   defp parse_pairs_into_map([<<>> | rest], acc), do: parse_pairs_into_map(rest, acc)
+
   defp parse_pairs_into_map([pair | rest], acc) do
     case :binary.match(pair, <<"=">>) do
       {pos, 1} ->
         key = binary_part(pair, 0, pos)
         value = binary_part(pair, pos + 1, byte_size(pair) - pos - 1)
         parse_pairs_into_map(rest, Map.put(acc, key, value))
+
       :nomatch ->
         parse_pairs_into_map(rest, Map.put(acc, pair, ""))
     end
diff --git a/lib/firebird/phoenix/router_dsl.ex b/lib/firebird/phoenix/router_dsl.ex
index 42e7ced..1f7e780 100644
--- a/lib/firebird/phoenix/router_dsl.ex
+++ b/lib/firebird/phoenix/router_dsl.ex
@@ -47,12 +47,21 @@ defmodule Firebird.Phoenix.RouterDSL do
 
   defmacro __using__(_opts) do
     quote do
-      import Firebird.Phoenix.RouterDSL, only: [
-        pipeline: 2, scope: 2, scope: 3,
-        get: 2, post: 2, put: 2, patch: 2, delete: 2,
-        plug: 1, resources: 2, resources: 3,
-        add_route: 3
-      ]
+      import Firebird.Phoenix.RouterDSL,
+        only: [
+          pipeline: 2,
+          scope: 2,
+          scope: 3,
+          get: 2,
+          post: 2,
+          put: 2,
+          patch: 2,
+          delete: 2,
+          plug: 1,
+          resources: 2,
+          resources: 3,
+          add_route: 3
+        ]
 
       Module.register_attribute(__MODULE__, :firebird_routes, accumulate: true)
       Module.register_attribute(__MODULE__, :firebird_pipelines, accumulate: true)
@@ -173,12 +182,19 @@ defmodule Firebird.Phoenix.RouterDSL do
   defmacro add_route(method, path, handler) do
     quote do
       scope = Module.get_attribute(__MODULE__, :firebird_current_scope) || ""
-      full_path = case {scope, unquote(path)} do
-        {"", path} -> path
-        {"/", path} -> path
-        {scope, path} -> String.trim_trailing(scope, "/") <> path
-      end
-      Module.put_attribute(__MODULE__, :firebird_routes, {unquote(method), full_path, unquote(handler)})
+
+      full_path =
+        case {scope, unquote(path)} do
+          {"", path} -> path
+          {"/", path} -> path
+          {scope, path} -> String.trim_trailing(scope, "/") <> path
+        end
+
+      Module.put_attribute(
+        __MODULE__,
+        :firebird_routes,
+        {unquote(method), full_path, unquote(handler)}
+      )
     end
   end
 end
diff --git a/lib/firebird/phoenix/server.ex b/lib/firebird/phoenix/server.ex
index bb46dfe..ef20711 100644
--- a/lib/firebird/phoenix/server.ex
+++ b/lib/firebird/phoenix/server.ex
@@ -91,7 +91,6 @@ defmodule Firebird.Phoenix.Server do
   @keepalive_timeout 15_000
   @max_keepalive_requests 100
 
-
   defstruct [
     :port,
     :listen_socket,
@@ -171,18 +170,21 @@ defmodule Firebird.Phoenix.Server do
     backlog = Keyword.get(opts, :backlog, @default_backlog)
 
     # Start or reuse WASM components
-    {components, owns} = case Keyword.get(opts, :components) do
-      nil ->
-        case Firebird.Phoenix.start(only: [:router, :template, :plug, :endpoint, :json]) do
-          {:ok, c} -> {c, true}
-          {:error, reason} -> throw({:error, {:components_failed, reason}})
-        end
-      c ->
-        {c, false}
-    end
+    {components, owns} =
+      case Keyword.get(opts, :components) do
+        nil ->
+          case Firebird.Phoenix.start(only: [:router, :template, :plug, :endpoint, :json]) do
+            {:ok, c} -> {c, true}
+            {:error, reason} -> throw({:error, {:components_failed, reason}})
+          end
+
+        c ->
+          {c, false}
+      end
 
     # Pre-compile routes if router is available
     router = Map.get(components, :router)
+
     if router do
       Firebird.Phoenix.Router.compile(router, routes)
     end
@@ -262,6 +264,7 @@ defmodule Firebird.Phoenix.Server do
   @impl true
   def handle_call(:stats, _from, state) do
     uptime = System.monotonic_time(:millisecond) - (state.started_at || 0)
+
     stats = %{
       port: state.port,
       request_count: state.request_count,
@@ -269,6 +272,7 @@ defmodule Firebird.Phoenix.Server do
       uptime_ms: uptime,
       components: Firebird.Phoenix.info(state.components)
     }
+
     {:reply, stats, state}
   end
 
@@ -282,9 +286,11 @@ defmodule Firebird.Phoenix.Server do
     if state.listen_socket do
       :gen_tcp.close(state.listen_socket)
     end
+
     if state.owns_components do
       Firebird.Phoenix.stop(state.components)
     end
+
     :ok
   end
 
@@ -295,10 +301,13 @@ defmodule Firebird.Phoenix.Server do
       {:ok, client_socket} ->
         send(server, {:accepted, client_socket})
         accept_loop(server, listen_socket)
+
       {:error, :timeout} ->
         accept_loop(server, listen_socket)
+
       {:error, :closed} ->
         :ok
+
       {:error, _reason} ->
         accept_loop(server, listen_socket)
     end
@@ -307,7 +316,14 @@ defmodule Firebird.Phoenix.Server do
   # ── Connection Handler ──────────────────────────────────
 
   defp handle_connection(socket, components, routes, actions, pipelines) do
-    handle_connection_loop(socket, components, routes, actions, pipelines, @max_keepalive_requests)
+    handle_connection_loop(
+      socket,
+      components,
+      routes,
+      actions,
+      pipelines,
+      @max_keepalive_requests
+    )
   end
 
   # Keep-Alive connection loop: reuse the TCP connection for multiple requests
@@ -341,7 +357,11 @@ defmodule Firebird.Phoenix.Server do
   # HTTP/1.1 defaults to keep-alive; only close if explicitly requested.
   defp connection_keep_alive?(raw_request) when is_binary(raw_request) do
     # Fast scan for "Connection:" header using binary matching
-    case :binary.match(raw_request, [<<"connection: close">>, <<"Connection: close">>, <<"Connection: Close">>]) do
+    case :binary.match(raw_request, [
+           <<"connection: close">>,
+           <<"Connection: close">>,
+           <<"Connection: Close">>
+         ]) do
       {_pos, _len} -> false
       :nomatch -> true
     end
@@ -354,21 +374,24 @@ defmodule Firebird.Phoenix.Server do
     plug = Map.get(components, :plug)
 
     # Try endpoint dispatch first (full pipeline), fall back to component-level dispatch
-    result = if endpoint do
-      case Firebird.Phoenix.Endpoint.dispatch(endpoint, raw_request, routes, actions) do
-        {:ok, response} -> {:ok, response}
-        {:error, _} -> fallback_dispatch(raw_request, router, template, plug, routes, actions)
+    result =
+      if endpoint do
+        case Firebird.Phoenix.Endpoint.dispatch(endpoint, raw_request, routes, actions) do
+          {:ok, response} -> {:ok, response}
+          {:error, _} -> fallback_dispatch(raw_request, router, template, plug, routes, actions)
+        end
+      else
+        fallback_dispatch(raw_request, router, template, plug, routes, actions)
       end
-    else
-      fallback_dispatch(raw_request, router, template, plug, routes, actions)
-    end
 
     case result do
       {:ok, response} when is_binary(response) or is_list(response) ->
         response
+
       {:ok, %{status: status, body: body} = resp} ->
         content_type = Map.get(resp, :content_type, "text/plain")
         build_raw_response(status, content_type, body, keep_alive?)
+
       {:error, _reason} ->
         build_raw_response(500, "text/plain", "Internal Server Error", keep_alive?)
     end
@@ -379,16 +402,19 @@ defmodule Firebird.Phoenix.Server do
 
     if router do
       # Try compiled routes first, fall back to uncompiled match
-      match_result = case Firebird.Phoenix.Router.match_compiled(router, method, path) do
-        {:error, _} -> Firebird.Phoenix.Router.match(router, method, path, routes)
-        other -> other
-      end
+      match_result =
+        case Firebird.Phoenix.Router.match_compiled(router, method, path) do
+          {:error, _} -> Firebird.Phoenix.Router.match(router, method, path, routes)
+          other -> other
+        end
 
       case match_result do
         {:ok, %{handler: handler, params: params}} ->
           dispatch_action(handler, params, actions, template, plug)
+
         {:ok, :not_found} ->
           {:ok, build_raw_response(404, "text/plain", "Not Found", false)}
+
         {:error, _} ->
           {:ok, build_raw_response(500, "text/plain", "Router Error", false)}
       end
@@ -456,12 +482,16 @@ defmodule Firebird.Phoenix.Server do
       {method_end, 1} ->
         method = binary_part(raw, 0, method_end)
         rest = binary_part(raw, method_end + 1, byte_size(raw) - method_end - 1)
-        path_end = case :binary.match(rest, [<<" ">>, <<"\r">>, <<"\n">>]) do
-          {pos, _} -> pos
-          :nomatch -> byte_size(rest)
-        end
+
+        path_end =
+          case :binary.match(rest, [<<" ">>, <<"\r">>, <<"\n">>]) do
+            {pos, _} -> pos
+            :nomatch -> byte_size(rest)
+          end
+
         path = binary_part(rest, 0, path_end)
         {method, path}
+
       :nomatch ->
         {"GET", "/"}
     end
@@ -476,10 +506,20 @@ defmodule Firebird.Phoenix.Server do
     # IO list avoids intermediate binary allocations on the hot path.
     # :gen_tcp.send/2 accepts iodata natively, so no final flatten needed.
     [
-      "HTTP/1.1 ", Integer.to_string(status), " ", status_text, "\r\n",
-      "Content-Type: ", content_type, "\r\n",
-      "Content-Length: ", content_length, "\r\n",
-      "Connection: ", connection_header, "\r\n",
+      "HTTP/1.1 ",
+      Integer.to_string(status),
+      " ",
+      status_text,
+      "\r\n",
+      "Content-Type: ",
+      content_type,
+      "\r\n",
+      "Content-Length: ",
+      content_length,
+      "\r\n",
+      "Connection: ",
+      connection_header,
+      "\r\n",
       "Server: Firebird/Phoenix-WASM\r\n",
       "\r\n",
       body_bytes
@@ -513,14 +553,17 @@ defmodule Firebird.Phoenix.Server do
     case :gen_tcp.connect(to_charlist(host), port, [:binary, active: false], 5000) do
       {:ok, socket} ->
         :gen_tcp.send(socket, request)
+
         case recv_all(socket, <<>>) do
           {:ok, response} ->
             :gen_tcp.close(socket)
             {:ok, parse_response(response)}
+
           {:error, reason} ->
             :gen_tcp.close(socket)
             {:error, reason}
         end
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -539,12 +582,14 @@ defmodule Firebird.Phoenix.Server do
       [header_section, body] ->
         [status_line | header_lines] = String.split(header_section, "\r\n")
 
-        status = case Regex.run(~r/HTTP\/\d\.\d (\d+)/, status_line) do
-          [_, code] -> String.to_integer(code)
-          _ -> 0
-        end
+        status =
+          case Regex.run(~r/HTTP\/\d\.\d (\d+)/, status_line) do
+            [_, code] -> String.to_integer(code)
+            _ -> 0
+          end
 
-        headers = header_lines
+        headers =
+          header_lines
           |> Enum.reduce(%{}, fn line, acc ->
             case String.split(line, ": ", parts: 2) do
               [k, v] -> Map.put(acc, String.downcase(k), v)
diff --git a/lib/firebird/phoenix/static.ex b/lib/firebird/phoenix/static.ex
index dfa8f6d..4f993fe 100644
--- a/lib/firebird/phoenix/static.ex
+++ b/lib/firebird/phoenix/static.ex
@@ -24,11 +24,11 @@ defmodule Firebird.Phoenix.Static do
   alias Firebird.Phoenix.Conn
 
   @type t :: %__MODULE__{
-    files: %{String.t() => {String.t(), binary()}},
-    etags: %{String.t() => String.t()},
-    prefix: String.t(),
-    max_age: integer()
-  }
+          files: %{String.t() => {String.t(), binary()}},
+          etags: %{String.t() => String.t()},
+          prefix: String.t(),
+          max_age: integer()
+        }
 
   defstruct files: %{}, etags: %{}, prefix: "", max_age: 86400
 
@@ -76,9 +76,10 @@ defmodule Firebird.Phoenix.Static do
     content_type = detect_content_type(path)
     etag = generate_etag(content)
 
-    %{static |
-      files: Map.put(static.files, path, {content_type, content}),
-      etags: Map.put(static.etags, path, etag)
+    %{
+      static
+      | files: Map.put(static.files, path, {content_type, content}),
+        etags: Map.put(static.etags, path, etag)
     }
   end
 
@@ -89,9 +90,10 @@ defmodule Firebird.Phoenix.Static do
   def put(%__MODULE__{} = static, path, content_type, content) do
     etag = generate_etag(content)
 
-    %{static |
-      files: Map.put(static.files, path, {content_type, content}),
-      etags: Map.put(static.etags, path, etag)
+    %{
+      static
+      | files: Map.put(static.files, path, {content_type, content}),
+        etags: Map.put(static.etags, path, etag)
     }
   end
 
@@ -125,11 +127,12 @@ defmodule Firebird.Phoenix.Static do
   @spec serve(t(), String.t(), map()) :: {:ok, Conn.t()}
   def serve(%__MODULE__{} = static, path, req_headers \\ %{}) do
     # Try both with and without prefix stripping
-    stripped_path = if static.prefix != "" and String.starts_with?(path, static.prefix) do
-      String.replace_prefix(path, static.prefix, "")
-    else
-      path
-    end
+    stripped_path =
+      if static.prefix != "" and String.starts_with?(path, static.prefix) do
+        String.replace_prefix(path, static.prefix, "")
+      else
+        path
+      end
 
     case Map.get(static.files, path) || Map.get(static.files, stripped_path) do
       nil ->
@@ -142,18 +145,20 @@ defmodule Firebird.Phoenix.Static do
         if_none_match = Map.get(req_headers, "if-none-match", "")
 
         if if_none_match != "" and if_none_match == "\"#{etag}\"" do
-          {:ok, Conn.new("GET", path)
-            |> Conn.put_status(304)
-            |> Conn.put_resp_header("etag", "\"#{etag}\"")
-            |> Conn.put_resp_body("")}
+          {:ok,
+           Conn.new("GET", path)
+           |> Conn.put_status(304)
+           |> Conn.put_resp_header("etag", "\"#{etag}\"")
+           |> Conn.put_resp_body("")}
         else
-          {:ok, Conn.new("GET", path)
-            |> Conn.put_status(200)
-            |> Conn.put_resp_header("content-type", content_type)
-            |> Conn.put_resp_header("content-length", "#{byte_size(content)}")
-            |> Conn.put_resp_header("etag", "\"#{etag}\"")
-            |> Conn.put_resp_header("cache-control", "public, max-age=#{static.max_age}")
-            |> Conn.put_resp_body(content)}
+          {:ok,
+           Conn.new("GET", path)
+           |> Conn.put_status(200)
+           |> Conn.put_resp_header("content-type", content_type)
+           |> Conn.put_resp_header("content-length", "#{byte_size(content)}")
+           |> Conn.put_resp_header("etag", "\"#{etag}\"")
+           |> Conn.put_resp_header("cache-control", "public, max-age=#{static.max_age}")
+           |> Conn.put_resp_body(content)}
         end
     end
   end
diff --git a/lib/firebird/phoenix/telemetry.ex b/lib/firebird/phoenix/telemetry.ex
index 81b3683..f4e5c5a 100644
--- a/lib/firebird/phoenix/telemetry.ex
+++ b/lib/firebird/phoenix/telemetry.ex
@@ -86,7 +86,8 @@ defmodule Firebird.Phoenix.Telemetry do
     :ets.update_counter(@table, route_key, {2, 1}, {route_key, 0})
 
     # Latency tracking
-    latency_int = trunc(latency_us * 10)  # Store as integer for precision
+    # Store as integer for precision
+    latency_int = trunc(latency_us * 10)
     timestamp = System.monotonic_time(:microsecond)
     :ets.insert(@latencies_table, {{timestamp, latency_int}, path, status})
 
@@ -161,25 +162,29 @@ defmodule Firebird.Phoenix.Telemetry do
 
     request_count = get_counter(:request_count)
     latency_sum = get_counter(:latency_sum)
-    start_time = case :ets.lookup(@table, :start_time) do
-      [{_, t}] -> t
-      [] -> System.monotonic_time(:microsecond)
-    end
+
+    start_time =
+      case :ets.lookup(@table, :start_time) do
+        [{_, t}] -> t
+        [] -> System.monotonic_time(:microsecond)
+      end
 
     avg_latency = if request_count > 0, do: latency_sum / (request_count * 10.0), else: 0.0
 
     # Collect status codes
-    status_codes = :ets.match(@table, {{:status, :"$1"}, :"$2"})
-    |> Enum.into(%{}, fn [code, count] -> {code, count} end)
+    status_codes =
+      :ets.match(@table, {{:status, :"$1"}, :"$2"})
+      |> Enum.into(%{}, fn [code, count] -> {code, count} end)
 
     # Collect WASM call metrics
-    wasm_calls = :ets.match(@table, {{:wasm, :"$1", :"$2"}, :"$3"})
-    |> Enum.map(fn [comp, func, count] ->
-      latency_key = {:wasm_latency, comp, func}
-      total_latency = get_counter(latency_key)
-      avg = if count > 0, do: Float.round(total_latency / (count * 10.0), 1), else: 0.0
-      %{component: comp, function: func, count: count, avg_us: avg}
-    end)
+    wasm_calls =
+      :ets.match(@table, {{:wasm, :"$1", :"$2"}, :"$3"})
+      |> Enum.map(fn [comp, func, count] ->
+        latency_key = {:wasm_latency, comp, func}
+        total_latency = get_counter(latency_key)
+        avg = if count > 0, do: Float.round(total_latency / (count * 10.0), 1), else: 0.0
+        %{component: comp, function: func, count: count, avg_us: avg}
+      end)
 
     uptime = (System.monotonic_time(:microsecond) - start_time) / 1_000_000
 
@@ -215,9 +220,10 @@ defmodule Firebird.Phoenix.Telemetry do
   def percentiles do
     ensure_started()
 
-    latencies = :ets.tab2list(@latencies_table)
-    |> Enum.map(fn {{_, lat}, _, _} -> lat / 10.0 end)
-    |> Enum.sort()
+    latencies =
+      :ets.tab2list(@latencies_table)
+      |> Enum.map(fn {{_, lat}, _, _} -> lat / 10.0 end)
+      |> Enum.sort()
 
     count = length(latencies)
 
@@ -244,6 +250,7 @@ defmodule Firebird.Phoenix.Telemetry do
       :ets.delete_all_objects(@latencies_table)
       :ets.insert(@table, {:start_time, System.monotonic_time(:microsecond)})
     end
+
     :ok
   end
 
@@ -269,7 +276,9 @@ defmodule Firebird.Phoenix.Telemetry do
   @spec finish_request(Firebird.Phoenix.Conn.t()) :: :ok
   def finish_request(conn) do
     case conn.assigns[:telemetry_start] do
-      nil -> :ok
+      nil ->
+        :ok
+
       start_time ->
         latency = System.monotonic_time(:microsecond) - start_time
         record_request(conn.path, conn.status, latency)
diff --git a/lib/firebird/phoenix/template.ex b/lib/firebird/phoenix/template.ex
index 1582b03..644bdee 100644
--- a/lib/firebird/phoenix/template.ex
+++ b/lib/firebird/phoenix/template.ex
@@ -57,13 +57,19 @@ defmodule Firebird.Phoenix.Template do
     single_line_template = String.replace(template, "\n", " ")
 
     # Use IO lists to avoid intermediate string allocations
-    input = case map_size(assigns) do
-      0 -> single_line_template
-      _ ->
-        assign_iodata = assigns
-          |> Enum.map(fn {key, value} -> ["\n", key, "=", value] end)
-        IO.iodata_to_binary([single_line_template | assign_iodata])
-    end
+    input =
+      case map_size(assigns) do
+        0 ->
+          single_line_template
+
+        _ ->
+          assign_iodata =
+            assigns
+            |> Enum.map(fn {key, value} -> ["\n", key, "=", value] end)
+
+          IO.iodata_to_binary([single_line_template | assign_iodata])
+      end
+
     FastHelper.call_string(instance, "render_template", input)
   end
 
@@ -82,14 +88,21 @@ defmodule Firebird.Phoenix.Template do
       # => {:ok, "<div><strong>Bold</strong></div>"}
   """
   @spec render_raw(pid(), String.t(), map()) :: {:ok, String.t()} | {:error, term()}
-  def render_raw(instance, template, assigns \\ %{}) when is_binary(template) and is_map(assigns) do
-    input = case map_size(assigns) do
-      0 -> template
-      _ ->
-        assign_iodata = assigns
-          |> Enum.map(fn {key, value} -> ["\n", key, "=", value] end)
-        IO.iodata_to_binary([template | assign_iodata])
-    end
+  def render_raw(instance, template, assigns \\ %{})
+      when is_binary(template) and is_map(assigns) do
+    input =
+      case map_size(assigns) do
+        0 ->
+          template
+
+        _ ->
+          assign_iodata =
+            assigns
+            |> Enum.map(fn {key, value} -> ["\n", key, "=", value] end)
+
+          IO.iodata_to_binary([template | assign_iodata])
+      end
+
     FastHelper.call_string(instance, "render_template_raw", input)
   end
 
@@ -138,6 +151,7 @@ defmodule Firebird.Phoenix.Template do
     case FastHelper.call_string(instance, "html_escape_batch", input) do
       {:ok, result} ->
         {:ok, String.split(result, <<0>>)}
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -164,9 +178,10 @@ defmodule Firebird.Phoenix.Template do
   @spec tag(pid(), String.t(), String.t(), map()) :: {:ok, String.t()} | {:error, term()}
   def tag(instance, tag_name, content \\ "", attrs \\ %{})
       when is_binary(tag_name) and is_binary(content) and is_map(attrs) do
-    attr_lines = Enum.map(attrs, fn {key, value} ->
-      "#{key}=#{value}"
-    end)
+    attr_lines =
+      Enum.map(attrs, fn {key, value} ->
+        "#{key}=#{value}"
+      end)
 
     input = Enum.join([tag_name, content | attr_lines], "\n")
     FastHelper.call_string(instance, "render_tag", input)
@@ -226,31 +241,38 @@ defmodule Firebird.Phoenix.Template do
   """
   @spec compile(pid() | reference(), String.t()) :: {:ok, non_neg_integer()} | {:error, term()}
   def compile(instance, template) when is_binary(template) do
-    compile_result = if FastHelper.fast?(instance) do
-      FastHelper.call_compile(instance, "compile_template", template)
-    else
-      write_and_call_compile(instance, template)
-    end
+    compile_result =
+      if FastHelper.fast?(instance) do
+        FastHelper.call_compile(instance, "compile_template", template)
+      else
+        write_and_call_compile(instance, template)
+      end
 
     case compile_result do
       {:ok, count} ->
         # Auto-cache variable names for transparent indexed rendering
-        var_result = if FastHelper.fast?(instance) do
-          FastHelper.call_output_only(instance, "get_var_names")
-        else
-          call_output_only(instance, "get_var_names")
-        end
+        var_result =
+          if FastHelper.fast?(instance) do
+            FastHelper.call_output_only(instance, "get_var_names")
+          else
+            call_output_only(instance, "get_var_names")
+          end
 
         case var_result do
           {:ok, ""} ->
             cache_var_names(instance, [])
+
           {:ok, result} ->
             var_names = :binary.split(result, <<0>>, [:global])
             cache_var_names(instance, var_names)
+
           {:error, _} ->
-            :ok  # Non-fatal: fall back to key-based render
+            # Non-fatal: fall back to key-based render
+            :ok
         end
+
         {:ok, count}
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -271,13 +293,18 @@ defmodule Firebird.Phoenix.Template do
     case Process.get({:firebird_template_vars, instance}) do
       nil ->
         ensure_var_cache_table()
+
         case :ets.lookup(@var_cache_table, instance) do
           [{^instance, var_names}] ->
             Process.put({:firebird_template_vars, instance}, var_names)
             var_names
-          _ -> nil
+
+          _ ->
+            nil
         end
-      var_names -> var_names
+
+      var_names ->
+        var_names
     end
   end
 
@@ -289,7 +316,9 @@ defmodule Firebird.Phoenix.Template do
         rescue
           ArgumentError -> :ok
         end
-      _ -> :ok
+
+      _ ->
+        :ok
     end
   end
 
@@ -316,10 +345,12 @@ defmodule Firebird.Phoenix.Template do
     case get_cached_var_names(instance) do
       nil ->
         # Fallback: key=value serialization
-        input = assigns
+        input =
+          assigns
           |> Enum.map(fn {key, value} -> [key, ?=, value] end)
           |> Enum.intersperse(?\n)
           |> IO.iodata_to_binary()
+
         FastHelper.call_string(instance, "render_compiled", input)
 
       var_names ->
@@ -334,12 +365,14 @@ defmodule Firebird.Phoenix.Template do
   # Build null-separated indexed input in a single pass (no intermediate list)
   defp build_indexed_input([], _assigns), do: <<>>
   defp build_indexed_input([name], assigns), do: Map.get(assigns, name, "")
+
   defp build_indexed_input([name | rest], assigns) do
     IO.iodata_to_binary([Map.get(assigns, name, "") | build_indexed_iodata(rest, assigns)])
   end
 
   defp build_indexed_iodata([], _assigns), do: []
   defp build_indexed_iodata([name], assigns), do: [<<0>>, Map.get(assigns, name, "")]
+
   defp build_indexed_iodata([name | rest], assigns) do
     [<<0>>, Map.get(assigns, name, "") | build_indexed_iodata(rest, assigns)]
   end
@@ -347,6 +380,7 @@ defmodule Firebird.Phoenix.Template do
   # Build full indexed IO data for a block (first element has no null prefix)
   defp build_indexed_iodata_raw([], _assigns), do: []
   defp build_indexed_iodata_raw([name], assigns), do: [Map.get(assigns, name, "")]
+
   defp build_indexed_iodata_raw([name | rest], assigns) do
     [Map.get(assigns, name, "") | build_indexed_iodata(rest, assigns)]
   end
@@ -376,13 +410,15 @@ defmodule Firebird.Phoenix.Template do
       ])
       # => {:ok, ["<p>Alice</p>", "<p>Bob</p>", "<p>Charlie</p>"]}
   """
-  @spec render_compiled_batch(pid() | reference(), list(map())) :: {:ok, list(String.t())} | {:error, term()}
+  @spec render_compiled_batch(pid() | reference(), list(map())) ::
+          {:ok, list(String.t())} | {:error, term()}
   def render_compiled_batch(instance, assigns_list) when is_list(assigns_list) do
     # Auto-indexed fast path: use indexed batch when var names are cached
     case get_cached_var_names(instance) do
       nil ->
         # Fallback: key=value serialization
-        input = assigns_list
+        input =
+          assigns_list
           |> Enum.map(fn assigns ->
             assigns
             |> Enum.map(fn {key, value} -> [key, ?=, value] end)
@@ -394,6 +430,7 @@ defmodule Firebird.Phoenix.Template do
         case FastHelper.call_string(instance, "render_compiled_batch", input) do
           {:ok, result} ->
             {:ok, :binary.split(result, <<0>>, [:global])}
+
           {:error, reason} ->
             {:error, reason}
         end
@@ -402,7 +439,8 @@ defmodule Firebird.Phoenix.Template do
         # FAST PATH: convert maps to ordered values, use indexed batch
         # SOH (0x01) separates blocks, NULL (0x00) separates values
         # Single-pass IO list build per block
-        input = assigns_list
+        input =
+          assigns_list
           |> Enum.map(fn assigns -> build_indexed_iodata_raw(var_names, assigns) end)
           |> Enum.intersperse(<<1>>)
           |> IO.iodata_to_binary()
@@ -410,6 +448,7 @@ defmodule Firebird.Phoenix.Template do
         case FastHelper.call_string(instance, "render_indexed_batch", input) do
           {:ok, result} ->
             {:ok, :binary.split(result, <<0>>, [:global])}
+
           {:error, reason} ->
             {:error, reason}
         end
@@ -430,11 +469,12 @@ defmodule Firebird.Phoenix.Template do
   @spec get_var_names(pid() | reference()) :: {:ok, list(String.t())} | {:error, term()}
   def get_var_names(instance) do
     # get_var_names takes only output_ptr, call it via special path
-    result = if FastHelper.fast?(instance) do
-      FastHelper.call_output_only(instance, "get_var_names")
-    else
-      call_output_only(instance, "get_var_names")
-    end
+    result =
+      if FastHelper.fast?(instance) do
+        FastHelper.call_output_only(instance, "get_var_names")
+      else
+        call_output_only(instance, "get_var_names")
+      end
 
     case result do
       {:ok, ""} -> {:ok, []}
@@ -468,7 +508,8 @@ defmodule Firebird.Phoenix.Template do
       {:ok, html} = Firebird.Phoenix.Template.render_indexed(instance, ["Alice", "Developer"])
       # => {:ok, "<h1>Alice</h1><p>Developer</p>"}
   """
-  @spec render_indexed(pid() | reference(), list(String.t())) :: {:ok, String.t()} | {:error, term()}
+  @spec render_indexed(pid() | reference(), list(String.t())) ::
+          {:ok, String.t()} | {:error, term()}
   def render_indexed(instance, values) when is_list(values) do
     if FastHelper.fast?(instance) do
       # FUSED NIF: write values directly to WASM memory (no IO.iodata_to_binary)
@@ -493,19 +534,23 @@ defmodule Firebird.Phoenix.Template do
   - `{:ok, [rendered_strings]}` - List of rendered strings
   - `{:error, reason}` - Rendering failed
   """
-  @spec render_indexed_batch(pid() | reference(), list(list(String.t()))) :: {:ok, list(String.t())} | {:error, term()}
+  @spec render_indexed_batch(pid() | reference(), list(list(String.t()))) ::
+          {:ok, list(String.t())} | {:error, term()}
   def render_indexed_batch(instance, values_list) when is_list(values_list) do
     # SOH (0x01) separates blocks, NULL (0x00) separates values within a block
-    input = values_list
+    input =
+      values_list
       |> Enum.map(fn values ->
         values |> Enum.intersperse(<<0>>)
       end)
-      |> Enum.intersperse(<<1>>)  # SOH block separator
+      # SOH block separator
+      |> Enum.intersperse(<<1>>)
       |> IO.iodata_to_binary()
 
     case FastHelper.call_string(instance, "render_indexed_batch", input) do
       {:ok, result} ->
         {:ok, :binary.split(result, <<0>>, [:global])}
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -542,13 +587,14 @@ defmodule Firebird.Phoenix.Template do
         ref = make_ref()
         from = {self(), ref}
 
-        :ok = Wasmex.Native.instance_call_exported_function(
-          store_resource,
-          instance_resource,
-          function,
-          [output_ptr],
-          from
-        )
+        :ok =
+          Wasmex.Native.instance_call_exported_function(
+            store_resource,
+            instance_resource,
+            function,
+            [output_ptr],
+            from
+          )
 
         receive do
           {^ref, {:ok, [output_len]}} ->
@@ -557,11 +603,13 @@ defmodule Firebird.Phoenix.Template do
             else
               {:ok, Wasmex.Memory.read_binary(store, memory, output_ptr, output_len)}
             end
+
           {^ref, {:error, reason}} ->
             {:error, reason}
         after
           5000 -> {:error, :timeout}
         end
+
       {:error, reason} ->
         {:error, reason}
     end
diff --git a/lib/firebird/phoenix/testing.ex b/lib/firebird/phoenix/testing.ex
index e5fbfe7..93521ac 100644
--- a/lib/firebird/phoenix/testing.ex
+++ b/lib/firebird/phoenix/testing.ex
@@ -110,12 +110,14 @@ defmodule Firebird.Phoenix.Testing do
   @spec assert_status(map(), integer()) :: true
   def assert_status(response, expected_status) do
     actual = response.status
+
     unless actual == expected_status do
       raise ExUnit.AssertionError,
         message: "Expected status #{expected_status}, got #{actual}",
         left: actual,
         right: expected_status
     end
+
     true
   end
 
@@ -129,12 +131,15 @@ defmodule Firebird.Phoenix.Testing do
   @spec assert_body_contains(map(), String.t()) :: true
   def assert_body_contains(response, expected) do
     body = response[:body] || response[:resp_body] || ""
+
     unless String.contains?(body, expected) do
       raise ExUnit.AssertionError,
-        message: "Expected body to contain #{inspect(expected)}, got: #{inspect(String.slice(body, 0..200))}",
+        message:
+          "Expected body to contain #{inspect(expected)}, got: #{inspect(String.slice(body, 0..200))}",
         left: body,
         right: expected
     end
+
     true
   end
 
@@ -149,12 +154,15 @@ defmodule Firebird.Phoenix.Testing do
   def assert_header(response, key, expected_value) do
     headers = response[:headers] || response[:resp_headers] || %{}
     actual = Map.get(headers, String.downcase(key))
+
     unless actual == expected_value do
       raise ExUnit.AssertionError,
-        message: "Expected header #{key} to be #{inspect(expected_value)}, got #{inspect(actual)}",
+        message:
+          "Expected header #{key} to be #{inspect(expected_value)}, got #{inspect(actual)}",
         left: actual,
         right: expected_value
     end
+
     true
   end
 
@@ -163,9 +171,10 @@ defmodule Firebird.Phoenix.Testing do
   """
   @spec assert_content_type(map(), String.t()) :: true
   def assert_content_type(response, expected) do
-    content_type = response[:content_type] ||
-      get_in(response, [:headers, "content-type"]) ||
-      get_in(response, [:resp_headers, "content-type"])
+    content_type =
+      response[:content_type] ||
+        get_in(response, [:headers, "content-type"]) ||
+        get_in(response, [:resp_headers, "content-type"])
 
     if content_type do
       unless String.contains?(content_type, expected) do
@@ -173,6 +182,7 @@ defmodule Firebird.Phoenix.Testing do
           message: "Expected content-type #{inspect(expected)}, got #{inspect(content_type)}"
       end
     end
+
     true
   end
 
@@ -187,6 +197,7 @@ defmodule Firebird.Phoenix.Testing do
   @spec put_json_body(Conn.t(), map()) :: Conn.t()
   def put_json_body(%Conn{} = conn, data) when is_map(data) do
     json = Jason.encode!(data)
+
     %{conn | body: json}
     |> Conn.put_req_header("content-type", "application/json")
   end
diff --git a/lib/firebird/phoenix/validator.ex b/lib/firebird/phoenix/validator.ex
index bb41827..d91322e 100644
--- a/lib/firebird/phoenix/validator.ex
+++ b/lib/firebird/phoenix/validator.ex
@@ -92,7 +92,8 @@ defmodule Firebird.Phoenix.Validator do
   - `{:ok, {:invalid, errors}}` - Validation failed, returns error list
   - `{:error, reason}` - WASM call failed
   """
-  @spec validate(pid(), map(), list()) :: {:ok, :valid | {:invalid, [{String.t(), String.t()}]}} | {:error, term()}
+  @spec validate(pid(), map(), list()) ::
+          {:ok, :valid | {:invalid, [{String.t(), String.t()}]}} | {:error, term()}
   def validate(instance, params, rules) when is_map(params) and is_list(rules) do
     param_lines = Enum.map(params, fn {k, v} -> "#{k}=#{v}" end) |> Enum.join("\n")
     rule_lines = Enum.map(rules, &format_rule/1) |> Enum.join("\n")
@@ -102,9 +103,11 @@ defmodule Firebird.Phoenix.Validator do
     case WasmHelper.call_string(instance, "validate_params", input) do
       {:ok, "valid"} ->
         {:ok, :valid}
+
       {:ok, "invalid|" <> error_str} ->
         errors = parse_errors(error_str)
         {:ok, {:invalid, errors}}
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -118,15 +121,18 @@ defmodule Firebird.Phoenix.Validator do
       {:ok, :valid} = Validator.validate_type(instance, "42", :integer)
       {:ok, {:invalid, reason}} = Validator.validate_type(instance, "abc", :integer)
   """
-  @spec validate_type(pid(), String.t(), atom()) :: {:ok, :valid | {:invalid, String.t()}} | {:error, term()}
+  @spec validate_type(pid(), String.t(), atom()) ::
+          {:ok, :valid | {:invalid, String.t()}} | {:error, term()}
   def validate_type(instance, value, type) when is_binary(value) and is_atom(type) do
     input = "#{type}\n#{value}"
 
     case WasmHelper.call_string(instance, "validate_type", input) do
       {:ok, "valid"} ->
         {:ok, :valid}
+
       {:ok, "invalid|" <> reason} ->
         {:ok, {:invalid, reason}}
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -153,7 +159,10 @@ defmodule Firebird.Phoenix.Validator do
   defp format_rule({:max_length, field, n}), do: "#{field}:max_length:#{n}"
   defp format_rule({:min, field, n}), do: "#{field}:min:#{n}"
   defp format_rule({:max, field, n}), do: "#{field}:max:#{n}"
-  defp format_rule({:in, field, values}) when is_list(values), do: "#{field}:in:#{Enum.join(values, ",")}"
+
+  defp format_rule({:in, field, values}) when is_list(values),
+    do: "#{field}:in:#{Enum.join(values, ",")}"
+
   defp format_rule({:format, field, fmt}), do: "#{field}:format:#{fmt}"
 
   # Parse error string into list of {field, message} tuples
@@ -168,4 +177,3 @@ defmodule Firebird.Phoenix.Validator do
     end)
   end
 end
-
diff --git a/lib/firebird/phoenix/view.ex b/lib/firebird/phoenix/view.ex
index 0ffb8ee..fd90656 100644
--- a/lib/firebird/phoenix/view.ex
+++ b/lib/firebird/phoenix/view.ex
@@ -263,8 +263,7 @@ defmodule Firebird.Phoenix.View do
     attrs = if class = Keyword.get(opts, :class), do: attrs ++ ["class=#{class}"], else: attrs
     attrs = if width = Keyword.get(opts, :width), do: attrs ++ ["width=#{width}"], else: attrs
 
-    attrs =
-      if height = Keyword.get(opts, :height), do: attrs ++ ["height=#{height}"], else: attrs
+    attrs = if height = Keyword.get(opts, :height), do: attrs ++ ["height=#{height}"], else: attrs
 
     input = Enum.join(["image" | attrs], "\n")
     WasmHelper.call_string(instance, "view_helper", input)
@@ -311,8 +310,7 @@ defmodule Firebird.Phoenix.View do
     attrs = if Keyword.get(opts, :async), do: attrs ++ ["async=true"], else: attrs
     attrs = if Keyword.get(opts, :defer), do: attrs ++ ["defer=true"], else: attrs
 
-    attrs =
-      if type = Keyword.get(opts, :type), do: attrs ++ ["type=#{type}"], else: attrs
+    attrs = if type = Keyword.get(opts, :type), do: attrs ++ ["type=#{type}"], else: attrs
 
     input = Enum.join(["script" | attrs], "\n")
     WasmHelper.call_string(instance, "view_helper", input)
diff --git a/lib/firebird/phoenix/wasm_helper.ex b/lib/firebird/phoenix/wasm_helper.ex
index c6a6a58..1ee6d96 100644
--- a/lib/firebird/phoenix/wasm_helper.ex
+++ b/lib/firebird/phoenix/wasm_helper.ex
@@ -18,7 +18,8 @@ defmodule Firebird.Phoenix.WasmHelper do
   not just large/batch operations.
   """
 
-  @output_buffer_size 65_536  # 64KB output buffer (legacy)
+  # 64KB output buffer (legacy)
+  @output_buffer_size 65_536
 
   # ETS table for caching buffer pointers, store/memory/instance refs per instance
   @cache_table :firebird_wasm_buffer_cache
@@ -29,7 +30,8 @@ defmodule Firebird.Phoenix.WasmHelper do
   Uses pre-allocated static buffers and direct NIF calls with cached
   resource handles for ZERO GenServer overhead per call.
   """
-  @spec call_string(pid(), String.t() | atom(), String.t()) :: {:ok, String.t()} | {:error, term()}
+  @spec call_string(pid(), String.t() | atom(), String.t()) ::
+          {:ok, String.t()} | {:error, term()}
   def call_string(instance, function, input) when is_binary(input) do
     function = if is_atom(function), do: Atom.to_string(function), else: function
 
@@ -40,15 +42,18 @@ defmodule Firebird.Phoenix.WasmHelper do
           {:ok, ctx} ->
             Process.put({:firebird_wasm_ctx, instance}, ctx)
             call_direct_nif(function, input, ctx)
+
           :miss ->
             case init_ctx(instance) do
               {:ok, ctx} ->
                 Process.put({:firebird_wasm_ctx, instance}, ctx)
                 call_direct_nif(function, input, ctx)
+
               {:error, reason} ->
                 {:error, reason}
             end
         end
+
       ctx ->
         call_direct_nif(function, input, ctx)
     end
@@ -77,13 +82,14 @@ defmodule Firebird.Phoenix.WasmHelper do
     ref = make_ref()
     from = {self(), ref}
 
-    :ok = Wasmex.Native.instance_call_exported_function(
-      store_resource,
-      instance_resource,
-      function,
-      [input_ptr, input_len, output_ptr],
-      from
-    )
+    :ok =
+      Wasmex.Native.instance_call_exported_function(
+        store_resource,
+        instance_resource,
+        function,
+        [input_ptr, input_len, output_ptr],
+        from
+      )
 
     # Receive the async reply from the NIF
     receive do
@@ -92,7 +98,13 @@ defmodule Firebird.Phoenix.WasmHelper do
           {:ok, ""}
         else
           # Direct NIF memory read - skip Wasmex.Memory struct dispatch
-          {:ok, Wasmex.Native.memory_read_binary(store_resource, memory_resource, output_ptr, output_len)}
+          {:ok,
+           Wasmex.Native.memory_read_binary(
+             store_resource,
+             memory_resource,
+             output_ptr,
+             output_len
+           )}
         end
 
       {^ref, {:error, reason}} ->
@@ -115,10 +127,9 @@ defmodule Firebird.Phoenix.WasmHelper do
     with {:ok, store} <- Wasmex.store(instance),
          {:ok, memory} <- Wasmex.memory(instance),
          {:ok, inst} <- Wasmex.instance(instance) do
-
       {input_ptr, output_ptr} =
         if Wasmex.function_exists(instance, "get_input_ptr") and
-           Wasmex.function_exists(instance, "get_output_ptr") do
+             Wasmex.function_exists(instance, "get_output_ptr") do
           {:ok, [iptr]} = Wasmex.call_function(instance, "get_input_ptr", [])
           {:ok, [optr]} = Wasmex.call_function(instance, "get_output_ptr", [])
           {iptr, optr}
@@ -147,8 +158,10 @@ defmodule Firebird.Phoenix.WasmHelper do
       try do
         :ets.insert(@cache_table, {instance, ctx})
       rescue
-        ArgumentError -> :ok  # Table may have been recreated
+        # Table may have been recreated
+        ArgumentError -> :ok
       end
+
       {:ok, ctx}
     else
       {:error, reason} -> {:error, reason}
@@ -173,8 +186,10 @@ defmodule Firebird.Phoenix.WasmHelper do
         try do
           :ets.new(@cache_table, [:named_table, :public, :set, {:read_concurrency, true}])
         rescue
-          ArgumentError -> :ok  # Race condition, table already created by another process
+          # Race condition, table already created by another process
+          ArgumentError -> :ok
         end
+
       _ ->
         :ok
     end
@@ -210,7 +225,8 @@ defmodule Firebird.Phoenix.WasmHelper do
   @doc """
   Read bytes from WASM linear memory as a binary string.
   """
-  @spec read_memory(pid(), non_neg_integer(), non_neg_integer()) :: {:ok, binary()} | {:error, term()}
+  @spec read_memory(pid(), non_neg_integer(), non_neg_integer()) ::
+          {:ok, binary()} | {:error, term()}
   def read_memory(instance, offset, length) do
     if length == 0 do
       {:ok, ""}
@@ -222,7 +238,3 @@ defmodule Firebird.Phoenix.WasmHelper do
     end
   end
 end
-
-
-
-
diff --git a/lib/firebird/phoenix/websocket.ex b/lib/firebird/phoenix/websocket.ex
index 9be34fc..5201b7c 100644
--- a/lib/firebird/phoenix/websocket.ex
+++ b/lib/firebird/phoenix/websocket.ex
@@ -97,11 +97,12 @@ defmodule Firebird.Phoenix.WebSocket do
   """
   @spec accept_headers(String.t()) :: {:ok, map()}
   def accept_headers(client_key) when is_binary(client_key) do
-    {:ok, %{
-      "Upgrade" => "websocket",
-      "Connection" => "Upgrade",
-      "Sec-WebSocket-Accept" => accept_key(client_key)
-    }}
+    {:ok,
+     %{
+       "Upgrade" => "websocket",
+       "Connection" => "Upgrade",
+       "Sec-WebSocket-Accept" => accept_key(client_key)
+     }}
   end
 
   @doc """
@@ -123,11 +124,12 @@ defmodule Firebird.Phoenix.WebSocket do
       "Sec-WebSocket-Accept: #{accept_key(client_key)}"
     ]
 
-    headers = if protocol do
-      headers ++ ["Sec-WebSocket-Protocol: #{protocol}"]
-    else
-      headers
-    end
+    headers =
+      if protocol do
+        headers ++ ["Sec-WebSocket-Protocol: #{protocol}"]
+      else
+        headers
+      end
 
     Enum.join(headers, "\r\n") <> "\r\n\r\n"
   end
@@ -178,10 +180,12 @@ defmodule Firebird.Phoenix.WebSocket do
   """
   @spec encode_close(integer() | nil, String.t()) :: binary()
   def encode_close(code \\ nil, reason \\ "") do
-    payload = case code do
-      nil -> <<>>
-      code -> <<code::16>> <> reason
-    end
+    payload =
+      case code do
+        nil -> <<>>
+        code -> <<code::16>> <> reason
+      end
+
     encode_frame(0x8, payload)
   end
 
@@ -200,7 +204,8 @@ defmodule Firebird.Phoenix.WebSocket do
 
       {:ok, {:text, "hello"}, <<>>} = WebSocket.decode_frame(frame_bytes)
   """
-  @spec decode_frame(binary()) :: {:ok, frame(), binary()} | {:incomplete, binary()} | {:error, term()}
+  @spec decode_frame(binary()) ::
+          {:ok, frame(), binary()} | {:incomplete, binary()} | {:error, term()}
   def decode_frame(data) when byte_size(data) < 2 do
     {:incomplete, data}
   end
@@ -280,13 +285,14 @@ defmodule Firebird.Phoenix.WebSocket do
   def decode_channel_message(json) when is_binary(json) do
     case Jason.decode(json) do
       {:ok, %{"topic" => topic, "event" => event} = msg} ->
-        {:ok, %{
-          topic: topic,
-          event: event,
-          payload: Map.get(msg, "payload", %{}),
-          ref: Map.get(msg, "ref"),
-          join_ref: Map.get(msg, "join_ref")
-        }}
+        {:ok,
+         %{
+           topic: topic,
+           event: event,
+           payload: Map.get(msg, "payload", %{}),
+           ref: Map.get(msg, "ref"),
+           join_ref: Map.get(msg, "join_ref")
+         }}
 
       {:ok, _} ->
         {:error, :invalid_channel_message}
@@ -299,13 +305,15 @@ defmodule Firebird.Phoenix.WebSocket do
   # Internal frame encoding (server-side, no masking)
   defp encode_frame(opcode, payload) do
     len = byte_size(payload)
-    first_byte = Bitwise.bor(0x80, opcode)  # FIN=1, RSV=000, opcode
-
-    length_bytes = cond do
-      len <= 125 -> <<len>>
-      len <= 65535 -> <<126, len::16>>
-      true -> <<127, len::64>>
-    end
+    # FIN=1, RSV=000, opcode
+    first_byte = Bitwise.bor(0x80, opcode)
+
+    length_bytes =
+      cond do
+        len <= 125 -> <<len>>
+        len <= 65535 -> <<126, len::16>>
+        true -> <<127, len::64>>
+      end
 
     <<first_byte>> <> length_bytes <> payload
   end
diff --git a/lib/firebird/phoenix/websocket_wasm.ex b/lib/firebird/phoenix/websocket_wasm.ex
index 18408b2..52526c5 100644
--- a/lib/firebird/phoenix/websocket_wasm.ex
+++ b/lib/firebird/phoenix/websocket_wasm.ex
@@ -33,7 +33,8 @@ defmodule Firebird.Phoenix.WebSocketWasm do
 
   Returns `{:ok, true, websocket_key}` or `{:ok, false}`.
   """
-  @spec is_upgrade?(pid(), String.t() | map()) :: {:ok, boolean(), String.t() | nil} | {:error, term()}
+  @spec is_upgrade?(pid(), String.t() | map()) ::
+          {:ok, boolean(), String.t() | nil} | {:error, term()}
   def is_upgrade?(instance, headers) when is_binary(headers) do
     case WasmHelper.call_string(instance, "is_upgrade", headers) do
       {:ok, "true|" <> key} -> {:ok, true, key}
@@ -106,13 +107,16 @@ defmodule Firebird.Phoenix.WebSocketWasm do
     case WasmHelper.call_string(instance, "decode_frame", frame_bytes) do
       {:ok, "error|" <> reason} ->
         {:error, reason}
+
       {:ok, result} ->
         case String.split(result, "|", parts: 2) do
           [type, payload] ->
             {:ok, String.to_atom(type), payload}
+
           [type] ->
             {:ok, String.to_atom(type), ""}
         end
+
       {:error, reason} ->
         {:error, reason}
     end
@@ -129,7 +133,14 @@ defmodule Firebird.Phoenix.WebSocketWasm do
   - `event` - Event name
   - `payload` - JSON payload string
   """
-  @spec serialize_channel_msg(pid(), String.t() | nil, String.t() | nil, String.t(), String.t(), String.t()) ::
+  @spec serialize_channel_msg(
+          pid(),
+          String.t() | nil,
+          String.t() | nil,
+          String.t(),
+          String.t(),
+          String.t()
+        ) ::
           {:ok, String.t()} | {:error, term()}
   def serialize_channel_msg(instance, join_ref, ref, topic, event, payload) do
     jr = if join_ref, do: join_ref, else: "null"
@@ -148,19 +159,23 @@ defmodule Firebird.Phoenix.WebSocketWasm do
     case WasmHelper.call_string(instance, "deserialize_channel_msg", json) do
       {:ok, "error|" <> reason} ->
         {:error, reason}
+
       {:ok, result} ->
         case String.split(result, "|", parts: 5) do
           [jr, r, topic, event, payload] ->
-            {:ok, %{
-              join_ref: if(jr == "" or jr == "null", do: nil, else: jr),
-              ref: if(r == "" or r == "null", do: nil, else: r),
-              topic: topic,
-              event: event,
-              payload: payload
-            }}
+            {:ok,
+             %{
+               join_ref: if(jr == "" or jr == "null", do: nil, else: jr),
+               ref: if(r == "" or r == "null", do: nil, else: r),
+               topic: topic,
+               event: event,
+               payload: payload
+             }}
+
           _ ->
             {:error, :invalid_message}
         end
+
       {:error, reason} ->
         {:error, reason}
     end
diff --git a/lib/firebird/pipeline.ex b/lib/firebird/pipeline.ex
index a4d0f43..84ce893 100644
--- a/lib/firebird/pipeline.ex
+++ b/lib/firebird/pipeline.ex
@@ -29,11 +29,11 @@ defmodule Firebird.Pipeline do
   defstruct instance: nil, steps: [], halted: false, error: nil
 
   @type t :: %__MODULE__{
-    instance: pid(),
-    steps: list(),
-    halted: boolean(),
-    error: term() | nil
-  }
+          instance: pid(),
+          steps: list(),
+          halted: boolean(),
+          error: term() | nil
+        }
 
   @doc """
   Create a new pipeline for a WASM instance.
@@ -166,6 +166,7 @@ defmodule Firebird.Pipeline do
     rescue
       _ -> :ok
     end
+
     {:ok, prev_result}
   end
 
@@ -181,6 +182,7 @@ defmodule Firebird.Pipeline do
         :_, idx ->
           val = Enum.at(prev_result, idx, 0)
           {val, idx + 1}
+
         other, idx ->
           {other, idx}
       end)
diff --git a/lib/firebird/pool.ex b/lib/firebird/pool.ex
index bfc3f2a..857f4e8 100644
--- a/lib/firebird/pool.ex
+++ b/lib/firebird/pool.ex
@@ -59,19 +59,29 @@ defmodule Firebird.Pool do
 
   use GenServer
 
-  defstruct [:wasm_source, :opts, :compiled, :instances, :size, :next_index, :monitors, :replaced, :busy]
+  defstruct [
+    :wasm_source,
+    :opts,
+    :compiled,
+    :instances,
+    :size,
+    :next_index,
+    :monitors,
+    :replaced,
+    :busy
+  ]
 
   @type t :: %__MODULE__{
-    wasm_source: binary(),
-    opts: keyword(),
-    compiled: map() | nil,
-    instances: tuple(),
-    size: non_neg_integer(),
-    next_index: non_neg_integer(),
-    monitors: %{reference() => non_neg_integer()},
-    replaced: non_neg_integer(),
-    busy: MapSet.t()
-  }
+          wasm_source: binary(),
+          opts: keyword(),
+          compiled: map() | nil,
+          instances: tuple(),
+          size: non_neg_integer(),
+          next_index: non_neg_integer(),
+          monitors: %{reference() => non_neg_integer()},
+          replaced: non_neg_integer(),
+          busy: MapSet.t()
+        }
 
   @doc """
   Start a pool of WASM instances with automatic health monitoring.
@@ -143,6 +153,7 @@ defmodule Firebird.Pool do
   @spec call(GenServer.server(), atom() | String.t(), list()) :: {:ok, list()} | {:error, term()}
   def call(pool, function, args) do
     instance = GenServer.call(pool, :checkout)
+
     try do
       Firebird.Runtime.call(instance, function, args)
     after
@@ -165,6 +176,101 @@ defmodule Firebird.Pool do
     end
   end
 
+  @doc """
+  Run multiple function calls on a single pooled instance.
+
+  Checks out one instance, executes all calls sequentially, and checks it
+  back in — paying only **one** checkout/checkin round-trip instead of N.
+  This is significantly faster than calling `call/3` in a loop when you
+  have multiple operations to perform.
+
+  Returns `{:ok, [result1, result2, ...]}` where each result is the raw
+  WASM return list (e.g., `[8]`). Stops on the first error.
+
+  ## Examples
+
+      {:ok, pool} = Firebird.Pool.start_link(wasm: "math.wasm", size: 4)
+
+      {:ok, [[8], [28], [55]]} = Firebird.Pool.call_many(pool, [
+        {:add, [5, 3]},
+        {:multiply, [4, 7]},
+        {:fibonacci, [10]}
+      ])
+
+      # Compare: 3 separate calls = 3 checkouts + 3 checkins
+      # call_many: 1 checkout + 3 WASM calls + 1 checkin
+  """
+  @spec call_many(GenServer.server(), [{atom() | String.t(), list()}]) ::
+          {:ok, [list()]} | {:error, term()}
+  def call_many(pool, calls) when is_list(calls) do
+    instance = GenServer.call(pool, :checkout)
+
+    try do
+      Enum.reduce_while(calls, {:ok, []}, fn {func, args}, {:ok, acc} ->
+        case Firebird.Runtime.call(instance, func, args) do
+          {:ok, result} -> {:cont, {:ok, [result | acc]}}
+          error -> {:halt, error}
+        end
+      end)
+      |> case do
+        {:ok, results} -> {:ok, Enum.reverse(results)}
+        error -> error
+      end
+    after
+      GenServer.cast(pool, {:checkin, instance})
+    end
+  end
+
+  @doc """
+  Like `call_many/2` but raises on error.
+
+  ## Examples
+
+      [[8], [28]] = Firebird.Pool.call_many!(pool, [
+        {:add, [5, 3]},
+        {:multiply, [4, 7]}
+      ])
+  """
+  @spec call_many!(GenServer.server(), [{atom() | String.t(), list()}]) :: [list()]
+  def call_many!(pool, calls) when is_list(calls) do
+    case call_many(pool, calls) do
+      {:ok, results} -> results
+      {:error, reason} -> raise "WASM pool call_many failed: #{inspect(reason)}"
+    end
+  end
+
+  @doc """
+  Like `call_many/2` but unwraps single-value results.
+
+  Most WASM functions return exactly one value. This convenience function
+  unwraps `[value]` → `value` for each result.
+
+  ## Examples
+
+      {:ok, [8, 28, 55]} = Firebird.Pool.call_many_unwrapped(pool, [
+        {:add, [5, 3]},
+        {:multiply, [4, 7]},
+        {:fibonacci, [10]}
+      ])
+  """
+  @spec call_many_unwrapped(GenServer.server(), [{atom() | String.t(), list()}]) ::
+          {:ok, [term()]} | {:error, term()}
+  def call_many_unwrapped(pool, calls) when is_list(calls) do
+    case call_many(pool, calls) do
+      {:ok, results} ->
+        unwrapped =
+          Enum.map(results, fn
+            [single] -> single
+            multi -> multi
+          end)
+
+        {:ok, unwrapped}
+
+      error ->
+        error
+    end
+  end
+
   @doc """
   Get pool status (size, active instances).
 
@@ -193,7 +299,8 @@ defmodule Firebird.Pool do
 
       {:ok, 8} = Firebird.Pool.call_one(pool, :add, [5, 3])
   """
-  @spec call_one(GenServer.server(), atom() | String.t(), list()) :: {:ok, term()} | {:error, term()}
+  @spec call_one(GenServer.server(), atom() | String.t(), list()) ::
+          {:ok, term()} | {:error, term()}
   def call_one(pool, function, args) do
     case call(pool, function, args) do
       {:ok, [single]} -> {:ok, single}
@@ -264,9 +371,11 @@ defmodule Firebird.Pool do
       end)
   """
   @spec with_memory(GenServer.server(), keyword(), (pid(), Firebird.Memory.t() -> result)) ::
-    {:ok, result} | {:error, term()} when result: var
+          {:ok, result} | {:error, term()}
+        when result: var
   def with_memory(pool, opts \\ [], fun) when is_function(fun, 2) do
     instance = GenServer.call(pool, :checkout)
+
     try do
       mem = Firebird.Memory.new(instance, opts)
       result = fun.(instance, mem)
@@ -311,11 +420,11 @@ defmodule Firebird.Pool do
       )
   """
   @spec call_with_strings(
-    GenServer.server(),
-    atom() | String.t(),
-    [String.t()],
-    keyword()
-  ) :: {:ok, term()} | {:error, term()}
+          GenServer.server(),
+          atom() | String.t(),
+          [String.t()],
+          keyword()
+        ) :: {:ok, term()} | {:error, term()}
   def call_with_strings(pool, function, strings, opts \\ []) when is_list(strings) do
     result_mode = Keyword.get(opts, :result, :raw)
     extra_args = Keyword.get(opts, :extra_args, [])
@@ -338,6 +447,7 @@ defmodule Firebird.Pool do
                 [ptr, len] ->
                   {:ok, str} = Firebird.Memory.read_string(mem, ptr, len)
                   str
+
                 _ ->
                   raise "Expected [ptr, len] result for :string mode, got: #{inspect(result)}"
               end
@@ -388,35 +498,38 @@ defmodule Firebird.Pool do
         extra_args = Map.get(call_spec, :args, [])
         result_mode = Map.get(call_spec, :result, :raw)
 
-        {result, _mem} = Firebird.Memory.with_arena(mem, fn mem ->
-          {mem, string_args_rev} =
-            Enum.reduce(strings, {mem, []}, fn str, {m, acc} ->
-              {m, ptr, len} = Firebird.Memory.write_string(m, str)
-              {m, [len, ptr | acc]}
-            end)
-
-          all_args = Enum.reverse(string_args_rev) ++ extra_args
-
-          result =
-            case Firebird.call(pid, function, all_args) do
-              {:ok, result} ->
-                case result_mode do
-                  :string ->
-                    [ptr, len] = result
-                    {:ok, str} = Firebird.Memory.read_string(mem, ptr, len)
-                    str
-                  :i32 ->
-                    hd(result)
-                  :raw ->
-                    result
-                end
-
-              {:error, reason} ->
-                raise "WASM pool call failed: #{inspect(reason)}"
-            end
+        {result, _mem} =
+          Firebird.Memory.with_arena(mem, fn mem ->
+            {mem, string_args_rev} =
+              Enum.reduce(strings, {mem, []}, fn str, {m, acc} ->
+                {m, ptr, len} = Firebird.Memory.write_string(m, str)
+                {m, [len, ptr | acc]}
+              end)
+
+            all_args = Enum.reverse(string_args_rev) ++ extra_args
+
+            result =
+              case Firebird.call(pid, function, all_args) do
+                {:ok, result} ->
+                  case result_mode do
+                    :string ->
+                      [ptr, len] = result
+                      {:ok, str} = Firebird.Memory.read_string(mem, ptr, len)
+                      str
+
+                    :i32 ->
+                      hd(result)
+
+                    :raw ->
+                      result
+                  end
+
+                {:error, reason} ->
+                  raise "WASM pool call failed: #{inspect(reason)}"
+              end
 
-          {result, mem}
-        end)
+            {result, mem}
+          end)
 
         result
       end)
@@ -450,10 +563,13 @@ defmodule Firebird.Pool do
 
   defp normalize_key(opts, short, canonical) do
     case Keyword.pop(opts, short) do
-      {nil, opts} -> opts
+      {nil, opts} ->
+        opts
+
       {value, opts} ->
         if Keyword.has_key?(opts, canonical) do
-          opts  # canonical takes precedence
+          # canonical takes precedence
+          opts
         else
           Keyword.put(opts, canonical, value)
         end
@@ -468,10 +584,11 @@ defmodule Firebird.Pool do
     wasi = Keyword.get(opts, :wasi, false)
     load_opts = [wasi: wasi]
 
-    bytes = cond do
-      path = Keyword.get(opts, :wasm_path) -> File.read!(path)
-      bytes = Keyword.get(opts, :wasm_bytes) -> bytes
-    end
+    bytes =
+      cond do
+        path = Keyword.get(opts, :wasm_path) -> File.read!(path)
+        bytes = Keyword.get(opts, :wasm_bytes) -> bytes
+      end
 
     # Precompile the WASM module once, then create all instances from it.
     # This avoids recompiling the same bytes N times (the main bottleneck
@@ -521,17 +638,18 @@ defmodule Firebird.Pool do
 
     instances_tuple = List.to_tuple(pids)
 
-    {:ok, %__MODULE__{
-      wasm_source: bytes,
-      opts: load_opts,
-      compiled: compiled,
-      instances: instances_tuple,
-      size: pool_size,
-      next_index: 0,
-      monitors: monitors,
-      replaced: 0,
-      busy: MapSet.new()
-    }}
+    {:ok,
+     %__MODULE__{
+       wasm_source: bytes,
+       opts: load_opts,
+       compiled: compiled,
+       instances: instances_tuple,
+       size: pool_size,
+       next_index: 0,
+       monitors: monitors,
+       replaced: 0,
+       busy: MapSet.new()
+     }}
   end
 
   @impl true
@@ -545,6 +663,7 @@ defmodule Firebird.Pool do
 
   def handle_call(:info, _from, state) do
     alive = Enum.count(Tuple.to_list(state.instances), &Process.alive?/1)
+
     info = %{
       pool_size: state.size,
       size: state.size,
@@ -553,6 +672,7 @@ defmodule Firebird.Pool do
       busy: MapSet.size(state.busy),
       idle: state.size - MapSet.size(state.busy)
     }
+
     {:reply, info, state}
   end
 
@@ -560,6 +680,7 @@ defmodule Firebird.Pool do
     {state, replaced_now} =
       Enum.reduce(0..(state.size - 1), {state, 0}, fn idx, {st, count} ->
         instance = elem(st.instances, idx)
+
         if Process.alive?(instance) do
           {st, count}
         else
@@ -596,6 +717,7 @@ defmodule Firebird.Pool do
         case replace_instance(state, idx) do
           {:ok, new_state} ->
             {:noreply, new_state}
+
           {:error, _reason} ->
             # Replacement failed — leave the dead PID; checkout will retry
             {:noreply, state}
@@ -617,6 +739,7 @@ defmodule Firebird.Pool do
     |> Enum.each(fn pid ->
       if Process.alive?(pid), do: Firebird.Runtime.stop(pid)
     end)
+
     :ok
   end
 
@@ -661,6 +784,7 @@ defmodule Firebird.Pool do
         case replace_instance(state, idx) do
           {:ok, new_state} ->
             new_instance = elem(new_state.instances, idx)
+
             if not MapSet.member?(new_state.busy, new_instance) do
               {:ok, idx, new_instance, new_state}
             else
@@ -728,11 +852,7 @@ defmodule Firebird.Pool do
         instances = put_elem(state.instances, idx, new_pid)
         monitors = Map.put(state.monitors, ref, idx)
 
-        {:ok, %{state |
-          instances: instances,
-          monitors: monitors,
-          replaced: state.replaced + 1
-        }}
+        {:ok, %{state | instances: instances, monitors: monitors, replaced: state.replaced + 1}}
 
       {:error, reason} ->
         {:error, reason}
diff --git a/lib/firebird/preloader.ex b/lib/firebird/preloader.ex
index 3485b35..17e69ca 100644
--- a/lib/firebird/preloader.ex
+++ b/lib/firebird/preloader.ex
@@ -58,11 +58,11 @@ defmodule Firebird.Preloader do
   (for fallback re-instantiation), and WASI configuration.
   """
   @type compiled :: %{
-    module: Wasmex.Module.t(),
-    store: Wasmex.StoreOrCaller.t() | nil,
-    bytes: binary(),
-    wasi: boolean() | map()
-  }
+          module: Wasmex.Module.t(),
+          store: Wasmex.StoreOrCaller.t() | nil,
+          bytes: binary(),
+          wasi: boolean() | map()
+        }
 
   @doc """
   Compile WASM bytes or a file path into a reusable module.
@@ -137,14 +137,22 @@ defmodule Firebird.Preloader do
   defp create_store(false), do: Wasmex.Store.new()
   defp create_store(true), do: Wasmex.Store.new_wasi(%Wasmex.Wasi.WasiOptions{})
   defp create_store(%Wasmex.Wasi.WasiOptions{} = w), do: Wasmex.Store.new_wasi(w)
-  defp create_store(opts) when is_map(opts), do: Wasmex.Store.new_wasi(struct(Wasmex.Wasi.WasiOptions, opts))
+
+  defp create_store(opts) when is_map(opts),
+    do: Wasmex.Store.new_wasi(struct(Wasmex.Wasi.WasiOptions, opts))
 
   # Create a store from a specific engine (needed for deserialization to avoid
   # "cross-Engine instantiation" errors).
   defp create_store_with_engine(false, engine), do: Wasmex.Store.new(nil, engine)
-  defp create_store_with_engine(true, engine), do: Wasmex.Store.new_wasi(%Wasmex.Wasi.WasiOptions{}, nil, engine)
-  defp create_store_with_engine(%Wasmex.Wasi.WasiOptions{} = w, engine), do: Wasmex.Store.new_wasi(w, nil, engine)
-  defp create_store_with_engine(opts, engine) when is_map(opts), do: Wasmex.Store.new_wasi(struct(Wasmex.Wasi.WasiOptions, opts), nil, engine)
+
+  defp create_store_with_engine(true, engine),
+    do: Wasmex.Store.new_wasi(%Wasmex.Wasi.WasiOptions{}, nil, engine)
+
+  defp create_store_with_engine(%Wasmex.Wasi.WasiOptions{} = w, engine),
+    do: Wasmex.Store.new_wasi(w, nil, engine)
+
+  defp create_store_with_engine(opts, engine) when is_map(opts),
+    do: Wasmex.Store.new_wasi(struct(Wasmex.Wasi.WasiOptions, opts), nil, engine)
 
   @doc """
   Compile WASM, raising on error.
@@ -197,6 +205,7 @@ defmodule Firebird.Preloader do
         {:error, _reason} when module != :deserialized ->
           # Module-based instantiation failed; fall back to bytes
           fallback_opts = apply_wasi_opts(%{bytes: bytes}, wasi)
+
           case Wasmex.start_link(fallback_opts) do
             {:ok, pid} -> {:ok, pid}
             {:error, reason2} -> {:error, {:instantiate_error, reason2}}
@@ -262,6 +271,7 @@ defmodule Firebird.Preloader do
         Enum.each(successes, fn {:ok, pid} ->
           if Process.alive?(pid), do: GenServer.stop(pid, :normal)
         end)
+
         {:error, reason}
     end
   end
@@ -349,8 +359,10 @@ defmodule Firebird.Preloader do
         |> Enum.map(fn
           {name, {:fn, params, results}} ->
             %{name: name, type: :function, params: params, results: results}
+
           {name, {type, _}} ->
             %{name: name, type: type}
+
           {name, type} ->
             %{name: name, type: type}
         end)
@@ -374,6 +386,7 @@ defmodule Firebird.Preloader do
     else
       if String.printable?(source) do
         path = Firebird.Runtime.resolve_wasm_path(source)
+
         case File.read(path) do
           {:ok, bytes} -> {:ok, bytes}
           {:error, reason} -> {:error, {:file_error, reason, source}}
diff --git a/lib/firebird/profiler.ex b/lib/firebird/profiler.ex
index 1a05fe7..d60c075 100644
--- a/lib/firebird/profiler.ex
+++ b/lib/firebird/profiler.ex
@@ -56,10 +56,11 @@ defmodule Firebird.Profiler do
     end
 
     # Measure
-    times = for _ <- 1..iterations do
-      {time, _} = :timer.tc(fn -> Firebird.call(instance, function, args) end)
-      time
-    end
+    times =
+      for _ <- 1..iterations do
+        {time, _} = :timer.tc(fn -> Firebird.call(instance, function, args) end)
+        time
+      end
 
     Firebird.stop(instance)
     compute_stats(times, to_string(function), iterations)
@@ -78,13 +79,16 @@ defmodule Firebird.Profiler do
     iterations = Keyword.get(opts, :iterations, 20)
     load_opts = Keyword.drop(opts, [:iterations])
 
-    times = for _ <- 1..iterations do
-      {time, {:ok, instance}} = :timer.tc(fn ->
-        Firebird.WasmRunner.start(wasm_path, load_opts)
-      end)
-      Firebird.stop(instance)
-      time
-    end
+    times =
+      for _ <- 1..iterations do
+        {time, {:ok, instance}} =
+          :timer.tc(fn ->
+            Firebird.WasmRunner.start(wasm_path, load_opts)
+          end)
+
+        Firebird.stop(instance)
+        time
+      end
 
     stats = compute_stats(times, "startup", iterations)
     Map.put(stats, :wasm_path, wasm_path)
@@ -110,31 +114,33 @@ defmodule Firebird.Profiler do
 
     sigs = Firebird.WasmRunner.function_signatures(instance)
 
-    profiles = Enum.map(sigs, fn {func, {params, _results}} ->
-      # Generate default args (all zeros)
-      args = Enum.map(params, fn _ -> 0 end)
-
-      # Skip functions that might trap with zero args
-      times = try do
-        # Warmup
-        for _ <- 1..5, do: Firebird.call(instance, func, args)
-
-        for _ <- 1..iterations do
-          {time, _} = :timer.tc(fn -> Firebird.call(instance, func, args) end)
-          time
+    profiles =
+      Enum.map(sigs, fn {func, {params, _results}} ->
+        # Generate default args (all zeros)
+        args = Enum.map(params, fn _ -> 0 end)
+
+        # Skip functions that might trap with zero args
+        times =
+          try do
+            # Warmup
+            for _ <- 1..5, do: Firebird.call(instance, func, args)
+
+            for _ <- 1..iterations do
+              {time, _} = :timer.tc(fn -> Firebird.call(instance, func, args) end)
+              time
+            end
+          rescue
+            _ -> []
+          catch
+            _, _ -> []
+          end
+
+        if times != [] do
+          {func, compute_stats(times, to_string(func), iterations)}
+        else
+          {func, %{function: to_string(func), error: "call failed with default args"}}
         end
-      rescue
-        _ -> []
-      catch
-        _, _ -> []
-      end
-
-      if times != [] do
-        {func, compute_stats(times, to_string(func), iterations)}
-      else
-        {func, %{function: to_string(func), error: "call failed with default args"}}
-      end
-    end)
+      end)
 
     Firebird.stop(instance)
 
@@ -163,32 +169,35 @@ defmodule Firebird.Profiler do
     iterations = Keyword.get(opts, :iterations, @default_iterations)
     warmup = Keyword.get(opts, :warmup, @default_warmup)
 
-    results = Enum.map(implementations, fn
-      {name, {wasm_path, load_opts}} ->
-        {:ok, instance} = Firebird.WasmRunner.start(wasm_path, load_opts)
+    results =
+      Enum.map(implementations, fn
+        {name, {wasm_path, load_opts}} ->
+          {:ok, instance} = Firebird.WasmRunner.start(wasm_path, load_opts)
 
-        # Warmup
-        for _ <- 1..warmup, do: Firebird.call(instance, function, args)
+          # Warmup
+          for _ <- 1..warmup, do: Firebird.call(instance, function, args)
 
-        times = for _ <- 1..iterations do
-          {time, _} = :timer.tc(fn -> Firebird.call(instance, function, args) end)
-          time
-        end
+          times =
+            for _ <- 1..iterations do
+              {time, _} = :timer.tc(fn -> Firebird.call(instance, function, args) end)
+              time
+            end
 
-        Firebird.stop(instance)
-        {name, compute_stats(times, "#{name}/#{function}", iterations)}
+          Firebird.stop(instance)
+          {name, compute_stats(times, "#{name}/#{function}", iterations)}
 
-      {name, func} when is_function(func) ->
-        # Native Elixir function
-        for _ <- 1..warmup, do: func.(args)
+        {name, func} when is_function(func) ->
+          # Native Elixir function
+          for _ <- 1..warmup, do: func.(args)
 
-        times = for _ <- 1..iterations do
-          {time, _} = :timer.tc(fn -> func.(args) end)
-          time
-        end
+          times =
+            for _ <- 1..iterations do
+              {time, _} = :timer.tc(fn -> func.(args) end)
+              time
+            end
 
-        {name, compute_stats(times, "#{name}/#{function}", iterations)}
-    end)
+          {name, compute_stats(times, "#{name}/#{function}", iterations)}
+      end)
 
     results_map = Map.new(results)
     fastest = results |> Enum.min_by(fn {_, stats} -> stats.avg_us end) |> elem(0)
@@ -256,10 +265,12 @@ defmodule Firebird.Profiler do
       ""
     ]
 
-    result_lines = Enum.map(results, fn {name, stats} ->
-      marker = if name == fastest, do: "🏆", else: "  "
-      "   #{marker} #{String.pad_trailing("#{name}", 15)} avg=#{Float.round(stats.avg_us, 1)}μs  p50=#{Float.round(stats.p50_us, 1)}μs  p99=#{Float.round(stats.p99_us, 1)}μs"
-    end)
+    result_lines =
+      Enum.map(results, fn {name, stats} ->
+        marker = if name == fastest, do: "🏆", else: "  "
+
+        "   #{marker} #{String.pad_trailing("#{name}", 15)} avg=#{Float.round(stats.avg_us, 1)}μs  p50=#{Float.round(stats.p50_us, 1)}μs  p99=#{Float.round(stats.p99_us, 1)}μs"
+      end)
 
     Enum.join(lines ++ result_lines, "\n")
   end
@@ -274,7 +285,8 @@ defmodule Firebird.Profiler do
       ""
     ]
 
-    func_lines = profiles
+    func_lines =
+      profiles
       |> Enum.reject(fn {_, stats} -> Map.has_key?(stats, :error) end)
       |> Enum.sort_by(fn {_, stats} -> stats.avg_us end)
       |> Enum.map(fn {name, stats} ->
@@ -291,7 +303,16 @@ defmodule Firebird.Profiler do
     count = length(sorted)
 
     if count == 0 do
-      %{function: name, avg_us: 0.0, min_us: 0, max_us: 0, p50_us: 0.0, p95_us: 0.0, p99_us: 0.0, stddev_us: 0.0}
+      %{
+        function: name,
+        avg_us: 0.0,
+        min_us: 0,
+        max_us: 0,
+        p50_us: 0.0,
+        p95_us: 0.0,
+        p99_us: 0.0,
+        stddev_us: 0.0
+      }
     else
       sum = Enum.sum(sorted)
       avg = sum / count
@@ -313,26 +334,31 @@ defmodule Firebird.Profiler do
   end
 
   defp percentile(sorted, p) when length(sorted) > 0 do
-    k = (p / 100) * (length(sorted) - 1)
+    k = p / 100 * (length(sorted) - 1)
     f = trunc(k)
     c = min(f + 1, length(sorted) - 1)
     lower = Enum.at(sorted, f)
     upper = Enum.at(sorted, c)
     lower + (upper - lower) * (k - f)
   end
+
   defp percentile(_, _), do: 0.0
 
   defp stddev(values, mean) when length(values) > 1 do
-    variance = Enum.reduce(values, 0.0, fn v, acc ->
-      diff = v - mean
-      acc + diff * diff
-    end) / (length(values) - 1)
+    variance =
+      Enum.reduce(values, 0.0, fn v, acc ->
+        diff = v - mean
+        acc + diff * diff
+      end) / (length(values) - 1)
+
     :math.sqrt(variance)
   end
+
   defp stddev(_, _), do: 0.0
 
   defp summarize_profiles(profiles) do
-    valid = profiles
+    valid =
+      profiles
       |> Enum.reject(fn {_, stats} -> Map.has_key?(stats, :error) end)
       |> Enum.map(fn {name, stats} -> {name, stats.avg_us} end)
 
diff --git a/lib/firebird/quick.ex b/lib/firebird/quick.ex
index 91655ec..7ef9355 100644
--- a/lib/firebird/quick.ex
+++ b/lib/firebird/quick.ex
@@ -116,12 +116,14 @@ defmodule Firebird.Quick do
   def load_as_functions(wasm_source, opts \\ []) do
     {:ok, instance} = Firebird.load(wasm_source, opts)
 
-    fns = for func <- Firebird.exports(instance), into: %{} do
-      callable = fn args ->
-        Firebird.call(instance, func, args)
+    fns =
+      for func <- Firebird.exports(instance), into: %{} do
+        callable = fn args ->
+          Firebird.call(instance, func, args)
+        end
+
+        {func, callable}
       end
-      {func, callable}
-    end
 
     Map.put(fns, :__instance__, instance)
     |> Map.put(:__stop__, fn -> Firebird.stop(instance) end)
diff --git a/lib/firebird/runtime.ex b/lib/firebird/runtime.ex
index a03c12e..be51bfd 100644
--- a/lib/firebird/runtime.ex
+++ b/lib/firebird/runtime.ex
@@ -22,8 +22,10 @@ defmodule Firebird.Runtime do
   - Serialization/deserialization of compiled modules
   """
 
-  @default_memory_limit 67_108_864  # 64MB
-  @default_timeout 5_000  # 5 seconds
+  # 64MB
+  @default_memory_limit 67_108_864
+  # 5 seconds
+  @default_timeout 5_000
 
   @doc """
   Load a WASM module and start an instance.
@@ -52,8 +54,11 @@ defmodule Firebird.Runtime do
     else
       if String.printable?(wasm_source) do
         resolved = resolve_wasm_path(wasm_source)
+
         case File.read(resolved) do
-          {:ok, bytes} -> load_bytes(bytes, opts)
+          {:ok, bytes} ->
+            load_bytes(bytes, opts)
+
           {:error, reason} ->
             # If the resolved path differs from the original, the file wasn't found
             # in any search location. Provide the original path for backward compat.
@@ -138,9 +143,12 @@ defmodule Firebird.Runtime do
   defp load_bytes_sync(bytes) do
     # Write bytes to a temp file since SyncNif.load expects a path
     # TODO: add SyncNif.load_bytes for direct binary loading
-    tmp_path = Path.join(System.tmp_dir!(), "firebird_sync_#{:erlang.unique_integer([:positive])}.wasm")
+    tmp_path =
+      Path.join(System.tmp_dir!(), "firebird_sync_#{:erlang.unique_integer([:positive])}.wasm")
+
     try do
       File.write!(tmp_path, bytes)
+
       case Firebird.SyncNif.load(tmp_path) do
         {:ok, ref} -> {:ok, ref}
         {:error, reason} -> {:error, {:wasm_error, reason}}
@@ -155,10 +163,17 @@ defmodule Firebird.Runtime do
 
     start_opts =
       case wasi do
-        false -> start_opts
-        true -> Map.put(start_opts, :wasi, %Wasmex.Wasi.WasiOptions{})
-        %Wasmex.Wasi.WasiOptions{} = w -> Map.put(start_opts, :wasi, w)
-        opts when is_map(opts) -> Map.put(start_opts, :wasi, struct(Wasmex.Wasi.WasiOptions, opts))
+        false ->
+          start_opts
+
+        true ->
+          Map.put(start_opts, :wasi, %Wasmex.Wasi.WasiOptions{})
+
+        %Wasmex.Wasi.WasiOptions{} = w ->
+          Map.put(start_opts, :wasi, w)
+
+        opts when is_map(opts) ->
+          Map.put(start_opts, :wasi, struct(Wasmex.Wasi.WasiOptions, opts))
       end
 
     try do
@@ -206,6 +221,7 @@ defmodule Firebird.Runtime do
       catch
         :exit, {:noproc, _} ->
           {:error, {:call_error, function, :instance_stopped}}
+
         :exit, reason ->
           {:error, {:call_error, function, {:exit, reason}}}
       end
@@ -222,17 +238,19 @@ defmodule Firebird.Runtime do
         results
 
       {:error, {:call_error, func_name, reason}} ->
-        suggestion = if Process.alive?(pid) do
-          available = exports(pid) |> Enum.map(&to_string/1)
-          if to_string(func_name) not in available do
-            "\n\nAvailable functions: #{Enum.join(available, ", ")}" <>
-            "\nDid you mean: #{suggest_function(to_string(func_name), available)}"
+        suggestion =
+          if Process.alive?(pid) do
+            available = exports(pid) |> Enum.map(&to_string/1)
+
+            if to_string(func_name) not in available do
+              "\n\nAvailable functions: #{Enum.join(available, ", ")}" <>
+                "\nDid you mean: #{suggest_function(to_string(func_name), available)}"
+            else
+              "\n\nThe function exists but the call failed. Check argument types/count."
+            end
           else
-            "\n\nThe function exists but the call failed. Check argument types/count."
+            "\n\nThe WASM instance is no longer alive."
           end
-        else
-          "\n\nThe WASM instance is no longer alive."
-        end
 
         raise "WASM call to '#{func_name}' failed: #{inspect(reason)}#{suggestion}"
 
@@ -276,7 +294,8 @@ defmodule Firebird.Runtime do
         |> Enum.filter(fn {_name, type} -> match?({:fn, _, _}, type) end)
         |> Enum.map(fn {name, _type} -> String.to_atom(name) end)
 
-      _ -> []
+      _ ->
+        []
     end
   end
 
@@ -297,7 +316,8 @@ defmodule Firebird.Runtime do
           {name, other} -> {name, other}
         end)
 
-      _ -> []
+      _ ->
+        []
     end
   end
 
@@ -313,7 +333,8 @@ defmodule Firebird.Runtime do
       {:ok, {[:i32], [:i32]}} = Firebird.Runtime.function_type(instance, :fibonacci)
       {:error, :not_found} = Firebird.Runtime.function_type(instance, :nonexistent)
   """
-  @spec function_type(pid(), atom() | String.t()) :: {:ok, {list(), list()}} | {:error, :not_found}
+  @spec function_type(pid(), atom() | String.t()) ::
+          {:ok, {list(), list()}} | {:error, :not_found}
   def function_type(pid, function) when is_atom(function) do
     function_type(pid, Atom.to_string(function))
   end
@@ -322,11 +343,14 @@ defmodule Firebird.Runtime do
     case Wasmex.module(pid) do
       {:ok, module} ->
         exports = Wasmex.Module.exports(module)
+
         case Map.get(exports, function) do
           {:fn, params, results} -> {:ok, {params, results}}
           _ -> {:error, :not_found}
         end
-      _ -> {:error, :not_found}
+
+      _ ->
+        {:error, :not_found}
     end
   end
 
@@ -344,7 +368,8 @@ defmodule Firebird.Runtime do
   @doc """
   Access the linear memory and store of a WASM instance.
   """
-  @spec memory(pid()) :: {:ok, %{memory: Wasmex.Memory.t(), store: reference()}} | {:error, term()}
+  @spec memory(pid()) ::
+          {:ok, %{memory: Wasmex.Memory.t(), store: reference()}} | {:error, term()}
   def memory(pid) do
     with {:ok, mem} <- Wasmex.memory(pid),
          {:ok, store} <- Wasmex.store(pid) do
@@ -357,12 +382,15 @@ defmodule Firebird.Runtime do
   @doc """
   Read bytes from WASM linear memory.
   """
-  @spec read_memory(pid(), non_neg_integer(), non_neg_integer()) :: {:ok, binary()} | {:error, term()}
+  @spec read_memory(pid(), non_neg_integer(), non_neg_integer()) ::
+          {:ok, binary()} | {:error, term()}
   def read_memory(pid, offset, length) do
     case memory(pid) do
       {:ok, %{memory: mem, store: store}} ->
         {:ok, Wasmex.Memory.read_binary(store, mem, offset, length)}
-      error -> error
+
+      error ->
+        error
     end
   end
 
@@ -375,7 +403,9 @@ defmodule Firebird.Runtime do
       {:ok, %{memory: mem, store: store}} ->
         Wasmex.Memory.write_binary(store, mem, offset, data)
         :ok
-      error -> error
+
+      error ->
+        error
     end
   end
 
@@ -387,7 +417,9 @@ defmodule Firebird.Runtime do
     case memory(pid) do
       {:ok, %{memory: mem, store: store}} ->
         {:ok, Wasmex.Memory.size(store, mem)}
-      error -> error
+
+      error ->
+        error
     end
   end
 
@@ -399,7 +431,9 @@ defmodule Firebird.Runtime do
     case memory(pid) do
       {:ok, %{memory: mem, store: store}} ->
         {:ok, Wasmex.Memory.grow(store, mem, pages)}
-      error -> error
+
+      error ->
+        error
     end
   end
 
diff --git a/lib/firebird/sandbox.ex b/lib/firebird/sandbox.ex
index f74bf8d..266473c 100644
--- a/lib/firebird/sandbox.ex
+++ b/lib/firebird/sandbox.ex
@@ -158,6 +158,7 @@ defmodule Firebird.Sandbox do
           max_calls: Keyword.get(sandbox_opts, :max_calls, :infinity),
           max_memory: Keyword.get(sandbox_opts, :max_memory, :infinity)
         }
+
         {:ok, state}
 
       {:error, reason} ->
@@ -179,9 +180,10 @@ defmodule Firebird.Sandbox do
       case check_memory(state) do
         :ok ->
           # Execute with timeout
-          task = Task.async(fn ->
-            Firebird.call(state.instance, function, args)
-          end)
+          task =
+            Task.async(fn ->
+              Firebird.call(state.instance, function, args)
+            end)
 
           case Task.yield(task, state.timeout) || Task.shutdown(task) do
             {:ok, {:ok, result}} ->
@@ -207,10 +209,11 @@ defmodule Firebird.Sandbox do
     now = System.monotonic_time(:millisecond)
     uptime = now - state.started_at
 
-    memory_bytes = case Firebird.memory_size(state.instance) do
-      {:ok, size} -> size
-      _ -> 0
-    end
+    memory_bytes =
+      case Firebird.memory_size(state.instance) do
+        {:ok, size} -> size
+        _ -> 0
+      end
 
     usage = %{
       calls: state.calls,
@@ -242,10 +245,12 @@ defmodule Firebird.Sandbox do
     if state.instance && Process.alive?(state.instance) do
       Firebird.stop(state.instance)
     end
+
     :ok
   end
 
   defp check_memory(%{max_memory: :infinity}), do: :ok
+
   defp check_memory(%{instance: instance, max_memory: max}) do
     case Firebird.memory_size(instance) do
       {:ok, size} when size <= max -> :ok
diff --git a/lib/firebird/sigils.ex b/lib/firebird/sigils.ex
index ae55eca..3586e3a 100644
--- a/lib/firebird/sigils.ex
+++ b/lib/firebird/sigils.ex
@@ -52,12 +52,15 @@ defmodule Firebird.Sigils do
       {:ok, [10]} = Firebird.call(wasm, :double, [5])
   """
   defmacro wat!(wat_source) do
-    wat_string = case Macro.expand(wat_source, __CALLER__) do
-      s when is_binary(s) -> s
-      _ ->
-        {result, _} = Code.eval_quoted(wat_source, [], __CALLER__)
-        result
-    end
+    wat_string =
+      case Macro.expand(wat_source, __CALLER__) do
+        s when is_binary(s) ->
+          s
+
+        _ ->
+          {result, _} = Code.eval_quoted(wat_source, [], __CALLER__)
+          result
+      end
 
     case compile_wat_to_bytes(wat_string) do
       {:ok, bytes} ->
diff --git a/lib/firebird/stream.ex b/lib/firebird/stream.ex
index 98fe239..9a8d0f0 100644
--- a/lib/firebird/stream.ex
+++ b/lib/firebird/stream.ex
@@ -55,6 +55,7 @@ defmodule Firebird.Stream do
   def map(enumerable, instance, function) do
     Stream.map(enumerable, fn input ->
       args = normalize_args(input)
+
       case Firebird.call(instance, function, args) do
         {:ok, [single]} -> single
         {:ok, multi} -> multi
@@ -77,6 +78,7 @@ defmodule Firebird.Stream do
   def map_raw(enumerable, instance, function) do
     Stream.map(enumerable, fn input ->
       args = normalize_args(input)
+
       case Firebird.call(instance, function, args) do
         {:ok, results} -> results
         {:error, reason} -> raise "Stream WASM call failed: #{inspect(reason)}"
@@ -102,6 +104,7 @@ defmodule Firebird.Stream do
   def filter(enumerable, instance, function) do
     Stream.filter(enumerable, fn input ->
       args = normalize_args(input)
+
       case Firebird.call(instance, function, args) do
         {:ok, [0]} -> false
         {:ok, [_]} -> true
@@ -157,7 +160,10 @@ defmodule Firebird.Stream do
       {:ok, _} -> true
       _ -> false
     end)
-    |> Stream.map(fn {:ok, [single]} -> single; {:ok, multi} -> multi end)
+    |> Stream.map(fn
+      {:ok, [single]} -> single
+      {:ok, multi} -> multi
+    end)
   end
 
   # Normalize various input formats to a list of args
diff --git a/lib/firebird/sync_nif.ex b/lib/firebird/sync_nif.ex
index 9297d71..6eb72c4 100644
--- a/lib/firebird/sync_nif.ex
+++ b/lib/firebird/sync_nif.ex
@@ -114,7 +114,8 @@ defmodule Firebird.SyncNif do
 
   Returns `{:ok, [binary]}` or `{:error, reason}`.
   """
-  def call_fast_render_indexed_batch(_instance, _values_list), do: :erlang.nif_error(:nif_not_loaded)
+  def call_fast_render_indexed_batch(_instance, _values_list),
+    do: :erlang.nif_error(:nif_not_loaded)
 
   @doc """
   FAST compile call (normal scheduler).
diff --git a/lib/firebird/target.ex b/lib/firebird/target.ex
index a6b5ece..80e9ca6 100644
--- a/lib/firebird/target.ex
+++ b/lib/firebird/target.ex
@@ -113,7 +113,7 @@ defmodule Firebird.Target do
   """
   @spec compile_files([String.t()], keyword()) :: {:ok, [map()]} | {:error, term()}
   def compile_files(files, opts \\ []) do
-    config = Config.new(Keyword.merge(opts, [files: files, sources: []]))
+    config = Config.new(Keyword.merge(opts, files: files, sources: []))
     compile(config)
   end
 
diff --git a/lib/firebird/target/benchmark.ex b/lib/firebird/target/benchmark.ex
index e62a1cf..ee29671 100644
--- a/lib/firebird/target/benchmark.ex
+++ b/lib/firebird/target/benchmark.ex
@@ -168,14 +168,16 @@ defmodule Firebird.Target.Benchmark do
     correct = wasm_result == beam_result
 
     # Benchmark WASM
-    wasm_times = time_iterations(iterations, fn ->
-      Firebird.call(instance, func_str, args)
-    end)
+    wasm_times =
+      time_iterations(iterations, fn ->
+        Firebird.call(instance, func_str, args)
+      end)
 
     # Benchmark BEAM
-    beam_times = time_iterations(iterations, fn ->
-      apply_beam_fn(beam_fn, args)
-    end)
+    beam_times =
+      time_iterations(iterations, fn ->
+        apply_beam_fn(beam_fn, args)
+      end)
 
     Firebird.stop(instance)
 
@@ -185,12 +187,15 @@ defmodule Firebird.Target.Benchmark do
     speedup = if wasm_stats.avg > 0, do: beam_stats.avg / wasm_stats.avg, else: 0.0
 
     optimizations =
-      Enum.filter([
-        if(compiler_opts[:optimize], do: "opt"),
-        if(compiler_opts[:tco], do: "tco"),
-        if(compiler_opts[:inline], do: "inline"),
-        if(compiler_opts[:licm], do: "licm")
-      ], & &1)
+      Enum.filter(
+        [
+          if(compiler_opts[:optimize], do: "opt"),
+          if(compiler_opts[:tco], do: "tco"),
+          if(compiler_opts[:inline], do: "inline"),
+          if(compiler_opts[:licm], do: "licm")
+        ],
+        & &1
+      )
 
     %{
       name: "#{function_name}(#{Enum.join(args, ", ")})",
@@ -323,15 +328,18 @@ defmodule Firebird.Target.Benchmark do
   """
   @spec format_json([map()]) :: String.t()
   def format_json(results) do
-    Jason.encode!(%{
-      timestamp: DateTime.utc_now() |> DateTime.to_iso8601(),
-      benchmarks: results,
-      summary: %{
-        total: length(results),
-        correct: Enum.count(results, & &1.correct),
-        avg_speedup: avg_speedup(results)
-      }
-    }, pretty: true)
+    Jason.encode!(
+      %{
+        timestamp: DateTime.utc_now() |> DateTime.to_iso8601(),
+        benchmarks: results,
+        summary: %{
+          total: length(results),
+          correct: Enum.count(results, & &1.correct),
+          avg_speedup: avg_speedup(results)
+        }
+      },
+      pretty: true
+    )
   end
 
   @doc """
@@ -358,8 +366,11 @@ defmodule Firebird.Target.Benchmark do
   """
   @spec format_comparison_markdown([map()]) :: String.t()
   def format_comparison_markdown(results) do
-    header = "| Benchmark | Raw WASM (μs) | Opt WASM (μs) | BEAM (μs) | Opt Gain | vs BEAM | Correct |"
-    separator = "|-----------|---------------|---------------|-----------|----------|---------|---------|"
+    header =
+      "| Benchmark | Raw WASM (μs) | Opt WASM (μs) | BEAM (μs) | Opt Gain | vs BEAM | Correct |"
+
+    separator =
+      "|-----------|---------------|---------------|-----------|----------|---------|---------|"
 
     rows =
       Enum.map(results, fn r ->
@@ -376,11 +387,13 @@ defmodule Firebird.Target.Benchmark do
   """
   @spec format_csv([map()]) :: String.t()
   def format_csv(results) do
-    header = "name,function,wasm_avg_us,beam_avg_us,speedup,correct,wasm_p95,beam_p95,wasm_bytes,optimizations"
+    header =
+      "name,function,wasm_avg_us,beam_avg_us,speedup,correct,wasm_p95,beam_p95,wasm_bytes,optimizations"
 
     rows =
       Enum.map(results, fn r ->
         opts = Map.get(r, :optimizations, []) |> Enum.join("+")
+
         [
           r.name,
           to_string(r.function),
@@ -407,70 +420,185 @@ defmodule Firebird.Target.Benchmark do
 
     [
       # Simple arithmetic
-      %{name: "add(100, 200)", source: math_source, function: :add, args: [100, 200],
-        beam_fn: fn a, b -> a + b end},
-      %{name: "multiply(12, 34)", source: math_source, function: :multiply, args: [12, 34],
-        beam_fn: fn a, b -> a * b end},
+      %{
+        name: "add(100, 200)",
+        source: math_source,
+        function: :add,
+        args: [100, 200],
+        beam_fn: fn a, b -> a + b end
+      },
+      %{
+        name: "multiply(12, 34)",
+        source: math_source,
+        function: :multiply,
+        args: [12, 34],
+        beam_fn: fn a, b -> a * b end
+      },
 
       # Pattern matching
-      %{name: "abs_val(-42)", source: math_source, function: :abs_val, args: [-42],
-        beam_fn: fn n -> abs(n) end},
-      %{name: "max_val(10, 20)", source: math_source, function: :max_val, args: [10, 20],
-        beam_fn: fn a, b -> max(a, b) end},
+      %{
+        name: "abs_val(-42)",
+        source: math_source,
+        function: :abs_val,
+        args: [-42],
+        beam_fn: fn n -> abs(n) end
+      },
+      %{
+        name: "max_val(10, 20)",
+        source: math_source,
+        function: :max_val,
+        args: [10, 20],
+        beam_fn: fn a, b -> max(a, b) end
+      },
 
       # Light recursion (fibonacci is NOT tail-recursive — tests raw call overhead)
-      %{name: "fibonacci(10)", source: math_source, function: :fibonacci, args: [10],
-        beam_fn: &beam_fibonacci/1},
-      %{name: "fibonacci(20)", source: math_source, function: :fibonacci, args: [20],
-        beam_fn: &beam_fibonacci/1},
+      %{
+        name: "fibonacci(10)",
+        source: math_source,
+        function: :fibonacci,
+        args: [10],
+        beam_fn: &beam_fibonacci/1
+      },
+      %{
+        name: "fibonacci(20)",
+        source: math_source,
+        function: :fibonacci,
+        args: [20],
+        beam_fn: &beam_fibonacci/1
+      },
 
       # Factorial (recursive, benefits from TCO via accumulator variant)
-      %{name: "factorial(10)", source: math_source, function: :factorial, args: [10],
-        beam_fn: &beam_factorial/1},
-      %{name: "factorial(15)", source: math_source, function: :factorial, args: [15],
-        beam_fn: &beam_factorial/1},
+      %{
+        name: "factorial(10)",
+        source: math_source,
+        function: :factorial,
+        args: [10],
+        beam_fn: &beam_factorial/1
+      },
+      %{
+        name: "factorial(15)",
+        source: math_source,
+        function: :factorial,
+        args: [15],
+        beam_fn: &beam_factorial/1
+      },
 
       # Tail-recursive accumulator variants — these are the TCO showcase
-      %{name: "factorial_acc(15, 1)", source: math_source, function: :factorial_acc, args: [15, 1],
-        beam_fn: fn n, acc -> beam_factorial_acc(n, acc) end},
-      %{name: "factorial_acc(20, 1)", source: math_source, function: :factorial_acc, args: [20, 1],
-        beam_fn: fn n, acc -> beam_factorial_acc(n, acc) end},
-      %{name: "sum_to_acc(1000, 0)", source: math_source, function: :sum_to_acc, args: [1000, 0],
-        beam_fn: fn n, acc -> beam_sum_to_acc(n, acc) end},
-      %{name: "sum_to_acc(5000, 0)", source: math_source, function: :sum_to_acc, args: [5000, 0],
-        beam_fn: fn n, acc -> beam_sum_to_acc(n, acc) end},
+      %{
+        name: "factorial_acc(15, 1)",
+        source: math_source,
+        function: :factorial_acc,
+        args: [15, 1],
+        beam_fn: fn n, acc -> beam_factorial_acc(n, acc) end
+      },
+      %{
+        name: "factorial_acc(20, 1)",
+        source: math_source,
+        function: :factorial_acc,
+        args: [20, 1],
+        beam_fn: fn n, acc -> beam_factorial_acc(n, acc) end
+      },
+      %{
+        name: "sum_to_acc(1000, 0)",
+        source: math_source,
+        function: :sum_to_acc,
+        args: [1000, 0],
+        beam_fn: fn n, acc -> beam_sum_to_acc(n, acc) end
+      },
+      %{
+        name: "sum_to_acc(5000, 0)",
+        source: math_source,
+        function: :sum_to_acc,
+        args: [5000, 0],
+        beam_fn: fn n, acc -> beam_sum_to_acc(n, acc) end
+      },
 
       # Math operations (gcd is naturally tail-recursive)
-      %{name: "gcd(48, 18)", source: math_source, function: :gcd, args: [48, 18],
-        beam_fn: fn a, b -> Integer.gcd(a, b) end},
-      %{name: "gcd(1071, 462)", source: math_source, function: :gcd, args: [1071, 462],
-        beam_fn: fn a, b -> Integer.gcd(a, b) end},
-      %{name: "power(2, 20)", source: math_source, function: :power, args: [2, 20],
-        beam_fn: fn base, exp -> Integer.pow(base, exp) end},
+      %{
+        name: "gcd(48, 18)",
+        source: math_source,
+        function: :gcd,
+        args: [48, 18],
+        beam_fn: fn a, b -> Integer.gcd(a, b) end
+      },
+      %{
+        name: "gcd(1071, 462)",
+        source: math_source,
+        function: :gcd,
+        args: [1071, 462],
+        beam_fn: fn a, b -> Integer.gcd(a, b) end
+      },
+      %{
+        name: "power(2, 20)",
+        source: math_source,
+        function: :power,
+        args: [2, 20],
+        beam_fn: fn base, exp -> Integer.pow(base, exp) end
+      },
 
       # Summation recursion (non-accumulator — limited depth)
-      %{name: "sum_to(100)", source: math_source, function: :sum_to, args: [100],
-        beam_fn: &beam_sum_to/1},
+      %{
+        name: "sum_to(100)",
+        source: math_source,
+        function: :sum_to,
+        args: [100],
+        beam_fn: &beam_sum_to/1
+      },
 
       # Collatz sequence
-      %{name: "collatz_steps(27)", source: math_source, function: :collatz_steps, args: [27],
-        beam_fn: &beam_collatz_steps/1},
+      %{
+        name: "collatz_steps(27)",
+        source: math_source,
+        function: :collatz_steps,
+        args: [27],
+        beam_fn: &beam_collatz_steps/1
+      },
 
       # Collatz with accumulator — tail-recursive, benefits heavily from TCO
-      %{name: "collatz_acc(27, 0)", source: math_source, function: :collatz_acc, args: [27, 0],
-        beam_fn: fn n, acc -> beam_collatz_acc(n, acc) end},
-      %{name: "collatz_acc(871, 0)", source: math_source, function: :collatz_acc, args: [871, 0],
-        beam_fn: fn n, acc -> beam_collatz_acc(n, acc) end},
+      %{
+        name: "collatz_acc(27, 0)",
+        source: math_source,
+        function: :collatz_acc,
+        args: [27, 0],
+        beam_fn: fn n, acc -> beam_collatz_acc(n, acc) end
+      },
+      %{
+        name: "collatz_acc(871, 0)",
+        source: math_source,
+        function: :collatz_acc,
+        args: [871, 0],
+        beam_fn: fn n, acc -> beam_collatz_acc(n, acc) end
+      },
 
       # Block-TCO: tail-recursive with let bindings (exercises block codegen in TCO)
-      %{name: "sum_squares_acc(100, 0)", source: math_source, function: :sum_squares_acc, args: [100, 0],
-        beam_fn: fn n, acc -> beam_sum_squares_acc(n, acc) end},
-      %{name: "sum_squares_acc(1000, 0)", source: math_source, function: :sum_squares_acc, args: [1000, 0],
-        beam_fn: fn n, acc -> beam_sum_squares_acc(n, acc) end},
-      %{name: "weighted_collatz(27, 0)", source: math_source, function: :weighted_collatz, args: [27, 0],
-        beam_fn: fn n, acc -> beam_weighted_collatz(n, acc) end},
-      %{name: "weighted_collatz(871, 0)", source: math_source, function: :weighted_collatz, args: [871, 0],
-        beam_fn: fn n, acc -> beam_weighted_collatz(n, acc) end}
+      %{
+        name: "sum_squares_acc(100, 0)",
+        source: math_source,
+        function: :sum_squares_acc,
+        args: [100, 0],
+        beam_fn: fn n, acc -> beam_sum_squares_acc(n, acc) end
+      },
+      %{
+        name: "sum_squares_acc(1000, 0)",
+        source: math_source,
+        function: :sum_squares_acc,
+        args: [1000, 0],
+        beam_fn: fn n, acc -> beam_sum_squares_acc(n, acc) end
+      },
+      %{
+        name: "weighted_collatz(27, 0)",
+        source: math_source,
+        function: :weighted_collatz,
+        args: [27, 0],
+        beam_fn: fn n, acc -> beam_weighted_collatz(n, acc) end
+      },
+      %{
+        name: "weighted_collatz(871, 0)",
+        source: math_source,
+        function: :weighted_collatz,
+        args: [871, 0],
+        beam_fn: fn n, acc -> beam_weighted_collatz(n, acc) end
+      }
     ]
   end
 
@@ -593,7 +721,12 @@ defmodule Firebird.Target.Benchmark do
 
     # Compile optimized (all passes including LICM)
     opt_result =
-      case Firebird.Compiler.compile_source(source, optimize: true, tco: true, inline: true, licm: true) do
+      case Firebird.Compiler.compile_source(source,
+             optimize: true,
+             tco: true,
+             inline: true,
+             licm: true
+           ) do
         {:ok, r} -> r
         {:error, reason} -> {:error, reason}
       end
@@ -602,7 +735,6 @@ defmodule Firebird.Target.Benchmark do
          %{wasm: opt_wasm} when opt_wasm != nil <- opt_result,
          {:ok, unopt_instance} <- Firebird.load(unopt_wasm),
          {:ok, opt_instance} <- Firebird.load(opt_wasm) do
-
       # Warmup all three
       for _ <- 1..warmup do
         safe_call(unopt_instance, func_str, args)
@@ -612,27 +744,32 @@ defmodule Firebird.Target.Benchmark do
 
       # Verify correctness (use optimized as reference)
       beam_result = apply_beam_fn(beam_fn, args)
+
       opt_wasm_result =
         case Firebird.call(opt_instance, func_str, args) do
           {:ok, [val]} -> val
           _ -> :error
         end
+
       correct = opt_wasm_result == beam_result
 
       # Benchmark unoptimized WASM
-      unopt_times = time_iterations(iterations, fn ->
-        safe_call(unopt_instance, func_str, args)
-      end)
+      unopt_times =
+        time_iterations(iterations, fn ->
+          safe_call(unopt_instance, func_str, args)
+        end)
 
       # Benchmark optimized WASM
-      opt_times = time_iterations(iterations, fn ->
-        Firebird.call(opt_instance, func_str, args)
-      end)
+      opt_times =
+        time_iterations(iterations, fn ->
+          Firebird.call(opt_instance, func_str, args)
+        end)
 
       # Benchmark BEAM
-      beam_times = time_iterations(iterations, fn ->
-        apply_beam_fn(beam_fn, args)
-      end)
+      beam_times =
+        time_iterations(iterations, fn ->
+          apply_beam_fn(beam_fn, args)
+        end)
 
       Firebird.stop(unopt_instance)
       Firebird.stop(opt_instance)
@@ -646,21 +783,22 @@ defmodule Firebird.Target.Benchmark do
       # Optimized WASM vs BEAM
       opt_vs_beam = if opt_stats.avg > 0, do: beam_stats.avg / opt_stats.avg, else: 0.0
 
-      {:ok, %{
-        name: "#{func_name}(#{Enum.join(args, ", ")})",
-        function: func_name,
-        args: args,
-        correct: correct,
-        unoptimized: unopt_stats,
-        optimized: opt_stats,
-        beam: beam_stats,
-        opt_vs_raw: Float.round(opt_vs_raw, 3),
-        opt_vs_beam: Float.round(opt_vs_beam, 3),
-        unopt_wasm_size: byte_size(unopt_result.wasm),
-        opt_wasm_size: byte_size(opt_result.wasm),
-        size_reduction: byte_size(unopt_result.wasm) - byte_size(opt_result.wasm),
-        iterations: iterations
-      }}
+      {:ok,
+       %{
+         name: "#{func_name}(#{Enum.join(args, ", ")})",
+         function: func_name,
+         args: args,
+         correct: correct,
+         unoptimized: unopt_stats,
+         optimized: opt_stats,
+         beam: beam_stats,
+         opt_vs_raw: Float.round(opt_vs_raw, 3),
+         opt_vs_beam: Float.round(opt_vs_beam, 3),
+         unopt_wasm_size: byte_size(unopt_result.wasm),
+         opt_wasm_size: byte_size(opt_result.wasm),
+         size_reduction: byte_size(unopt_result.wasm) - byte_size(opt_result.wasm),
+         iterations: iterations
+       }}
     else
       _ -> {:error, {:compilation_failed, func_name}}
     end
@@ -703,8 +841,9 @@ defmodule Firebird.Target.Benchmark do
   end
 
   defp percentile([], _p), do: 0
+
   defp percentile(sorted, p) do
-    k = (p / 100) * (length(sorted) - 1)
+    k = p / 100 * (length(sorted) - 1)
     f = trunc(k)
     c = Float.ceil(k) |> trunc()
 
@@ -719,6 +858,7 @@ defmodule Firebird.Target.Benchmark do
 
   defp stddev(values, mean) do
     count = length(values)
+
     if count <= 1 do
       0.0
     else
@@ -734,6 +874,7 @@ defmodule Firebird.Target.Benchmark do
 
   defp avg_speedup(results) do
     total = length(results)
+
     if total > 0 do
       Enum.map(results, & &1.speedup) |> Enum.sum() |> Kernel./(total) |> Float.round(3)
     else
@@ -776,6 +917,7 @@ defmodule Firebird.Target.Benchmark do
   defp beam_sum_to_acc(n, acc), do: beam_sum_to_acc(n - 1, acc + n)
 
   defp beam_collatz_steps(1), do: 0
+
   defp beam_collatz_steps(n) do
     if rem(n, 2) == 0 do
       1 + beam_collatz_steps(div(n, 2))
@@ -785,6 +927,7 @@ defmodule Firebird.Target.Benchmark do
   end
 
   defp beam_collatz_acc(1, acc), do: acc
+
   defp beam_collatz_acc(n, acc) do
     if rem(n, 2) == 0 do
       beam_collatz_acc(div(n, 2), acc + 1)
@@ -794,14 +937,17 @@ defmodule Firebird.Target.Benchmark do
   end
 
   defp beam_sum_squares_acc(0, acc), do: acc
+
   defp beam_sum_squares_acc(n, acc) do
     sq = n * n
     beam_sum_squares_acc(n - 1, acc + sq)
   end
 
   defp beam_weighted_collatz(1, acc), do: acc
+
   defp beam_weighted_collatz(n, acc) do
     weight = rem(n, 7) + 1
+
     if rem(n, 2) == 0 do
       beam_weighted_collatz(div(n, 2), acc + weight)
     else
diff --git a/lib/firebird/target/diagnostics.ex b/lib/firebird/target/diagnostics.ex
index 912d347..a4a7c0f 100644
--- a/lib/firebird/target/diagnostics.ex
+++ b/lib/firebird/target/diagnostics.ex
@@ -20,19 +20,19 @@ defmodule Firebird.Target.Diagnostics do
 
   @type severity :: :error | :warning | :info | :hint
   @type diagnostic :: %{
-    severity: severity(),
-    message: String.t(),
-    line: non_neg_integer() | nil,
-    source: String.t() | nil
-  }
+          severity: severity(),
+          message: String.t(),
+          line: non_neg_integer() | nil,
+          source: String.t() | nil
+        }
   @type report :: %{
-    file: String.t(),
-    module: atom() | nil,
-    compilable: boolean(),
-    diagnostics: [diagnostic()],
-    function_count: non_neg_integer(),
-    estimated_wasm_size: non_neg_integer() | nil
-  }
+          file: String.t(),
+          module: atom() | nil,
+          compilable: boolean(),
+          diagnostics: [diagnostic()],
+          function_count: non_neg_integer(),
+          estimated_wasm_size: non_neg_integer() | nil
+        }
 
   @unsupported_patterns [
     {~r/spawn\s*\(/, "Process spawning not supported in WASM"},
@@ -62,7 +62,8 @@ defmodule Firebird.Target.Diagnostics do
   ]
 
   @optimization_hints [
-    {~r/def\s+\w+\(.*\)\s*do\s*\n\s*\w+\(/, "Function may benefit from --tco (tail call optimization)"},
+    {~r/def\s+\w+\(.*\)\s*do\s*\n\s*\w+\(/,
+     "Function may benefit from --tco (tail call optimization)"},
     {~r/def\s+\w+\([^)]*\),\s*do:\s*\d+/, "Small constant functions may benefit from --inline"}
   ]
 
@@ -77,6 +78,7 @@ defmodule Firebird.Target.Diagnostics do
       {:ok, code} ->
         report = analyze_code(code, path)
         {:ok, report}
+
       {:error, reason} ->
         {:error, {:file_read_error, reason, path}}
     end
@@ -107,6 +109,7 @@ defmodule Firebird.Target.Diagnostics do
           [{start, _}] ->
             line = code |> String.slice(0, start) |> String.split("\n") |> length()
             [%{severity: :warning, message: message, line: line, source: file}]
+
           _ ->
             []
         end
@@ -134,9 +137,17 @@ defmodule Firebird.Target.Diagnostics do
           module = extract_module_name(ast)
           funcs = count_wasm_functions(ast)
           {module, funcs, []}
+
         {:error, {meta, msg, token}} ->
           line = if is_tuple(meta), do: elem(meta, 0), else: nil
-          diag = %{severity: :error, message: "Parse error: #{msg}#{token}", line: line, source: file}
+
+          diag = %{
+            severity: :error,
+            message: "Parse error: #{msg}#{token}",
+            line: line,
+            source: file
+          }
+
           {nil, 0, [diag]}
       end
 
@@ -151,9 +162,25 @@ defmodule Firebird.Target.Diagnostics do
     # Add info diagnostic for function count
     diagnostics =
       if func_count > 0 do
-        diagnostics ++ [%{severity: :info, message: "#{func_count} WASM function(s) found", line: nil, source: file}]
+        diagnostics ++
+          [
+            %{
+              severity: :info,
+              message: "#{func_count} WASM function(s) found",
+              line: nil,
+              source: file
+            }
+          ]
       else
-        diagnostics ++ [%{severity: :info, message: "No @wasm annotated functions - all public functions will be compiled", line: nil, source: file}]
+        diagnostics ++
+          [
+            %{
+              severity: :info,
+              message: "No @wasm annotated functions - all public functions will be compiled",
+              line: nil,
+              source: file
+            }
+          ]
       end
 
     %{
@@ -184,12 +211,14 @@ defmodule Firebird.Target.Diagnostics do
   def format_report(report) do
     lines = []
 
-    lines = lines ++ [
-      "📄 #{report.file || "unknown"}",
-      "   Module: #{report.module || "unknown"}",
-      "   Compilable: #{if report.compilable, do: "✅ yes", else: "❌ no"}",
-      "   Functions: #{report.function_count}"
-    ]
+    lines =
+      lines ++
+        [
+          "📄 #{report.file || "unknown"}",
+          "   Module: #{report.module || "unknown"}",
+          "   Compilable: #{if report.compilable, do: "✅ yes", else: "❌ no"}",
+          "   Functions: #{report.function_count}"
+        ]
 
     lines =
       if report.estimated_wasm_size do
@@ -201,17 +230,19 @@ defmodule Firebird.Target.Diagnostics do
     if Enum.any?(report.diagnostics) do
       lines = lines ++ ["", "   Diagnostics:"]
 
-      diag_lines = Enum.map(report.diagnostics, fn d ->
-        icon = case d.severity do
-          :error -> "❌"
-          :warning -> "⚠️ "
-          :info -> "ℹ️ "
-          :hint -> "💡"
-        end
+      diag_lines =
+        Enum.map(report.diagnostics, fn d ->
+          icon =
+            case d.severity do
+              :error -> "❌"
+              :warning -> "⚠️ "
+              :info -> "ℹ️ "
+              :hint -> "💡"
+            end
 
-        loc = if d.line, do: " (line #{d.line})", else: ""
-        "     #{icon} #{d.message}#{loc}"
-      end)
+          loc = if d.line, do: " (line #{d.line})", else: ""
+          "     #{icon} #{d.message}#{loc}"
+        end)
 
       lines ++ diag_lines
     else
@@ -235,21 +266,26 @@ defmodule Firebird.Target.Diagnostics do
   defp extract_module_name({:defmodule, _, [{:__aliases__, _, parts}, _]}) do
     parts |> Enum.map(&to_string/1) |> Enum.join(".") |> String.to_atom()
   end
+
   defp extract_module_name({:__block__, _, stmts}) do
     Enum.find_value(stmts, fn
       {:defmodule, _, _} = mod -> extract_module_name(mod)
       _ -> nil
     end)
   end
+
   defp extract_module_name(_), do: nil
 
   defp count_wasm_functions(ast) do
-    {_, count} = Macro.prewalk(ast, 0, fn
-      {:@, _, [{:wasm, _, [true]}]} = node, acc ->
-        {node, acc + 1}
-      node, acc ->
-        {node, acc}
-    end)
+    {_, count} =
+      Macro.prewalk(ast, 0, fn
+        {:@, _, [{:wasm, _, [true]}]} = node, acc ->
+          {node, acc + 1}
+
+        node, acc ->
+          {node, acc}
+      end)
+
     count
   end
 end
diff --git a/lib/firebird/target/guard.ex b/lib/firebird/target/guard.ex
index 601aff3..cd1ace3 100644
--- a/lib/firebird/target/guard.ex
+++ b/lib/firebird/target/guard.ex
@@ -63,12 +63,13 @@ defmodule Firebird.Target.Guard do
   """
   @spec compilable_ast?(Macro.t()) :: boolean()
   def compilable_ast?(ast) do
-    {_, issues} = Macro.prewalk(ast, [], fn node, acc ->
-      case check_node(node) do
-        :ok -> {node, acc}
-        {:error, reason} -> {node, [reason | acc]}
-      end
-    end)
+    {_, issues} =
+      Macro.prewalk(ast, [], fn node, acc ->
+        case check_node(node) do
+          :ok -> {node, acc}
+          {:error, reason} -> {node, [reason | acc]}
+        end
+      end)
 
     Enum.empty?(issues)
   end
@@ -81,7 +82,9 @@ defmodule Firebird.Target.Guard do
   @spec check_issues(String.t()) :: [String.t()]
   def check_issues(source) when is_binary(source) do
     case Code.string_to_quoted(source, columns: true) do
-      {:ok, ast} -> ast_issues(ast)
+      {:ok, ast} ->
+        ast_issues(ast)
+
       {:error, {meta, msg, token}} ->
         line = if is_tuple(meta), do: elem(meta, 0), else: 0
         ["Parse error at line #{line}: #{msg}#{token}"]
@@ -114,12 +117,13 @@ defmodule Firebird.Target.Guard do
   # Private - check individual AST nodes
 
   defp ast_issues(ast) do
-    {_, issues} = Macro.prewalk(ast, [], fn node, acc ->
-      case check_node(node) do
-        :ok -> {node, acc}
-        {:error, reason} -> {node, [reason | acc]}
-      end
-    end)
+    {_, issues} =
+      Macro.prewalk(ast, [], fn node, acc ->
+        case check_node(node) do
+          :ok -> {node, acc}
+          {:error, reason} -> {node, [reason | acc]}
+        end
+      end)
 
     Enum.reverse(issues) |> Enum.uniq()
   end
@@ -139,8 +143,8 @@ defmodule Firebird.Target.Guard do
   defp check_node({ctrl, _, _}) when ctrl in @supported_control, do: :ok
 
   # do/end blocks
-  defp check_node([do: _]), do: :ok
-  defp check_node([do: _, else: _]), do: :ok
+  defp check_node(do: _), do: :ok
+  defp check_node(do: _, else: _), do: :ok
 
   # Integer and float literals
   defp check_node(n) when is_integer(n), do: :ok
@@ -192,18 +196,22 @@ defmodule Firebird.Target.Guard do
   defp check_node(list) when is_list(list) do
     # Lists can appear as AST metadata, so only flag non-empty runtime lists
     if Enum.any?(list, fn
-      {key, _} when is_atom(key) -> false  # keyword list (metadata)
-      _ -> true
-    end) do
-      :ok  # Could be AST metadata
+         # keyword list (metadata)
+         {key, _} when is_atom(key) -> false
+         _ -> true
+       end) do
+      # Could be AST metadata
+      :ok
     else
       :ok
     end
   end
 
   # Strings/atoms (in non-metadata context)
-  defp check_node(s) when is_binary(s), do: :ok  # Strings in AST are often module names
-  defp check_node(a) when is_atom(a), do: :ok     # Atoms appear everywhere in AST
+  # Strings in AST are often module names
+  defp check_node(s) when is_binary(s), do: :ok
+  # Atoms appear everywhere in AST
+  defp check_node(a) when is_atom(a), do: :ok
 
   # Catch-all: allow unknown nodes (they may be structural AST elements)
   defp check_node(_), do: :ok
diff --git a/lib/firebird/target/manifest.ex b/lib/firebird/target/manifest.ex
index de22135..b842bff 100644
--- a/lib/firebird/target/manifest.ex
+++ b/lib/firebird/target/manifest.ex
@@ -45,22 +45,22 @@ defmodule Firebird.Target.Manifest do
   @manifest_filename "firebird_manifest.json"
 
   @type t :: %{
-    version: integer(),
-    timestamp: String.t(),
-    output_dir: String.t(),
-    modules: [module_entry()],
-    elapsed_ms: integer() | nil,
-    options: map() | nil
-  }
+          version: integer(),
+          timestamp: String.t(),
+          output_dir: String.t(),
+          modules: [module_entry()],
+          elapsed_ms: integer() | nil,
+          options: map() | nil
+        }
 
   @type module_entry :: %{
-    module: String.t(),
-    wat_file: String.t() | nil,
-    wasm_file: String.t() | nil,
-    wat_size: integer(),
-    wasm_size: integer(),
-    source: String.t() | nil
-  }
+          module: String.t(),
+          wat_file: String.t() | nil,
+          wasm_file: String.t() | nil,
+          wat_size: integer(),
+          wasm_size: integer(),
+          source: String.t() | nil
+        }
 
   @doc """
   Read a manifest from a file path.
@@ -73,6 +73,7 @@ defmodule Firebird.Target.Manifest do
           {:ok, data} -> {:ok, normalize_manifest(data)}
           {:error, reason} -> {:error, {:json_decode_error, reason}}
         end
+
       {:error, reason} ->
         {:error, {:file_read_error, reason}}
     end
@@ -97,6 +98,7 @@ defmodule Firebird.Target.Manifest do
       {:ok, json} ->
         File.mkdir_p!(Path.dirname(path))
         File.write(path, json)
+
       {:error, reason} ->
         {:error, {:json_encode_error, reason}}
     end
@@ -148,6 +150,7 @@ defmodule Firebird.Target.Manifest do
 
         if wasm_file do
           wasm_path = Path.join(output_dir, wasm_file)
+
           case File.read(wasm_path) do
             {:ok, wasm_binary} -> Firebird.load(wasm_binary)
             {:error, reason} -> {:error, {:file_read_error, reason, wasm_path}}
@@ -170,6 +173,7 @@ defmodule Firebird.Target.Manifest do
       |> modules()
       |> Enum.map(fn entry ->
         name = get_field(entry, "module")
+
         case load_module(manifest, name) do
           {:ok, instance} -> {:ok, {name, instance}}
           {:error, reason} -> {:error, {name, reason}}
@@ -206,8 +210,10 @@ defmodule Firebird.Target.Manifest do
 
           true ->
             path = Path.join(output_dir, wasm_file)
+
             if File.exists?(path) do
-              {:ok, "#{name}: #{wasm_file} exists (#{get_field(entry, "wasm_size") || "?"} bytes)"}
+              {:ok,
+               "#{name}: #{wasm_file} exists (#{get_field(entry, "wasm_size") || "?"} bytes)"}
             else
               {:error, "#{name}: #{wasm_file} not found at #{path}"}
             end
@@ -240,11 +246,12 @@ defmodule Firebird.Target.Manifest do
 
   # Get a field from a map with either string or atom keys
   defp get_field(map, key) when is_binary(key) do
-    atom_key = try do
-      String.to_existing_atom(key)
-    rescue
-      _ -> nil
-    end
+    atom_key =
+      try do
+        String.to_existing_atom(key)
+      rescue
+        _ -> nil
+      end
 
     Map.get(map, key) || (atom_key && Map.get(map, atom_key))
   end
diff --git a/lib/firebird/target/mix_target.ex b/lib/firebird/target/mix_target.ex
index 1ac01f1..0258219 100644
--- a/lib/firebird/target/mix_target.ex
+++ b/lib/firebird/target/mix_target.ex
@@ -72,17 +72,18 @@ defmodule Firebird.Target.MixTarget do
   def config_from_env do
     base = Firebird.Target.Config.from_mix_project()
 
-    env_overrides = [
-      output_dir: System.get_env("FIREBIRD_OUTPUT"),
-      wat_only: env_bool("FIREBIRD_WAT_ONLY"),
-      optimize: env_bool("FIREBIRD_OPTIMIZE"),
-      tco: env_bool("FIREBIRD_TCO"),
-      inline: env_bool("FIREBIRD_INLINE"),
-      licm: env_bool("FIREBIRD_LICM"),
-      verbose: env_bool("FIREBIRD_VERBOSE"),
-      verify: env_bool("FIREBIRD_VERIFY")
-    ]
-    |> Enum.reject(fn {_k, v} -> is_nil(v) end)
+    env_overrides =
+      [
+        output_dir: System.get_env("FIREBIRD_OUTPUT"),
+        wat_only: env_bool("FIREBIRD_WAT_ONLY"),
+        optimize: env_bool("FIREBIRD_OPTIMIZE"),
+        tco: env_bool("FIREBIRD_TCO"),
+        inline: env_bool("FIREBIRD_INLINE"),
+        licm: env_bool("FIREBIRD_LICM"),
+        verbose: env_bool("FIREBIRD_VERBOSE"),
+        verify: env_bool("FIREBIRD_VERIFY")
+      ]
+      |> Enum.reject(fn {_k, v} -> is_nil(v) end)
 
     Firebird.Target.Config.merge(base, env_overrides)
   end
diff --git a/lib/firebird/target/parallel.ex b/lib/firebird/target/parallel.ex
index 89d097e..b4f5660 100644
--- a/lib/firebird/target/parallel.ex
+++ b/lib/firebird/target/parallel.ex
@@ -173,7 +173,9 @@ defmodule Firebird.Target.Parallel do
               {:ok, ast} -> extract_module_name(ast)
               _ -> nil
             end
-          _ -> nil
+
+          _ ->
+            nil
         end
 
       {source, module}
@@ -215,12 +217,14 @@ defmodule Firebird.Target.Parallel do
   defp extract_module_name({:defmodule, _, [{:__aliases__, _, parts}, _]}) do
     parts |> Enum.map(&to_string/1) |> Enum.join(".") |> String.to_atom()
   end
+
   defp extract_module_name({:__block__, _, stmts}) do
     Enum.find_value(stmts, fn
       {:defmodule, _, _} = mod -> extract_module_name(mod)
       _ -> nil
     end)
   end
+
   defp extract_module_name(_), do: nil
 
   defp partition_results(results) do
diff --git a/lib/firebird/target/pipeline.ex b/lib/firebird/target/pipeline.ex
index d60b425..971142a 100644
--- a/lib/firebird/target/pipeline.ex
+++ b/lib/firebird/target/pipeline.ex
@@ -32,10 +32,38 @@ defmodule Firebird.Target.Pipeline do
   """
 
   alias Firebird.Compiler
-  alias Firebird.Compiler.{IRGen, WATGen, TypeInference, Validator, Optimizer, TCO, Inliner, CSE, ConstantPropagation, IfChainToCase, LICM}
+
+  alias Firebird.Compiler.{
+    IRGen,
+    WATGen,
+    TypeInference,
+    Validator,
+    Optimizer,
+    TCO,
+    Inliner,
+    CSE,
+    ConstantPropagation,
+    IfChainToCase,
+    LICM
+  }
+
   alias Firebird.Compiler.IR
 
-  @type stage :: :parse | :ir | :inline | :const_prop | :optimize | :cse | :tco | :licm | :post_const_prop | :post_optimize | :validate | :type_infer | :wat | :wasm
+  @type stage ::
+          :parse
+          | :ir
+          | :inline
+          | :const_prop
+          | :optimize
+          | :cse
+          | :tco
+          | :licm
+          | :post_const_prop
+          | :post_optimize
+          | :validate
+          | :type_infer
+          | :wat
+          | :wasm
 
   # Pass ordering matches Firebird.Compiler.compile_source/2:
   # inline → const_prop → optimize → CSE → TCO → LICM → post-TCO const_prop → post-TCO optimize → validate → type_infer → WAT → WASM
@@ -49,7 +77,23 @@ defmodule Firebird.Target.Pipeline do
   # loop-invariant expressions out of loop bodies.
   # Post-TCO optimize runs constant folding / strength reduction inside the
   # loop bodies that TCO introduces, which is critical for performance.
-  @stages [:parse, :ir, :if_to_case, :inline, :const_prop, :optimize, :cse, :tco, :licm, :post_const_prop, :post_optimize, :validate, :type_infer, :wat, :wasm]
+  @stages [
+    :parse,
+    :ir,
+    :if_to_case,
+    :inline,
+    :const_prop,
+    :optimize,
+    :cse,
+    :tco,
+    :licm,
+    :post_const_prop,
+    :post_optimize,
+    :validate,
+    :type_infer,
+    :wat,
+    :wasm
+  ]
 
   @doc """
   List all pipeline stages in order.
@@ -208,47 +252,49 @@ defmodule Firebird.Target.Pipeline do
 
           # Inline FIRST so inlined bodies benefit from constant propagation + optimization + TCO
           with {:ok, ir} <- maybe_pass(:inline, ir, opts) do
-          if target == :inline, do: throw({:done, ir})
+            if target == :inline, do: throw({:done, ir})
 
-          # Constant propagation: substitute let-bound literals so constant folding can evaluate
-          with {:ok, ir} <- maybe_pass(:const_prop, ir, opts) do
-            if target == :const_prop, do: throw({:done, ir})
+            # Constant propagation: substitute let-bound literals so constant folding can evaluate
+            with {:ok, ir} <- maybe_pass(:const_prop, ir, opts) do
+              if target == :const_prop, do: throw({:done, ir})
 
-            with {:ok, ir} <- maybe_pass(:optimize, ir, opts) do
-              if target == :optimize, do: throw({:done, ir})
+              with {:ok, ir} <- maybe_pass(:optimize, ir, opts) do
+                if target == :optimize, do: throw({:done, ir})
 
-              with {:ok, ir} <- maybe_pass(:cse, ir, opts) do
-                if target == :cse, do: throw({:done, ir})
+                with {:ok, ir} <- maybe_pass(:cse, ir, opts) do
+                  if target == :cse, do: throw({:done, ir})
 
-                with {:ok, ir} <- maybe_pass(:tco, ir, opts) do
-                  if target == :tco, do: throw({:done, ir})
+                  with {:ok, ir} <- maybe_pass(:tco, ir, opts) do
+                    if target == :tco, do: throw({:done, ir})
 
-                  # LICM: hoist loop-invariant expressions out of tail_loop bodies
-                  with {:ok, ir} <- maybe_pass(:licm, ir, opts) do
-                  if target == :licm, do: throw({:done, ir})
+                    # LICM: hoist loop-invariant expressions out of tail_loop bodies
+                    with {:ok, ir} <- maybe_pass(:licm, ir, opts) do
+                      if target == :licm, do: throw({:done, ir})
 
-                  # Post-TCO constant propagation + optimization:
-                  # propagate constants inside TCO loop bodies, then fold.
-                  with {:ok, ir} <- maybe_pass(:post_const_prop, ir, opts) do
-                    if target == :post_const_prop, do: throw({:done, ir})
+                      # Post-TCO constant propagation + optimization:
+                      # propagate constants inside TCO loop bodies, then fold.
+                      with {:ok, ir} <- maybe_pass(:post_const_prop, ir, opts) do
+                        if target == :post_const_prop, do: throw({:done, ir})
 
-                    # Post-TCO optimization: constant folding, strength reduction,
-                    # and dead code elimination inside TCO loop bodies.
-                    # Only runs when BOTH optimize and tco are enabled.
-                    with {:ok, ir} <- maybe_pass(:post_optimize, ir, opts) do
-                      if target == :post_optimize, do: throw({:done, ir})
+                        # Post-TCO optimization: constant folding, strength reduction,
+                        # and dead code elimination inside TCO loop bodies.
+                        # Only runs when BOTH optimize and tco are enabled.
+                        with {:ok, ir} <- maybe_pass(:post_optimize, ir, opts) do
+                          if target == :post_optimize, do: throw({:done, ir})
 
-                      with :ok <- validate(ir) do
-                        if target == :validate, do: throw({:done, :ok})
+                          with :ok <- validate(ir) do
+                            if target == :validate, do: throw({:done, :ok})
 
-                        with {:ok, typed_ir} <- type_infer(ir) do
-                          if target == :type_infer, do: throw({:done, typed_ir})
+                            with {:ok, typed_ir} <- type_infer(ir) do
+                              if target == :type_infer, do: throw({:done, typed_ir})
 
-                          with {:ok, wat} <- to_wat(typed_ir) do
-                            if target == :wat, do: throw({:done, wat})
+                              with {:ok, wat} <- to_wat(typed_ir) do
+                                if target == :wat, do: throw({:done, wat})
 
-                            with {:ok, wasm} <- to_wasm(wat) do
-                              {:ok, wasm}
+                                with {:ok, wasm} <- to_wasm(wat) do
+                                  {:ok, wasm}
+                                end
+                              end
                             end
                           end
                         end
@@ -256,12 +302,10 @@ defmodule Firebird.Target.Pipeline do
                     end
                   end
                 end
-                end
               end
             end
           end
         end
-        end
       end
     end
   catch
@@ -369,7 +413,7 @@ defmodule Firebird.Target.Pipeline do
   # Can also be explicitly enabled with the :licm option.
   defp maybe_pass(:licm, ir, opts) do
     if Keyword.get(opts, :licm, false) or
-       (Keyword.get(opts, :optimize, false) and Keyword.get(opts, :tco, false)) do
+         (Keyword.get(opts, :optimize, false) and Keyword.get(opts, :tco, false)) do
       LICM.optimize(ir)
     else
       {:ok, ir}
@@ -488,7 +532,9 @@ defmodule Firebird.Target.Pipeline do
   defp format_stage_result(:type_infer, %IR.Module{} = ir) do
     funcs =
       Enum.map(ir.functions, fn f ->
-        params = if f.type, do: Enum.map(f.type.params, &to_string/1) |> Enum.join(", "), else: "?"
+        params =
+          if f.type, do: Enum.map(f.type.params, &to_string/1) |> Enum.join(", "), else: "?"
+
         ret = if f.type, do: to_string(f.type.return), else: "?"
         "  #{f.name}(#{params}) -> #{ret}"
       end)
diff --git a/lib/firebird/target/profiler.ex b/lib/firebird/target/profiler.ex
index 72b0265..39ca1f4 100644
--- a/lib/firebird/target/profiler.ex
+++ b/lib/firebird/target/profiler.ex
@@ -31,21 +31,21 @@ defmodule Firebird.Target.Profiler do
   ]
 
   @type timing :: %{
-    stage: atom(),
-    elapsed_us: non_neg_integer(),
-    percentage: float()
-  }
+          stage: atom(),
+          elapsed_us: non_neg_integer(),
+          percentage: float()
+        }
 
   @type profile :: %{
-    source: String.t() | nil,
-    file: String.t() | nil,
-    module: atom() | nil,
-    timings: [timing()],
-    total_us: non_neg_integer(),
-    result: :ok | :error,
-    error: term() | nil,
-    options: keyword()
-  }
+          source: String.t() | nil,
+          file: String.t() | nil,
+          module: atom() | nil,
+          timings: [timing()],
+          total_us: non_neg_integer(),
+          result: :ok | :error,
+          error: term() | nil,
+          options: keyword()
+        }
 
   @doc """
   Profile compilation of a source code string.
@@ -69,77 +69,93 @@ defmodule Firebird.Target.Profiler do
     timings = []
 
     # Parse
-    {parse_us, parse_result} = time_stage(fn ->
-      Firebird.Compiler.parse(source)
-    end)
+    {parse_us, parse_result} =
+      time_stage(fn ->
+        Firebird.Compiler.parse(source)
+      end)
+
     timings = [{:parse, parse_us} | timings]
 
     case parse_result do
       {:ok, ast} ->
         # IR Generation
-        {ir_us, ir_result} = time_stage(fn ->
-          Firebird.Compiler.IRGen.generate(ast)
-        end)
+        {ir_us, ir_result} =
+          time_stage(fn ->
+            Firebird.Compiler.IRGen.generate(ast)
+          end)
+
         timings = [{:ir_gen, ir_us} | timings]
 
         case ir_result do
           {:ok, module_ir} ->
             # Optional: Optimize
-            {opt_us, opt_result} = time_stage(fn ->
-              if optimize do
-                Firebird.Compiler.Optimizer.optimize(module_ir)
-              else
-                {:ok, module_ir}
-              end
-            end)
+            {opt_us, opt_result} =
+              time_stage(fn ->
+                if optimize do
+                  Firebird.Compiler.Optimizer.optimize(module_ir)
+                else
+                  {:ok, module_ir}
+                end
+              end)
+
             timings = [{:optimize, opt_us} | timings]
 
             case opt_result do
               {:ok, opt_ir} ->
                 # Optional: TCO
-                {tco_us, tco_result} = time_stage(fn ->
-                  if tco do
-                    Firebird.Compiler.TCO.optimize(opt_ir)
-                  else
-                    {:ok, opt_ir}
-                  end
-                end)
+                {tco_us, tco_result} =
+                  time_stage(fn ->
+                    if tco do
+                      Firebird.Compiler.TCO.optimize(opt_ir)
+                    else
+                      {:ok, opt_ir}
+                    end
+                  end)
+
                 timings = [{:tco, tco_us} | timings]
 
                 case tco_result do
                   {:ok, tco_ir} ->
                     # Optional: Inline
-                    {inline_us, inline_result} = time_stage(fn ->
-                      if do_inline do
-                        Firebird.Compiler.Inliner.inline(tco_ir)
-                      else
-                        {:ok, tco_ir}
-                      end
-                    end)
+                    {inline_us, inline_result} =
+                      time_stage(fn ->
+                        if do_inline do
+                          Firebird.Compiler.Inliner.inline(tco_ir)
+                        else
+                          {:ok, tco_ir}
+                        end
+                      end)
+
                     timings = [{:inline, inline_us} | timings]
 
                     case inline_result do
                       {:ok, final_ir} ->
                         # Validate
-                        {val_us, val_result} = time_stage(fn ->
-                          Firebird.Compiler.Validator.validate(final_ir)
-                        end)
+                        {val_us, val_result} =
+                          time_stage(fn ->
+                            Firebird.Compiler.Validator.validate(final_ir)
+                          end)
+
                         timings = [{:validate, val_us} | timings]
 
                         case val_result do
                           :ok ->
                             # Type Inference
-                            {type_us, type_result} = time_stage(fn ->
-                              Firebird.Compiler.TypeInference.infer(final_ir)
-                            end)
+                            {type_us, type_result} =
+                              time_stage(fn ->
+                                Firebird.Compiler.TypeInference.infer(final_ir)
+                              end)
+
                             timings = [{:type_infer, type_us} | timings]
 
                             case type_result do
                               {:ok, typed_ir} ->
                                 # WAT Generation
-                                {wat_us, wat_result} = time_stage(fn ->
-                                  Firebird.Compiler.WATGen.generate(typed_ir)
-                                end)
+                                {wat_us, wat_result} =
+                                  time_stage(fn ->
+                                    Firebird.Compiler.WATGen.generate(typed_ir)
+                                  end)
+
                                 timings = [{:wat_gen, wat_us} | timings]
 
                                 case wat_result do
@@ -151,6 +167,7 @@ defmodule Firebird.Target.Profiler do
                                       else
                                         time_stage(fn -> Firebird.Compiler.wat_to_wasm(wat) end)
                                       end
+
                                     timings = [{:wat2wasm, wasm_us} | timings]
 
                                     build_profile(timings, typed_ir.name, nil, opts, :ok)
@@ -203,11 +220,7 @@ defmodule Firebird.Target.Profiler do
         all_tuples = [{:read, read_us} | existing_tuples]
         total = Enum.map(all_tuples, fn {_, us} -> us end) |> Enum.sum()
 
-        {:ok, %{profile |
-          file: path,
-          timings: build_timings(all_tuples, total),
-          total_us: total
-        }}
+        {:ok, %{profile | file: path, timings: build_timings(all_tuples, total), total_us: total}}
 
       {:error, reason} ->
         build_profile([{:read, read_us}], nil, path, opts, :error, {:file_error, reason})
@@ -274,16 +287,17 @@ defmodule Firebird.Target.Profiler do
     timings = Enum.reverse(timings)
     total = Enum.map(timings, fn {_, us} -> us end) |> Enum.sum()
 
-    {:ok, %{
-      source: nil,
-      file: file,
-      module: module,
-      timings: build_timings(timings, total),
-      total_us: total,
-      result: result,
-      error: error,
-      options: opts
-    }}
+    {:ok,
+     %{
+       source: nil,
+       file: file,
+       module: module,
+       timings: build_timings(timings, total),
+       total_us: total,
+       result: result,
+       error: error,
+       options: opts
+     }}
   end
 
   defp build_timings(timings, total) do
diff --git a/lib/firebird/target/stats.ex b/lib/firebird/target/stats.ex
index 95c9b71..8a99cd5 100644
--- a/lib/firebird/target/stats.ex
+++ b/lib/firebird/target/stats.ex
@@ -24,35 +24,35 @@ defmodule Firebird.Target.Stats do
   """
 
   @type module_stat :: %{
-    module: String.t(),
-    wat_bytes: non_neg_integer(),
-    wasm_bytes: non_neg_integer() | nil,
-    export_count: non_neg_integer(),
-    source_file: String.t() | nil
-  }
+          module: String.t(),
+          wat_bytes: non_neg_integer(),
+          wasm_bytes: non_neg_integer() | nil,
+          export_count: non_neg_integer(),
+          source_file: String.t() | nil
+        }
 
   @type stats :: %{
-    version: integer(),
-    timestamp: String.t(),
-    elapsed_ms: non_neg_integer(),
-    module_count: non_neg_integer(),
-    total_wat_bytes: non_neg_integer(),
-    total_wasm_bytes: non_neg_integer(),
-    modules: [module_stat()],
-    options: map()
-  }
+          version: integer(),
+          timestamp: String.t(),
+          elapsed_ms: non_neg_integer(),
+          module_count: non_neg_integer(),
+          total_wat_bytes: non_neg_integer(),
+          total_wasm_bytes: non_neg_integer(),
+          modules: [module_stat()],
+          options: map()
+        }
 
   @type comparison :: %{
-    module_count_delta: integer(),
-    wat_bytes_delta: integer(),
-    wasm_bytes_delta: integer(),
-    time_delta_ms: integer(),
-    wat_pct_change: float() | nil,
-    wasm_pct_change: float() | nil,
-    added_modules: [String.t()],
-    removed_modules: [String.t()],
-    changed_modules: [%{module: String.t(), wat_delta: integer(), wasm_delta: integer()}]
-  }
+          module_count_delta: integer(),
+          wat_bytes_delta: integer(),
+          wasm_bytes_delta: integer(),
+          time_delta_ms: integer(),
+          wat_pct_change: float() | nil,
+          wasm_pct_change: float() | nil,
+          added_modules: [String.t()],
+          removed_modules: [String.t()],
+          changed_modules: [%{module: String.t(), wat_delta: integer(), wasm_delta: integer()}]
+        }
 
   @doc """
   Collect compilation statistics from compilation results.
@@ -115,6 +115,7 @@ defmodule Firebird.Target.Stats do
           {:ok, data} -> {:ok, normalize_stats(data)}
           {:error, reason} -> {:error, {:json_decode_error, reason}}
         end
+
       {:error, reason} ->
         {:error, {:file_read_error, reason}}
     end
@@ -146,11 +147,13 @@ defmodule Firebird.Target.Stats do
         new_wasm = get_field(new_m, "wasm_bytes", 0) || 0
 
         if old_wat != new_wat or old_wasm != new_wasm do
-          [%{
-            module: name,
-            wat_delta: new_wat - old_wat,
-            wasm_delta: new_wasm - old_wasm
-          }]
+          [
+            %{
+              module: name,
+              wat_delta: new_wat - old_wat,
+              wasm_delta: new_wasm - old_wasm
+            }
+          ]
         else
           []
         end
@@ -162,10 +165,12 @@ defmodule Firebird.Target.Stats do
     new_total_wasm = get_field(new_stats, "total_wasm_bytes", 0)
 
     %{
-      module_count_delta: get_field(new_stats, "module_count", 0) - get_field(old_stats, "module_count", 0),
+      module_count_delta:
+        get_field(new_stats, "module_count", 0) - get_field(old_stats, "module_count", 0),
       wat_bytes_delta: new_total_wat - old_total_wat,
       wasm_bytes_delta: new_total_wasm - old_total_wasm,
-      time_delta_ms: get_field(new_stats, "elapsed_ms", 0) - get_field(old_stats, "elapsed_ms", 0),
+      time_delta_ms:
+        get_field(new_stats, "elapsed_ms", 0) - get_field(old_stats, "elapsed_ms", 0),
       wat_pct_change: pct_change(old_total_wat, new_total_wat),
       wasm_pct_change: pct_change(old_total_wasm, new_total_wasm),
       added_modules: added,
@@ -191,7 +196,10 @@ defmodule Firebird.Target.Stats do
 
     issues =
       if comparison.wasm_pct_change && comparison.wasm_pct_change > max_wasm_growth do
-        ["WASM binary size grew by #{Float.round(comparison.wasm_pct_change, 1)}% (threshold: #{max_wasm_growth}%)" | issues]
+        [
+          "WASM binary size grew by #{Float.round(comparison.wasm_pct_change, 1)}% (threshold: #{max_wasm_growth}%)"
+          | issues
+        ]
       else
         issues
       end
@@ -206,7 +214,10 @@ defmodule Firebird.Target.Stats do
 
     issues =
       if length(comparison.removed_modules) > 0 do
-        ["#{length(comparison.removed_modules)} module(s) removed: #{Enum.join(comparison.removed_modules, ", ")}" | issues]
+        [
+          "#{length(comparison.removed_modules)} module(s) removed: #{Enum.join(comparison.removed_modules, ", ")}"
+          | issues
+        ]
       else
         issues
       end
@@ -221,12 +232,14 @@ defmodule Firebird.Target.Stats do
   def format_comparison(comp) do
     lines = ["📊 Build Comparison"]
 
-    lines = lines ++ [
-      "  Modules: #{format_delta(comp.module_count_delta)}",
-      "  WAT size: #{format_bytes_delta(comp.wat_bytes_delta, comp.wat_pct_change)}",
-      "  WASM size: #{format_bytes_delta(comp.wasm_bytes_delta, comp.wasm_pct_change)}",
-      "  Time: #{format_time_delta(comp.time_delta_ms)}"
-    ]
+    lines =
+      lines ++
+        [
+          "  Modules: #{format_delta(comp.module_count_delta)}",
+          "  WAT size: #{format_bytes_delta(comp.wat_bytes_delta, comp.wat_pct_change)}",
+          "  WASM size: #{format_bytes_delta(comp.wasm_bytes_delta, comp.wasm_pct_change)}",
+          "  Time: #{format_time_delta(comp.time_delta_ms)}"
+        ]
 
     lines =
       if Enum.any?(comp.added_modules) do
@@ -244,9 +257,11 @@ defmodule Firebird.Target.Stats do
 
     lines =
       if Enum.any?(comp.changed_modules) do
-        change_lines = Enum.map(comp.changed_modules, fn c ->
-          "    #{c.module}: WAT #{format_delta(c.wat_delta)}B, WASM #{format_delta(c.wasm_delta)}B"
-        end)
+        change_lines =
+          Enum.map(comp.changed_modules, fn c ->
+            "    #{c.module}: WAT #{format_delta(c.wat_delta)}B, WASM #{format_delta(c.wasm_delta)}B"
+          end)
+
         lines ++ ["  Changed:"] ++ change_lines
       else
         lines
@@ -272,19 +287,22 @@ defmodule Firebird.Target.Stats do
   end
 
   defp get_field(map, key, default) when is_binary(key) do
-    atom_key = try do
-      String.to_existing_atom(key)
-    rescue
-      _ -> nil
-    end
+    atom_key =
+      try do
+        String.to_existing_atom(key)
+      rescue
+        _ -> nil
+      end
 
     Map.get(map, key, Map.get(map, atom_key, default))
   end
 
   defp pct_change(0, _new), do: nil
+
   defp pct_change(old, new) when old > 0 do
     Float.round((new - old) / old * 100, 1)
   end
+
   defp pct_change(_, _), do: nil
 
   defp format_delta(0), do: "no change"
diff --git a/lib/firebird/target/verify.ex b/lib/firebird/target/verify.ex
index e0b2b08..a686db6 100644
--- a/lib/firebird/target/verify.ex
+++ b/lib/firebird/target/verify.ex
@@ -31,7 +31,15 @@ defmodule Firebird.Target.Verify do
           valid: boolean(),
           exports: [atom()],
           export_count: non_neg_integer(),
-          smoke_tests: [%{function: atom(), args: [integer()], expected: integer(), actual: integer(), passed: boolean()}],
+          smoke_tests: [
+            %{
+              function: atom(),
+              args: [integer()],
+              expected: integer(),
+              actual: integer(),
+              passed: boolean()
+            }
+          ],
           error: term() | nil
         }
 
@@ -72,13 +80,14 @@ defmodule Firebird.Target.Verify do
         {:ok, report}
 
       {:error, reason} ->
-        {:ok, %{
-          valid: false,
-          exports: [],
-          export_count: 0,
-          smoke_tests: [],
-          error: reason
-        }}
+        {:ok,
+         %{
+           valid: false,
+           exports: [],
+           export_count: 0,
+           smoke_tests: [],
+           error: reason
+         }}
     end
   end
 
@@ -89,7 +98,8 @@ defmodule Firebird.Target.Verify do
   def verify_result(result, opts \\ []) do
     cond do
       result.wasm == nil ->
-        {:ok, %{valid: false, exports: [], export_count: 0, smoke_tests: [], error: :no_wasm_binary}}
+        {:ok,
+         %{valid: false, exports: [], export_count: 0, smoke_tests: [], error: :no_wasm_binary}}
 
       true ->
         verify_binary(result.wasm, opts)
@@ -99,7 +109,8 @@ defmodule Firebird.Target.Verify do
   @doc """
   Verify all WASM files in a directory.
   """
-  @spec verify_dir(String.t(), keyword()) :: {:ok, [%{file: String.t(), result: verify_result()}]} | {:error, term()}
+  @spec verify_dir(String.t(), keyword()) ::
+          {:ok, [%{file: String.t(), result: verify_result()}]} | {:error, term()}
   def verify_dir(dir, opts \\ []) do
     unless File.dir?(dir) do
       {:error, {:not_a_directory, dir}}
@@ -114,7 +125,16 @@ defmodule Firebird.Target.Verify do
               %{file: file, result: report}
 
             {:error, reason} ->
-              %{file: file, result: %{valid: false, exports: [], export_count: 0, smoke_tests: [], error: reason}}
+              %{
+                file: file,
+                result: %{
+                  valid: false,
+                  exports: [],
+                  export_count: 0,
+                  smoke_tests: [],
+                  error: reason
+                }
+              }
           end
         end)
 
@@ -146,6 +166,7 @@ defmodule Firebird.Target.Verify do
         test_lines =
           Enum.map(report.smoke_tests, fn t ->
             icon = if t.passed, do: "✅", else: "❌"
+
             "    #{icon} #{t.function}(#{Enum.join(t.args, ", ")}) = #{t.actual} (expected #{t.expected})"
           end)
 
@@ -162,7 +183,13 @@ defmodule Firebird.Target.Verify do
 
     case Firebird.call(instance, func_str, args) do
       {:ok, [actual]} ->
-        %{function: func, args: args, expected: expected, actual: actual, passed: actual == expected}
+        %{
+          function: func,
+          args: args,
+          expected: expected,
+          actual: actual,
+          passed: actual == expected
+        }
 
       {:ok, other} ->
         %{function: func, args: args, expected: expected, actual: other, passed: false}
diff --git a/lib/firebird/test_helpers.ex b/lib/firebird/test_helpers.ex
index ed61e72..2c842cd 100644
--- a/lib/firebird/test_helpers.ex
+++ b/lib/firebird/test_helpers.ex
@@ -81,9 +81,11 @@ defmodule Firebird.TestHelpers do
     quote do
       setup do
         {:ok, pid} = Firebird.load(unquote(path), unquote(opts))
+
         on_exit(fn ->
           if Process.alive?(pid), do: Firebird.stop(pid)
         end)
+
         {:ok, wasm: pid}
       end
     end
@@ -99,7 +101,8 @@ defmodule Firebird.TestHelpers do
   """
   defmacro assert_wasm_call(instance, function, args, expected) do
     quote do
-      assert {:ok, unquote(expected)} = Firebird.call(unquote(instance), unquote(function), unquote(args))
+      assert {:ok, unquote(expected)} =
+               Firebird.call(unquote(instance), unquote(function), unquote(args))
     end
   end
 
@@ -113,9 +116,10 @@ defmodule Firebird.TestHelpers do
   defmacro assert_wasm_exports(instance, functions) do
     quote do
       exports = Firebird.exports(unquote(instance))
+
       for func <- unquote(functions) do
         assert func in exports,
-          "Expected #{inspect(func)} in exports, got: #{inspect(exports)}"
+               "Expected #{inspect(func)} in exports, got: #{inspect(exports)}"
       end
     end
   end
@@ -130,7 +134,7 @@ defmodule Firebird.TestHelpers do
   defmacro assert_wasm_type(instance, function, {params, results}) do
     quote do
       assert {:ok, {unquote(params), unquote(results)}} =
-        Firebird.function_type(unquote(instance), unquote(function))
+               Firebird.function_type(unquote(instance), unquote(function))
     end
   end
 
@@ -157,11 +161,12 @@ defmodule Firebird.TestHelpers do
   defmacro assert_wasm_function(instance, function, arity) do
     quote do
       assert Firebird.function_exists?(unquote(instance), unquote(function)),
-        "Expected function #{inspect(unquote(function))} to exist"
+             "Expected function #{inspect(unquote(function))} to exist"
 
       {:ok, {params, _results}} = Firebird.function_type(unquote(instance), unquote(function))
+
       assert length(params) == unquote(arity),
-        "Expected #{inspect(unquote(function))} to have arity #{unquote(arity)}, got #{length(params)}"
+             "Expected #{inspect(unquote(function))} to have arity #{unquote(arity)}, got #{length(params)}"
     end
   end
 
@@ -183,9 +188,11 @@ defmodule Firebird.TestHelpers do
       setup do
         path = Firebird.sample_wasm_path()
         {:ok, pid} = Firebird.load(path, unquote(opts))
+
         on_exit(fn ->
           if Process.alive?(pid), do: Firebird.stop(pid)
         end)
+
         {:ok, wasm: pid}
       end
     end
@@ -204,7 +211,8 @@ defmodule Firebird.TestHelpers do
   """
   defmacro assert_wasm_result(instance, function, args, expected) do
     quote do
-      assert {:ok, unquote(expected)} = Firebird.call_one(unquote(instance), unquote(function), unquote(args))
+      assert {:ok, unquote(expected)} =
+               Firebird.call_one(unquote(instance), unquote(function), unquote(args))
     end
   end
 
@@ -218,9 +226,10 @@ defmodule Firebird.TestHelpers do
   defmacro refute_wasm_exports(instance, functions) do
     quote do
       exports = Firebird.exports(unquote(instance))
+
       for func <- unquote(functions) do
         refute func in exports,
-          "Expected #{inspect(func)} NOT in exports, but found in: #{inspect(exports)}"
+               "Expected #{inspect(func)} NOT in exports, but found in: #{inspect(exports)}"
       end
     end
   end
@@ -234,13 +243,16 @@ defmodule Firebird.TestHelpers do
   """
   defmacro assert_wasm_fast(instance, function, args, max_ms) do
     quote do
-      {time_us, result} = :timer.tc(fn ->
-        Firebird.call(unquote(instance), unquote(function), unquote(args))
-      end)
+      {time_us, result} =
+        :timer.tc(fn ->
+          Firebird.call(unquote(instance), unquote(function), unquote(args))
+        end)
+
       time_ms = time_us / 1000
       assert {:ok, _} = result, "WASM call failed: #{inspect(result)}"
+
       assert time_ms < unquote(max_ms),
-        "Expected #{inspect(unquote(function))} to complete in < #{unquote(max_ms)}ms, took #{Float.round(time_ms, 2)}ms"
+             "Expected #{inspect(unquote(function))} to complete in < #{unquote(max_ms)}ms, took #{Float.round(time_ms, 2)}ms"
     end
   end
 
@@ -263,9 +275,11 @@ defmodule Firebird.TestHelpers do
       setup do
         path = Firebird.sample_wasm_path()
         {:ok, pid} = Firebird.load(path)
+
         on_exit(fn ->
           if Process.alive?(pid), do: Firebird.stop(pid)
         end)
+
         {:ok, wasm: pid}
       end
     end
@@ -309,6 +323,7 @@ defmodule Firebird.TestHelpers do
   defmacro assert_wasm_table(instance, function, table, opts \\ []) do
     quote do
       raw = Keyword.get(unquote(opts), :raw, false)
+
       for {args, expected} = row <- unquote(table) do
         if raw do
           case Firebird.call(unquote(instance), unquote(function), args) do
@@ -318,16 +333,16 @@ defmodule Firebird.TestHelpers do
             {:ok, actual} ->
               flunk(
                 "assert_wasm_table #{inspect(unquote(function))} failed\n" <>
-                "  args:     #{inspect(args)}\n" <>
-                "  expected: #{inspect(expected)}\n" <>
-                "  actual:   #{inspect(actual)}"
+                  "  args:     #{inspect(args)}\n" <>
+                  "  expected: #{inspect(expected)}\n" <>
+                  "  actual:   #{inspect(actual)}"
               )
 
             {:error, reason} ->
               flunk(
                 "assert_wasm_table #{inspect(unquote(function))} errored\n" <>
-                "  args:   #{inspect(args)}\n" <>
-                "  error:  #{inspect(reason)}"
+                  "  args:   #{inspect(args)}\n" <>
+                  "  error:  #{inspect(reason)}"
               )
           end
         else
@@ -338,16 +353,16 @@ defmodule Firebird.TestHelpers do
             {:ok, actual} ->
               flunk(
                 "assert_wasm_table #{inspect(unquote(function))} failed\n" <>
-                "  args:     #{inspect(args)}\n" <>
-                "  expected: #{inspect(expected)}\n" <>
-                "  actual:   #{inspect(actual)}"
+                  "  args:     #{inspect(args)}\n" <>
+                  "  expected: #{inspect(expected)}\n" <>
+                  "  actual:   #{inspect(actual)}"
               )
 
             {:error, reason} ->
               flunk(
                 "assert_wasm_table #{inspect(unquote(function))} errored\n" <>
-                "  args:   #{inspect(args)}\n" <>
-                "  error:  #{inspect(reason)}"
+                  "  args:   #{inspect(args)}\n" <>
+                  "  error:  #{inspect(reason)}"
               )
           end
         end
@@ -365,13 +380,19 @@ defmodule Firebird.TestHelpers do
   defmacro bench_wasm_call(instance, function, args, opts \\ []) do
     quote do
       iterations = Keyword.get(unquote(opts), :iterations, 100)
-      times = for _ <- 1..iterations do
-        {time, {:ok, _}} = :timer.tc(fn ->
-          Firebird.call(unquote(instance), unquote(function), unquote(args))
-        end)
-        time
-      end
+
+      times =
+        for _ <- 1..iterations do
+          {time, {:ok, _}} =
+            :timer.tc(fn ->
+              Firebird.call(unquote(instance), unquote(function), unquote(args))
+            end)
+
+          time
+        end
+
       avg = Enum.sum(times) / length(times)
+
       %{
         avg_us: Float.round(avg, 2),
         min_us: Enum.min(times),
@@ -473,16 +494,16 @@ defmodule Firebird.TestHelpers do
         {:ok, actual} ->
           flunk(
             "assert_wasm_pipeline failed\n" <>
-            "  steps:    #{inspect(unquote(steps))}\n" <>
-            "  expected: #{inspect(unquote(expected))}\n" <>
-            "  actual:   #{inspect(actual)}"
+              "  steps:    #{inspect(unquote(steps))}\n" <>
+              "  expected: #{inspect(unquote(expected))}\n" <>
+              "  actual:   #{inspect(actual)}"
           )
 
         {:error, reason} ->
           flunk(
             "assert_wasm_pipeline errored\n" <>
-            "  steps: #{inspect(unquote(steps))}\n" <>
-            "  error: #{inspect(reason)}"
+              "  steps: #{inspect(unquote(steps))}\n" <>
+              "  error: #{inspect(reason)}"
           )
       end
     end
@@ -512,16 +533,16 @@ defmodule Firebird.TestHelpers do
       case Firebird.call_one(unquote(instance), unquote(function), unquote(args)) do
         {:ok, value} ->
           assert value >= unquote(min_val) and value <= unquote(max_val),
-            "assert_wasm_between #{inspect(unquote(function))} failed\n" <>
-            "  args:     #{inspect(unquote(args))}\n" <>
-            "  value:    #{inspect(value)}\n" <>
-            "  expected: between #{inspect(unquote(min_val))} and #{inspect(unquote(max_val))}"
+                 "assert_wasm_between #{inspect(unquote(function))} failed\n" <>
+                   "  args:     #{inspect(unquote(args))}\n" <>
+                   "  value:    #{inspect(value)}\n" <>
+                   "  expected: between #{inspect(unquote(min_val))} and #{inspect(unquote(max_val))}"
 
         {:error, reason} ->
           flunk(
             "assert_wasm_between #{inspect(unquote(function))} errored\n" <>
-            "  args:  #{inspect(unquote(args))}\n" <>
-            "  error: #{inspect(reason)}"
+              "  args:  #{inspect(unquote(args))}\n" <>
+              "  error: #{inspect(reason)}"
           )
       end
     end
diff --git a/lib/firebird/typed_call.ex b/lib/firebird/typed_call.ex
index ff3d3ca..10c7d78 100644
--- a/lib/firebird/typed_call.ex
+++ b/lib/firebird/typed_call.ex
@@ -106,7 +106,12 @@ defmodule Firebird.TypedCall do
   end
 
   defp build_error(_function, {:type_mismatch, idx, opts}) do
-    Firebird.WasmError.type_mismatch(opts[:function] || "unknown", idx, opts[:expected], opts[:got])
+    Firebird.WasmError.type_mismatch(
+      opts[:function] || "unknown",
+      idx,
+      opts[:expected],
+      opts[:got]
+    )
   end
 
   defp build_error(_function, {:function_not_found, name}) do
diff --git a/lib/firebird/wasm_runner.ex b/lib/firebird/wasm_runner.ex
index 2053d27..36f72a3 100644
--- a/lib/firebird/wasm_runner.ex
+++ b/lib/firebird/wasm_runner.ex
@@ -151,6 +151,503 @@ defmodule Firebird.WasmRunner do
     :ets.whereis(:firebird_module_cache) != :undefined
   end
 
+  # ── run/2: Simple one-shot execution ──────────────────────────────────
+
+  @doc """
+  Load a WASM module, execute one or more function calls, and return results.
+
+  This is the simplest API for one-shot WASM execution. The module is loaded,
+  calls are executed, and the instance is automatically cleaned up. Results
+  are unwrapped from single-element lists for ergonomics.
+
+  ## Single call (keyword shorthand)
+
+      {:ok, 8} = WasmRunner.run("math.wasm", add: [5, 3])
+      {:ok, 55} = WasmRunner.run("math.wasm", fibonacci: [10])
+
+  ## Multiple calls (executed sequentially on one instance)
+
+      {:ok, [8, 28, 55]} = WasmRunner.run("math.wasm", [
+        add: [5, 3],
+        multiply: [4, 7],
+        fibonacci: [10]
+      ])
+
+  ## With options
+
+      {:ok, result} = WasmRunner.run("go_math.wasm", [add: [5, 3]], wasi: true)
+
+  ## From precompiled module (skips compilation)
+
+      {:ok, compiled} = WasmRunner.precompile("math.wasm")
+      {:ok, 8} = WasmRunner.run(compiled, add: [5, 3])
+
+  ## How results are returned
+
+  - **Single call**: returns `{:ok, value}` where value is unwrapped from `[value]`
+  - **Multiple calls**: returns `{:ok, [value1, value2, ...]}` with each unwrapped
+  - If a WASM function returns multiple values, they stay as a list
+
+  ## Options
+
+  Options are passed through to `start/2`. Common ones:
+  - `:wasi` — force WASI mode (auto-detected if not specified)
+  - `:cache` — use module cache for repeated loads
+  - `:timeout` — execution timeout in milliseconds per call (default: 5000)
+  """
+  @spec run(binary() | String.t() | map(), keyword()) :: {:ok, term()} | {:error, term()}
+  def run(wasm_source, calls_and_opts \\ [])
+
+  def run(wasm_source, calls_and_opts) when is_list(calls_and_opts) do
+    {calls, opts} = split_calls_and_opts(calls_and_opts)
+    {call_opts, start_opts} = extract_call_opts(opts)
+
+    if calls == [] do
+      {:error, :no_calls}
+    else
+      case start(wasm_source, start_opts) do
+        {:ok, pid} ->
+          try do
+            results =
+              Enum.map(calls, fn {func, args} ->
+                call_single!(pid, func, args, call_opts)
+              end)
+
+            case results do
+              [single] -> {:ok, single}
+              multiple -> {:ok, multiple}
+            end
+          rescue
+            e -> {:error, Exception.message(e)}
+          after
+            Firebird.stop(pid)
+          end
+
+        {:error, _} = error ->
+          error
+      end
+    end
+  end
+
+  @doc """
+  Like `run/2` but raises on error.
+
+  ## Examples
+
+      8 = WasmRunner.run!("math.wasm", add: [5, 3])
+      [8, 55] = WasmRunner.run!("math.wasm", add: [5, 3], fibonacci: [10])
+  """
+  @spec run!(binary() | String.t() | map(), keyword()) :: term()
+  def run!(wasm_source, calls_and_opts \\ []) do
+    case run(wasm_source, calls_and_opts) do
+      {:ok, result} -> result
+      {:error, reason} -> raise "WASM run failed: #{inspect(reason)}"
+    end
+  end
+
+  # ── pipe/2: Chain WASM calls where output feeds into next input ─────
+
+  @doc """
+  Chain WASM function calls, feeding the output of each call as the first
+  argument to the next. Loads the module once, runs the pipeline, and
+  cleans up automatically.
+
+  The first call in the pipeline is executed normally. For each subsequent
+  call, the result of the previous call is prepended to the argument list.
+  Use the `:pipe` atom as a placeholder in argument lists to control where
+  the piped value is inserted (defaults to first position).
+
+  ## Examples
+
+      # Chain: add(5,3) → fibonacci(8) → multiply(21, 2)
+      {:ok, 42} = WasmRunner.pipe("math.wasm", [
+        {:add, [5, 3]},           # => 8
+        {:fibonacci, []},          # => fibonacci(8) = 21
+        {:multiply, [:pipe, 2]}    # => multiply(21, 2) = 42
+      ])
+
+      # Piped value goes to first arg by default
+      {:ok, 55} = WasmRunner.pipe("math.wasm", [
+        {:add, [5, 5]},       # => 10
+        {:fibonacci, []}       # => fibonacci(10) = 55
+      ])
+
+      # Use :pipe placeholder for explicit positioning
+      {:ok, 7} = WasmRunner.pipe("math.wasm", [
+        {:add, [2, 3]},           # => 5
+        {:add, [2, :pipe]}        # => add(2, 5) = 7
+      ])
+
+      # With options
+      {:ok, result} = WasmRunner.pipe("go_math.wasm", [
+        {:add, [5, 3]},
+        {:multiply, [:pipe, 10]}
+      ], wasi: true)
+
+  ## How the pipe works
+
+  1. The first call is executed with its arguments as-is
+  2. For each subsequent call:
+     - If args contain `:pipe`, each `:pipe` is replaced with the previous result
+     - If args don't contain `:pipe`, the previous result is prepended as the first arg
+  3. The final result is returned unwrapped
+
+  ## Options
+
+  Options are passed through to `start/2`:
+  - `:wasi` — force WASI mode (auto-detected if not specified)
+  - `:cache` — use module cache for repeated loads
+  - `:timeout` — execution timeout in milliseconds per call (default: 5000)
+  """
+  @spec pipe(binary() | String.t() | map(), [{atom() | String.t(), list()}], keyword()) ::
+          {:ok, term()} | {:error, term()}
+  def pipe(wasm_source, calls, opts \\ []) when is_list(calls) do
+    {call_opts, start_opts} = extract_call_opts(opts)
+
+    if calls == [] do
+      {:error, :no_calls}
+    else
+      case start(wasm_source, start_opts) do
+        {:ok, pid} ->
+          try do
+            [first_call | rest] = calls
+            {first_func, first_args} = first_call
+            first_result = call_single!(pid, first_func, first_args, call_opts)
+
+            final =
+              Enum.reduce(rest, first_result, fn {func, args}, prev ->
+                resolved_args = resolve_pipe_args(args, prev)
+                call_single!(pid, func, resolved_args, call_opts)
+              end)
+
+            {:ok, final}
+          rescue
+            e -> {:error, Exception.message(e)}
+          after
+            Firebird.stop(pid)
+          end
+
+        {:error, _} = error ->
+          error
+      end
+    end
+  end
+
+  @doc """
+  Like `pipe/3` but raises on error.
+
+  ## Examples
+
+      42 = WasmRunner.pipe!("math.wasm", [
+        {:add, [5, 3]},
+        {:fibonacci, []},
+        {:multiply, [:pipe, 2]}
+      ])
+  """
+  @spec pipe!(binary() | String.t() | map(), [{atom() | String.t(), list()}], keyword()) :: term()
+  def pipe!(wasm_source, calls, opts \\ []) do
+    case pipe(wasm_source, calls, opts) do
+      {:ok, result} -> result
+      {:error, reason} -> raise "WASM pipe failed: #{inspect(reason)}"
+    end
+  end
+
+  # Resolve :pipe placeholders in argument lists.
+  # If args contain :pipe, replace each occurrence with the piped value.
+  # If args don't contain :pipe, prepend the piped value as first arg.
+  defp resolve_pipe_args([], prev), do: [prev]
+
+  defp resolve_pipe_args(args, prev) do
+    if Enum.member?(args, :pipe) do
+      Enum.map(args, fn
+        :pipe -> prev
+        other -> other
+      end)
+    else
+      [prev | args]
+    end
+  end
+
+  # Split a keyword list into {calls, opts}.
+  # Calls are entries where the value is a list of arguments (function calls).
+  # Opts are known option keys like :wasi, :cache, etc.
+  @known_opts ~w(wasi cache timeout)a
+
+  defp split_calls_and_opts(keyword_list) do
+    {opts, calls} =
+      Enum.split_with(keyword_list, fn {key, _val} ->
+        key in @known_opts
+      end)
+
+    {calls, opts}
+  end
+
+  # Separate call-level opts (timeout) from start-level opts (wasi, cache).
+  # Returns {call_opts, start_opts}.
+  @call_opts ~w(timeout)a
+  defp extract_call_opts(opts) do
+    {call_opts, start_opts} =
+      Enum.split_with(opts, fn {key, _val} ->
+        key in @call_opts
+      end)
+
+    {call_opts, start_opts}
+  end
+
+  # ── Collection helpers: map, reduce, filter over WASM ─────────────────
+
+  @doc """
+  Apply a WASM function to each element of a collection.
+
+  Loads the WASM module once, calls the given function for each element
+  in `enumerable`, and returns the mapped results. The instance is
+  automatically cleaned up.
+
+  Input elements are normalized:
+  - Single values become `[value]` argument lists
+  - Tuples are spread as positional arguments: `{a, b}` → `[a, b]`
+  - Lists are used as argument lists directly
+
+  ## Options
+
+  Passed through to `start/2`:
+  - `:wasi` — WASI configuration (auto-detected if not specified)
+  - `:cache` — Use module cache (default: false)
+  - `:timeout` — Per-call timeout in ms (default: 5000)
+
+  ## Examples
+
+      # Map fibonacci over a range
+      {:ok, results} = WasmRunner.map("math.wasm", :fibonacci, 1..5)
+      # => [1, 1, 2, 3, 5]
+
+      # Map a two-arg function over tuples
+      {:ok, results} = WasmRunner.map("math.wasm", :add, [{1, 2}, {3, 4}, {5, 6}])
+      # => [3, 7, 11]
+
+      # Map over explicit arg lists
+      {:ok, results} = WasmRunner.map("math.wasm", :add, [[1, 2], [3, 4]])
+      # => [3, 7]
+
+      # With precompiled module
+      {:ok, compiled} = WasmRunner.precompile("math.wasm")
+      {:ok, results} = WasmRunner.map(compiled, :multiply, [{2, 3}, {4, 5}])
+      # => [6, 20]
+  """
+  @spec map(binary() | String.t() | map(), atom() | String.t(), Enumerable.t(), keyword()) ::
+          {:ok, list()} | {:error, term()}
+  def map(wasm_source, function, enumerable, opts \\ []) do
+    {call_opts, start_opts} = extract_call_opts(opts)
+
+    case start(wasm_source, start_opts) do
+      {:ok, pid} ->
+        try do
+          results =
+            Enum.map(enumerable, fn input ->
+              args = normalize_args(input)
+              call_single!(pid, function, args, call_opts)
+            end)
+
+          {:ok, results}
+        rescue
+          e -> {:error, Exception.message(e)}
+        after
+          Firebird.stop(pid)
+        end
+
+      {:error, _} = error ->
+        error
+    end
+  end
+
+  @doc """
+  Like `map/4` but raises on error.
+
+  ## Examples
+
+      [1, 1, 2, 3, 5] = WasmRunner.map!("math.wasm", :fibonacci, 1..5)
+  """
+  @spec map!(binary() | String.t() | map(), atom() | String.t(), Enumerable.t(), keyword()) ::
+          list()
+  def map!(wasm_source, function, enumerable, opts \\ []) do
+    case map(wasm_source, function, enumerable, opts) do
+      {:ok, results} -> results
+      {:error, reason} -> raise "WASM map failed: #{inspect(reason)}"
+    end
+  end
+
+  @doc """
+  Reduce a collection through a WASM function, accumulating a result.
+
+  Calls `function(accumulator, element)` for each element in `enumerable`,
+  threading the result as the new accumulator. The WASM function must accept
+  two i32 arguments and return one i32 result.
+
+  The instance is loaded once and cleaned up automatically.
+
+  ## Options
+
+  Passed through to `start/2` (`:wasi`, `:cache`, `:timeout`).
+
+  ## Examples
+
+      # Sum a list using WASM add
+      {:ok, 15} = WasmRunner.reduce("math.wasm", :add, [1, 2, 3, 4, 5], 0)
+
+      # Multiply a list using WASM multiply
+      {:ok, 120} = WasmRunner.reduce("math.wasm", :multiply, [1, 2, 3, 4, 5], 1)
+
+      # With precompiled module
+      {:ok, compiled} = WasmRunner.precompile("math.wasm")
+      {:ok, 10} = WasmRunner.reduce(compiled, :add, [1, 2, 3, 4], 0)
+  """
+  @spec reduce(
+          binary() | String.t() | map(),
+          atom() | String.t(),
+          Enumerable.t(),
+          integer(),
+          keyword()
+        ) ::
+          {:ok, term()} | {:error, term()}
+  def reduce(wasm_source, function, enumerable, initial, opts \\ []) do
+    {call_opts, start_opts} = extract_call_opts(opts)
+
+    case start(wasm_source, start_opts) do
+      {:ok, pid} ->
+        try do
+          result =
+            Enum.reduce(enumerable, initial, fn element, acc ->
+              call_single!(pid, function, [acc, element], call_opts)
+            end)
+
+          {:ok, result}
+        rescue
+          e -> {:error, Exception.message(e)}
+        after
+          Firebird.stop(pid)
+        end
+
+      {:error, _} = error ->
+        error
+    end
+  end
+
+  @doc """
+  Like `reduce/5` but raises on error.
+
+  ## Examples
+
+      15 = WasmRunner.reduce!("math.wasm", :add, [1, 2, 3, 4, 5], 0)
+  """
+  @spec reduce!(
+          binary() | String.t() | map(),
+          atom() | String.t(),
+          Enumerable.t(),
+          integer(),
+          keyword()
+        ) :: term()
+  def reduce!(wasm_source, function, enumerable, initial, opts \\ []) do
+    case reduce(wasm_source, function, enumerable, initial, opts) do
+      {:ok, result} -> result
+      {:error, reason} -> raise "WASM reduce failed: #{inspect(reason)}"
+    end
+  end
+
+  @doc """
+  Filter a collection using a WASM predicate function.
+
+  Calls `function(element)` for each element. Keeps elements where the
+  WASM function returns a non-zero value (truthy in WASM i32 convention).
+
+  The instance is loaded once and cleaned up automatically.
+
+  Input elements are normalized the same way as `map/4`.
+
+  ## Options
+
+  Passed through to `start/2` (`:wasi`, `:cache`, `:timeout`).
+
+  ## Examples
+
+      # Filter using a WASM "is_even" function that returns 1 for even, 0 for odd
+      {:ok, evens} = WasmRunner.filter("math.wasm", :is_even, [1, 2, 3, 4, 5, 6])
+      # => [2, 4, 6]
+
+      # Filter with a WASM predicate on tuples
+      {:ok, results} = WasmRunner.filter("math.wasm", :greater_than, [{5, 3}, {1, 4}, {7, 2}])
+      # => [{5, 3}, {7, 2}]  (where greater_than(a, b) returns 1 if a > b)
+  """
+  @spec filter(binary() | String.t() | map(), atom() | String.t(), Enumerable.t(), keyword()) ::
+          {:ok, list()} | {:error, term()}
+  def filter(wasm_source, function, enumerable, opts \\ []) do
+    {call_opts, start_opts} = extract_call_opts(opts)
+
+    case start(wasm_source, start_opts) do
+      {:ok, pid} ->
+        try do
+          results =
+            Enum.filter(enumerable, fn input ->
+              args = normalize_args(input)
+              result = call_single!(pid, function, args, call_opts)
+              result != 0
+            end)
+
+          {:ok, results}
+        rescue
+          e -> {:error, Exception.message(e)}
+        after
+          Firebird.stop(pid)
+        end
+
+      {:error, _} = error ->
+        error
+    end
+  end
+
+  @doc """
+  Like `filter/4` but raises on error.
+
+  ## Examples
+
+      [2, 4, 6] = WasmRunner.filter!("math.wasm", :is_even, [1, 2, 3, 4, 5, 6])
+  """
+  @spec filter!(binary() | String.t() | map(), atom() | String.t(), Enumerable.t(), keyword()) ::
+          list()
+  def filter!(wasm_source, function, enumerable, opts \\ []) do
+    case filter(wasm_source, function, enumerable, opts) do
+      {:ok, results} -> results
+      {:error, reason} -> raise "WASM filter failed: #{inspect(reason)}"
+    end
+  end
+
+  @doc """
+  Apply a WASM function to each element for side-effects only.
+
+  Like `map/4` but discards results. Useful for WASM functions that
+  modify linear memory or have other side effects.
+
+  ## Examples
+
+      :ok = WasmRunner.each("math.wasm", :fibonacci, 1..10)
+  """
+  @spec each(binary() | String.t() | map(), atom() | String.t(), Enumerable.t(), keyword()) ::
+          :ok | {:error, term()}
+  def each(wasm_source, function, enumerable, opts \\ []) do
+    case map(wasm_source, function, enumerable, opts) do
+      {:ok, _} -> :ok
+      {:error, _} = error -> error
+    end
+  end
+
+  # Normalize input values into argument lists for WASM calls.
+  # - Single integers/floats → [value]
+  # - Tuples → Tuple.to_list(tuple)
+  # - Lists → used as-is
+  defp normalize_args(value) when is_integer(value), do: [value]
+  defp normalize_args(value) when is_float(value), do: [value]
+  defp normalize_args(value) when is_tuple(value), do: Tuple.to_list(value)
+  defp normalize_args(value) when is_list(value), do: value
+
   @doc """
   Detect whether a WASM module requires WASI by inspecting its imports.
 
@@ -188,6 +685,7 @@ defmodule Firebird.WasmRunner do
       if String.printable?(source) do
         # File path — read it
         path = Firebird.Runtime.resolve_wasm_path(source)
+
         case File.read(path) do
           {:ok, bytes} -> bytes
           {:error, _} -> nil
@@ -201,10 +699,20 @@ defmodule Firebird.WasmRunner do
 
   @doc """
   Call a function and return a single result value (unwrapped from list).
+
+  ## Options
+
+  - `:timeout` — Execution timeout in milliseconds (passed to `Firebird.call/4`)
+
+  ## Examples
+
+      {:ok, 8} = Firebird.WasmRunner.call_single(instance, :add, [5, 3])
+      {:ok, 8} = Firebird.WasmRunner.call_single(instance, :add, [5, 3], timeout: 1000)
   """
-  @spec call_single(pid(), atom() | String.t(), list()) :: {:ok, integer()} | {:error, term()}
-  def call_single(instance, function, args) do
-    case Firebird.call(instance, function, args) do
+  @spec call_single(pid(), atom() | String.t(), list(), keyword()) ::
+          {:ok, integer()} | {:error, term()}
+  def call_single(instance, function, args, opts \\ []) do
+    case Firebird.call(instance, function, args, opts) do
       {:ok, [result]} -> {:ok, result}
       {:ok, results} -> {:ok, results}
       error -> error
@@ -213,10 +721,19 @@ defmodule Firebird.WasmRunner do
 
   @doc """
   Call a function and return a single result, raising on error.
+
+  ## Options
+
+  - `:timeout` — Execution timeout in milliseconds (passed to `Firebird.call/4`)
+
+  ## Examples
+
+      8 = Firebird.WasmRunner.call_single!(instance, :add, [5, 3])
+      8 = Firebird.WasmRunner.call_single!(instance, :add, [5, 3], timeout: 1000)
   """
-  @spec call_single!(pid(), atom() | String.t(), list()) :: integer()
-  def call_single!(instance, function, args) do
-    case call_single(instance, function, args) do
+  @spec call_single!(pid(), atom() | String.t(), list(), keyword()) :: integer()
+  def call_single!(instance, function, args, opts \\ []) do
+    case call_single(instance, function, args, opts) do
       {:ok, result} -> result
       {:error, reason} -> raise "WASM call failed: #{inspect(reason)}"
     end
@@ -241,13 +758,17 @@ defmodule Firebird.WasmRunner do
       {:ok, results} = Firebird.WasmRunner.run_batch(compiled, [{:add, [5, 3]}, {:multiply, [4, 7]}])
   """
   @spec run_batch(binary() | String.t() | map(), [{atom() | String.t(), list()}], keyword()) ::
-    {:ok, list()} | {:error, term()}
+          {:ok, list()} | {:error, term()}
   def run_batch(wasm_source, calls, opts \\ []) do
-    with {:ok, pid} <- start(wasm_source, opts) do
+    {call_opts, start_opts} = extract_call_opts(opts)
+
+    with {:ok, pid} <- start(wasm_source, start_opts) do
       try do
-        results = Enum.map(calls, fn {func, args} ->
-          call_single!(pid, func, args)
-        end)
+        results =
+          Enum.map(calls, fn {func, args} ->
+            call_single!(pid, func, args, call_opts)
+          end)
+
         {:ok, results}
       rescue
         e -> {:error, Exception.message(e)}
@@ -294,7 +815,8 @@ defmodule Firebird.WasmRunner do
       end)
   """
   @spec with_instance(binary() | String.t() | map(), keyword(), (pid() -> result)) ::
-    {:ok, result} | {:error, term()} when result: var
+          {:ok, result} | {:error, term()}
+        when result: var
   def with_instance(wasm_source, opts \\ [], fun) when is_function(fun, 1) do
     case start(wasm_source, opts) do
       {:ok, pid} ->
@@ -371,8 +893,10 @@ defmodule Firebird.WasmRunner do
           else
             {:error, {:arity_mismatch, func_name, expected: length(params), got: length(args)}}
           end
+
         _ ->
-          :ok  # Can't verify type, let it through
+          # Can't verify type, let it through
+          :ok
       end
     end
   end
@@ -383,29 +907,31 @@ defmodule Firebird.WasmRunner do
   Useful for verifying cross-language consistency.
   """
   @spec compare(
-    [{binary() | String.t() | map(), keyword()}],
-    atom() | String.t(),
-    list()
-  ) :: {:ok, [{binary() | String.t() | map(), list()}]} | {:error, term()}
+          [{binary() | String.t() | map(), keyword()}],
+          atom() | String.t(),
+          list()
+        ) :: {:ok, [{binary() | String.t() | map(), list()}]} | {:error, term()}
   def compare(modules, function, args) do
-    results = Enum.map(modules, fn
-      {source, opts} ->
-        with {:ok, pid} <- start(source, opts),
-             {:ok, result} <- Firebird.call(pid, function, args) do
-          Firebird.stop(pid)
-          {source, {:ok, result}}
-        else
-          error -> {source, error}
-        end
-      source when is_binary(source) ->
-        with {:ok, pid} <- start(source),
-             {:ok, result} <- Firebird.call(pid, function, args) do
-          Firebird.stop(pid)
-          {source, {:ok, result}}
-        else
-          error -> {source, error}
-        end
-    end)
+    results =
+      Enum.map(modules, fn
+        {source, opts} ->
+          with {:ok, pid} <- start(source, opts),
+               {:ok, result} <- Firebird.call(pid, function, args) do
+            Firebird.stop(pid)
+            {source, {:ok, result}}
+          else
+            error -> {source, error}
+          end
+
+        source when is_binary(source) ->
+          with {:ok, pid} <- start(source),
+               {:ok, result} <- Firebird.call(pid, function, args) do
+            Firebird.stop(pid)
+            {source, {:ok, result}}
+          else
+            error -> {source, error}
+          end
+      end)
 
     {:ok, results}
   end
@@ -429,11 +955,17 @@ defmodule Firebird.WasmRunner do
         "fixtures/rust_math.wasm", :fibonacci, args_list, concurrency: 4
       )
   """
-  @spec run_concurrent(binary() | String.t() | map(), atom() | String.t(), [[integer()]], keyword()) ::
-    {:ok, [term()]} | {:error, term()}
+  @spec run_concurrent(
+          binary() | String.t() | map(),
+          atom() | String.t(),
+          [[integer()]],
+          keyword()
+        ) ::
+          {:ok, [term()]} | {:error, term()}
   def run_concurrent(wasm_source, function, args_list, opts \\ []) do
     concurrency = Keyword.get(opts, :concurrency, System.schedulers_online())
     wasm_opts = Keyword.drop(opts, [:concurrency])
+    {call_opts, wasm_opts} = extract_call_opts(wasm_opts)
 
     # Precompile once, then create all instances from the compiled module.
     # This avoids recompiling the same WASM bytes N times.
@@ -465,6 +997,7 @@ defmodule Firebird.WasmRunner do
                       {:error, reason} -> throw({:start_error, reason})
                     end
                   end
+
                 {List.to_tuple(pids), pids}
             end
         end
@@ -482,8 +1015,9 @@ defmodule Firebird.WasmRunner do
           |> Task.async_stream(
             fn {args, idx} ->
               instance = elem(instances_tuple, rem(idx, concurrency))
+
               try do
-                call_single!(instance, function, args)
+                call_single!(instance, function, args, call_opts)
               rescue
                 e -> {:error, Exception.message(e)}
               end
@@ -517,7 +1051,8 @@ defmodule Firebird.WasmRunner do
       {time_us, {:ok, [55]}} = Firebird.WasmRunner.timed_call(instance, :fibonacci, [10])
       IO.puts("Took \#{time_us}μs")
   """
-  @spec timed_call(pid(), atom() | String.t(), list()) :: {non_neg_integer(), {:ok, list()} | {:error, term()}}
+  @spec timed_call(pid(), atom() | String.t(), list()) ::
+          {non_neg_integer(), {:ok, list()} | {:error, term()}}
   def timed_call(instance, function, args) do
     :timer.tc(fn -> Firebird.call(instance, function, args) end)
   end
@@ -536,10 +1071,11 @@ defmodule Firebird.WasmRunner do
     memories = Enum.count(all, fn {_, type} -> type == :memory end)
     globals = Enum.count(all, fn {_, type} -> type == :global end)
 
-    mem_info = case Firebird.memory_size(instance) do
-      {:ok, size} -> %{memory_bytes: size, memory_pages: div(size, 65536)}
-      _ -> %{memory_bytes: 0, memory_pages: 0}
-    end
+    mem_info =
+      case Firebird.memory_size(instance) do
+        {:ok, size} -> %{memory_bytes: size, memory_pages: div(size, 65536)}
+        _ -> %{memory_bytes: 0, memory_pages: 0}
+      end
 
     Map.merge(mem_info, %{
       functions: exports,
@@ -601,8 +1137,13 @@ defmodule Firebird.WasmRunner do
           r
         end)
   """
-  @spec with_memory(binary() | String.t() | map(), keyword(), (pid(), Firebird.Memory.t() -> result)) ::
-    {:ok, result} | {:error, term()} when result: var
+  @spec with_memory(
+          binary() | String.t() | map(),
+          keyword(),
+          (pid(), Firebird.Memory.t() -> result)
+        ) ::
+          {:ok, result} | {:error, term()}
+        when result: var
   def with_memory(wasm_source, opts \\ [], fun) when is_function(fun, 2) do
     {memory_opts, wasm_opts} = Keyword.pop(opts, :memory, [])
 
@@ -672,11 +1213,11 @@ defmodule Firebird.WasmRunner do
       )
   """
   @spec call_with_strings(
-    binary() | String.t() | map(),
-    atom() | String.t(),
-    [String.t()],
-    keyword()
-  ) :: {:ok, term()} | {:error, term()}
+          binary() | String.t() | map(),
+          atom() | String.t(),
+          [String.t()],
+          keyword()
+        ) :: {:ok, term()} | {:error, term()}
   def call_with_strings(wasm_source, function, strings, opts \\ []) when is_list(strings) do
     result_mode = Keyword.get(opts, :result, :raw)
     extra_args = Keyword.get(opts, :extra_args, [])
@@ -701,6 +1242,7 @@ defmodule Firebird.WasmRunner do
                 [ptr, len] ->
                   {:ok, str} = Firebird.Memory.read_string(mem, ptr, len)
                   str
+
                 _ ->
                   raise "Expected [ptr, len] result for :string mode, got: #{inspect(result)}"
               end
@@ -747,10 +1289,10 @@ defmodule Firebird.WasmRunner do
       # results => [hash1, hash2, encrypted_len]
   """
   @spec run_memory_batch(
-    binary() | String.t() | map(),
-    [map()],
-    keyword()
-  ) :: {:ok, [term()]} | {:error, term()}
+          binary() | String.t() | map(),
+          [map()],
+          keyword()
+        ) :: {:ok, [term()]} | {:error, term()}
   def run_memory_batch(wasm_source, calls, opts \\ []) when is_list(calls) do
     with_memory(wasm_source, opts, fn pid, mem ->
       Enum.map(calls, fn call_spec ->
@@ -761,43 +1303,46 @@ defmodule Firebird.WasmRunner do
         result_mode = Map.get(call_spec, :result, :raw)
 
         # Use arena so memory is reclaimed after each call
-        {result, _mem} = Firebird.Memory.with_arena(mem, fn mem ->
-          # Write strings as (ptr, len) pairs — prepend + reverse to avoid O(n²)
-          {mem, string_args_rev} =
-            Enum.reduce(strings, {mem, []}, fn str, {m, acc} ->
-              {m, ptr, len} = Firebird.Memory.write_string(m, str)
-              {m, [len, ptr | acc]}
-            end)
-
-          # Write typed arrays as (ptr, count) pairs — same pattern
-          {mem, array_args_rev} =
-            Enum.reduce(arrays, {mem, []}, fn {type, values}, {m, acc} ->
-              {m, ptr, count} = write_typed_array(m, type, values)
-              {m, [count, ptr | acc]}
-            end)
-
-          all_args = Enum.reverse(string_args_rev) ++ Enum.reverse(array_args_rev) ++ extra_args
-
-          result =
-            case Firebird.call(pid, function, all_args) do
-              {:ok, result} ->
-                case result_mode do
-                  :string ->
-                    [ptr, len] = result
-                    {:ok, str} = Firebird.Memory.read_string(mem, ptr, len)
-                    str
-                  :i32 ->
-                    hd(result)
-                  :raw ->
-                    result
-                end
+        {result, _mem} =
+          Firebird.Memory.with_arena(mem, fn mem ->
+            # Write strings as (ptr, len) pairs — prepend + reverse to avoid O(n²)
+            {mem, string_args_rev} =
+              Enum.reduce(strings, {mem, []}, fn str, {m, acc} ->
+                {m, ptr, len} = Firebird.Memory.write_string(m, str)
+                {m, [len, ptr | acc]}
+              end)
+
+            # Write typed arrays as (ptr, count) pairs — same pattern
+            {mem, array_args_rev} =
+              Enum.reduce(arrays, {mem, []}, fn {type, values}, {m, acc} ->
+                {m, ptr, count} = write_typed_array(m, type, values)
+                {m, [count, ptr | acc]}
+              end)
+
+            all_args = Enum.reverse(string_args_rev) ++ Enum.reverse(array_args_rev) ++ extra_args
+
+            result =
+              case Firebird.call(pid, function, all_args) do
+                {:ok, result} ->
+                  case result_mode do
+                    :string ->
+                      [ptr, len] = result
+                      {:ok, str} = Firebird.Memory.read_string(mem, ptr, len)
+                      str
+
+                    :i32 ->
+                      hd(result)
+
+                    :raw ->
+                      result
+                  end
 
-              {:error, reason} ->
-                raise "WASM call failed: #{inspect(reason)}"
-            end
+                {:error, reason} ->
+                  raise "WASM call failed: #{inspect(reason)}"
+              end
 
-          {result, mem}
-        end)
+            {result, mem}
+          end)
 
         result
       end)
@@ -859,15 +1404,16 @@ defmodule Firebird.WasmRunner do
       )
   """
   @spec benchmark(
-    binary() | String.t() | map(),
-    atom() | String.t(),
-    [[integer()]],
-    keyword()
-  ) :: map()
+          binary() | String.t() | map(),
+          atom() | String.t(),
+          [[integer()]],
+          keyword()
+        ) :: map()
   def benchmark(wasm_source, function, args_list, opts \\ []) do
     iterations = Keyword.get(opts, :iterations, 100)
     warmup = Keyword.get(opts, :warmup, 10)
     wasm_opts = Keyword.drop(opts, [:iterations, :warmup])
+    {call_opts, wasm_opts} = extract_call_opts(wasm_opts)
 
     # Measure cold start (loading the module)
     {cold_start_us, {:ok, pid}} = :timer.tc(fn -> start(wasm_source, wasm_opts) end)
@@ -876,18 +1422,20 @@ defmodule Firebird.WasmRunner do
       # Warmup phase — get JIT/caches hot
       for _ <- 1..warmup do
         Enum.each(args_list, fn args ->
-          Firebird.call(pid, function, args)
+          Firebird.call(pid, function, args, call_opts)
         end)
       end
 
       # Timed iterations
       times =
         for _ <- 1..iterations do
-          {elapsed, _} = :timer.tc(fn ->
-            Enum.each(args_list, fn args ->
-              Firebird.call(pid, function, args)
+          {elapsed, _} =
+            :timer.tc(fn ->
+              Enum.each(args_list, fn args ->
+                Firebird.call(pid, function, args, call_opts)
+              end)
             end)
-          end)
+
           elapsed
         end
 
@@ -956,16 +1504,17 @@ defmodule Firebird.WasmRunner do
       IO.puts(Firebird.WasmRunner.format_benchmark(result))
   """
   @spec benchmark_compare(
-    binary() | String.t() | map(),
-    atom() | String.t(),
-    [[integer()]],
-    keyword()
-  ) :: map()
+          binary() | String.t() | map(),
+          atom() | String.t(),
+          [[integer()]],
+          keyword()
+        ) :: map()
   def benchmark_compare(wasm_source, function, args_list, opts \\ []) do
     beam_fun = Keyword.fetch!(opts, :beam_fun)
     iterations = Keyword.get(opts, :iterations, 100)
     warmup = Keyword.get(opts, :warmup, 10)
     wasm_opts = Keyword.drop(opts, [:iterations, :warmup, :beam_fun])
+    {call_opts, wasm_opts} = extract_call_opts(wasm_opts)
 
     # --- WASM benchmark ---
     {cold_start_us, {:ok, pid}} = :timer.tc(fn -> start(wasm_source, wasm_opts) end)
@@ -974,7 +1523,7 @@ defmodule Firebird.WasmRunner do
       # Warmup both
       for _ <- 1..warmup do
         Enum.each(args_list, fn args ->
-          Firebird.call(pid, function, args)
+          Firebird.call(pid, function, args, call_opts)
           apply_beam_fun(beam_fun, args)
         end)
       end
@@ -982,22 +1531,26 @@ defmodule Firebird.WasmRunner do
       # Time WASM
       wasm_times =
         for _ <- 1..iterations do
-          {elapsed, _} = :timer.tc(fn ->
-            Enum.each(args_list, fn args ->
-              Firebird.call(pid, function, args)
+          {elapsed, _} =
+            :timer.tc(fn ->
+              Enum.each(args_list, fn args ->
+                Firebird.call(pid, function, args, call_opts)
+              end)
             end)
-          end)
+
           elapsed
         end
 
       # Time BEAM
       beam_times =
         for _ <- 1..iterations do
-          {elapsed, _} = :timer.tc(fn ->
-            Enum.each(args_list, fn args ->
-              apply_beam_fun(beam_fun, args)
+          {elapsed, _} =
+            :timer.tc(fn ->
+              Enum.each(args_list, fn args ->
+                apply_beam_fun(beam_fun, args)
+              end)
             end)
-          end)
+
           elapsed
         end
 
@@ -1085,7 +1638,9 @@ defmodule Firebird.WasmRunner do
   end
 
   # Pad a numeric value to 8 chars with "μs" suffix
-  defp pad_num(val) when is_float(val), do: String.pad_leading("#{Float.round(val, 1)}", 6) <> " μs"
+  defp pad_num(val) when is_float(val),
+    do: String.pad_leading("#{Float.round(val, 1)}", 6) <> " μs"
+
   defp pad_num(val) when is_integer(val), do: String.pad_leading("#{val}", 6) <> " μs"
   defp pad_num(val), do: String.pad_leading("#{val}", 6) <> " μs"
 
@@ -1113,8 +1668,9 @@ defmodule Firebird.WasmRunner do
   end
 
   defp bench_percentile([], _p), do: 0
+
   defp bench_percentile(sorted, p) do
-    k = (p / 100) * (length(sorted) - 1)
+    k = p / 100 * (length(sorted) - 1)
     f = trunc(k)
     c = Float.ceil(k) |> trunc()
 
@@ -1129,6 +1685,7 @@ defmodule Firebird.WasmRunner do
 
   defp bench_stddev(values, mean) do
     count = length(values)
+
     if count <= 1 do
       0.0
     else
diff --git a/lib/firebird/wasm_string.ex b/lib/firebird/wasm_string.ex
index f93bdbd..0d0f25d 100644
--- a/lib/firebird/wasm_string.ex
+++ b/lib/firebird/wasm_string.ex
@@ -33,7 +33,8 @@ defmodule Firebird.WasmString do
 
   Returns `{:ok, pointer, byte_length}` or `{:error, reason}`.
   """
-  @spec write_string(pid(), String.t()) :: {:ok, non_neg_integer(), non_neg_integer()} | {:error, term()}
+  @spec write_string(pid(), String.t()) ::
+          {:ok, non_neg_integer(), non_neg_integer()} | {:error, term()}
   def write_string(instance, string) when is_binary(string) do
     len = byte_size(string)
 
@@ -46,7 +47,8 @@ defmodule Firebird.WasmString do
   @doc """
   Read a string from WASM memory at the given pointer and length.
   """
-  @spec read_string(pid(), non_neg_integer(), non_neg_integer()) :: {:ok, String.t()} | {:error, term()}
+  @spec read_string(pid(), non_neg_integer(), non_neg_integer()) ::
+          {:ok, String.t()} | {:error, term()}
   def read_string(instance, ptr, len) do
     Firebird.read_memory(instance, ptr, len)
   end
@@ -76,7 +78,8 @@ defmodule Firebird.WasmString do
 
       {:ok, "HELLO"} = Firebird.WasmString.call_with_string(wasm, :to_uppercase, "hello")
   """
-  @spec call_with_string(pid(), atom() | String.t(), String.t(), list()) :: {:ok, String.t()} | {:error, term()}
+  @spec call_with_string(pid(), atom() | String.t(), String.t(), list()) ::
+          {:ok, String.t()} | {:error, term()}
   def call_with_string(instance, function, string, extra_args \\ []) do
     with {:ok, ptr, len} <- write_string(instance, string),
          {:ok, [result_len]} <- Firebird.call(instance, function, [ptr, len | extra_args]),
diff --git a/lib/mix/compilers/firebird_nif.ex b/lib/mix/compilers/firebird_nif.ex
index 5be1a92..5578dc6 100644
--- a/lib/mix/compilers/firebird_nif.ex
+++ b/lib/mix/compilers/firebird_nif.ex
@@ -32,7 +32,9 @@ defmodule Mix.Tasks.Compile.FirebirdNif do
 
         case System.cmd("cargo", ["build", "--release"],
                cd: native_dir,
-               env: [{"PATH", System.get_env("PATH", "") <> ":#{System.get_env("HOME")}/.cargo/bin"}],
+               env: [
+                 {"PATH", System.get_env("PATH", "") <> ":#{System.get_env("HOME")}/.cargo/bin"}
+               ],
                stderr_to_stdout: true
              ) do
           {_output, 0} ->
@@ -52,7 +54,8 @@ defmodule Mix.Tasks.Compile.FirebirdNif do
           {output, code} ->
             Mix.shell().error("Firebird NIF compilation failed (exit #{code}):")
             Mix.shell().error(output)
-            :ok  # Don't fail the build - SyncNif is optional
+            # Don't fail the build - SyncNif is optional
+            :ok
         end
       else
         :ok
diff --git a/lib/mix/compilers/firebird_wasm.ex b/lib/mix/compilers/firebird_wasm.ex
index 6024566..7a3f039 100644
--- a/lib/mix/compilers/firebird_wasm.ex
+++ b/lib/mix/compilers/firebird_wasm.ex
@@ -70,8 +70,7 @@ defmodule Mix.Compilers.FirebirdWasm do
       failures = Enum.filter(results, &match?({:error, _}, &1))
 
       # Update manifest with successful compilations
-      new_entries =
-        Enum.map(successes, fn {:ok, entry} -> entry end)
+      new_entries = Enum.map(successes, fn {:ok, entry} -> entry end)
 
       # Keep non-stale entries from old manifest
       stale_paths = MapSet.new(stale)
@@ -153,7 +152,8 @@ defmodule Mix.Compilers.FirebirdWasm do
   defp stale_sources(sources, manifest) do
     manifest_map =
       Map.new(manifest, fn entry ->
-        {entry.source, %{compiled_at: entry.compiled_at, content_hash: Map.get(entry, :content_hash)}}
+        {entry.source,
+         %{compiled_at: entry.compiled_at, content_hash: Map.get(entry, :content_hash)}}
       end)
 
     Enum.filter(sources, fn source ->
@@ -172,6 +172,7 @@ defmodule Mix.Compilers.FirebirdWasm do
             {:ok, %{mtime: mtime}} ->
               mtime_seconds = :calendar.datetime_to_gregorian_seconds(mtime)
               mtime_seconds > compiled_at
+
             _ ->
               true
           end
diff --git a/lib/mix/tasks/compile.wasm.ex b/lib/mix/tasks/compile.wasm.ex
index 5f587b7..f099ee9 100644
--- a/lib/mix/tasks/compile.wasm.ex
+++ b/lib/mix/tasks/compile.wasm.ex
@@ -142,6 +142,7 @@ defmodule Mix.Tasks.Compile.Wasm do
             if verbose do
               Mix.shell().info("  Compiled #{Path.relative_to_cwd(source)} → #{result.module}")
             end
+
             {:ok, Map.put(result, :source_file, source)}
 
           {:error, reason} ->
@@ -152,22 +153,26 @@ defmodule Mix.Tasks.Compile.Wasm do
     diagnostics =
       Enum.flat_map(results, fn
         {:ok, result} ->
-          [%Mix.Task.Compiler.Diagnostic{
-            compiler_name: "wasm",
-            file: Map.get(result, :source_file, "unknown"),
-            message: "Compiled #{result.module} to WASM",
-            position: 0,
-            severity: :information
-          }]
+          [
+            %Mix.Task.Compiler.Diagnostic{
+              compiler_name: "wasm",
+              file: Map.get(result, :source_file, "unknown"),
+              message: "Compiled #{result.module} to WASM",
+              position: 0,
+              severity: :information
+            }
+          ]
 
         {:error, {source, reason}} ->
-          [%Mix.Task.Compiler.Diagnostic{
-            compiler_name: "wasm",
-            file: source,
-            message: format_error(reason),
-            position: error_position(reason),
-            severity: :error
-          }]
+          [
+            %Mix.Task.Compiler.Diagnostic{
+              compiler_name: "wasm",
+              file: source,
+              message: format_error(reason),
+              position: error_position(reason),
+              severity: :error
+            }
+          ]
       end)
 
     successes = Enum.filter(results, &match?({:ok, _}, &1)) |> Enum.map(fn {:ok, r} -> r end)
@@ -210,7 +215,9 @@ defmodule Mix.Tasks.Compile.Wasm do
           entries when is_list(entries) -> entries
           _ -> []
         end
-      _ -> []
+
+      _ ->
+        []
     end
   rescue
     _ -> []
@@ -231,10 +238,12 @@ defmodule Mix.Tasks.Compile.Wasm do
   defp format_error({:parse_error, {line, col}, msg, token}) do
     "Parse error at #{line}:#{col}: #{msg}#{token}"
   end
+
   defp format_error({:validation_errors, errors}) do
     Enum.map(errors, fn {func, errs} -> "#{func}: #{Enum.join(errs, ", ")}" end)
     |> Enum.join("; ")
   end
+
   defp format_error({:wat2wasm_error, output}), do: "wat2wasm: #{output}"
   defp format_error({:file_error, reason, path}), do: "Cannot read #{path}: #{reason}"
   defp format_error(other), do: inspect(other)
diff --git a/lib/mix/tasks/firebird.analyze.ex b/lib/mix/tasks/firebird.analyze.ex
index 7d37746..8518b29 100644
--- a/lib/mix/tasks/firebird.analyze.ex
+++ b/lib/mix/tasks/firebird.analyze.ex
@@ -77,13 +77,17 @@ defmodule Mix.Tasks.Firebird.Analyze do
 
     for func <- analysis.functions do
       icon = if func.compilable, do: "✅", else: "❌"
-      rec_info = cond do
-        func.tail_recursive -> " [tail-recursive]"
-        func.recursive -> " [recursive]"
-        true -> ""
-      end
 
-      Mix.shell().info("    #{icon} #{func.name}/#{func.arity} #{func.estimated_complexity}#{rec_info}")
+      rec_info =
+        cond do
+          func.tail_recursive -> " [tail-recursive]"
+          func.recursive -> " [recursive]"
+          true -> ""
+        end
+
+      Mix.shell().info(
+        "    #{icon} #{func.name}/#{func.arity} #{func.estimated_complexity}#{rec_info}"
+      )
 
       for issue <- func.issues do
         Mix.shell().info("       ⚠ #{issue}")
@@ -93,6 +97,7 @@ defmodule Mix.Tasks.Firebird.Analyze do
     if Enum.any?(analysis.suggestions) do
       Mix.shell().info("")
       Mix.shell().info("  💡 Suggestions:")
+
       for sug <- analysis.suggestions do
         Mix.shell().info("    • #{sug}")
       end
diff --git a/lib/mix/tasks/firebird.bench.ex b/lib/mix/tasks/firebird.bench.ex
index 0ff27f1..c101261 100644
--- a/lib/mix/tasks/firebird.bench.ex
+++ b/lib/mix/tasks/firebird.bench.ex
@@ -276,9 +276,17 @@ defmodule Mix.Tasks.Firebird.Bench do
   defp beam_collatz_steps(n), do: 1 + beam_collatz_steps(3 * n + 1)
 
   defp print_results(results) do
-    Mix.shell().info("┌─────────────────────────────────────┬───────────┬───────────┬──────────┬──────────┬──────────┐")
-    Mix.shell().info("│ Benchmark                           │ WASM (μs) │ BEAM (μs) │ Speedup  │ WASM p95 │ BEAM p95 │")
-    Mix.shell().info("├─────────────────────────────────────┼───────────┼───────────┼──────────┼──────────┼──────────┤")
+    Mix.shell().info(
+      "┌─────────────────────────────────────┬───────────┬───────────┬──────────┬──────────┬──────────┐"
+    )
+
+    Mix.shell().info(
+      "│ Benchmark                           │ WASM (μs) │ BEAM (μs) │ Speedup  │ WASM p95 │ BEAM p95 │"
+    )
+
+    Mix.shell().info(
+      "├─────────────────────────────────────┼───────────┼───────────┼──────────┼──────────┼──────────┤"
+    )
 
     for r <- results do
       name = String.pad_trailing(r.name, 37) |> String.slice(0, 37)
@@ -302,7 +310,10 @@ defmodule Mix.Tasks.Firebird.Bench do
       )
     end
 
-    Mix.shell().info("└─────────────────────────────────────┴───────────┴───────────┴──────────┴──────────┴──────────┘")
+    Mix.shell().info(
+      "└─────────────────────────────────────┴───────────┴───────────┴──────────┴──────────┴──────────┘"
+    )
+
     Mix.shell().info("")
     Mix.shell().info("Note: WASM times include Wasmex FFI overhead. Raw WASM execution")
     Mix.shell().info("is typically faster but measured end-to-end from Elixir.")
@@ -326,7 +337,9 @@ defmodule Mix.Tasks.Firebird.Bench do
                 end)
 
               if prev do
-                prev_wasm = get_in(prev, ["wasm", "avg_us"]) || get_in(prev, [:wasm, :avg_us]) || 0
+                prev_wasm =
+                  get_in(prev, ["wasm", "avg_us"]) || get_in(prev, [:wasm, :avg_us]) || 0
+
                 curr_wasm = curr.wasm.avg_us
 
                 if prev_wasm > 0 do
@@ -352,4 +365,3 @@ defmodule Mix.Tasks.Firebird.Bench do
     Mix.shell().info("📊 Results saved to #{path}")
   end
 end
-
diff --git a/lib/mix/tasks/firebird.build.ex b/lib/mix/tasks/firebird.build.ex
index d7af17c..976bb18 100644
--- a/lib/mix/tasks/firebird.build.ex
+++ b/lib/mix/tasks/firebird.build.ex
@@ -24,7 +24,8 @@ defmodule Mix.Tasks.Firebird.Build do
 
   @rust_targets [
     {"fixtures/rust_math", "math", "fixtures/rust_math.wasm", "wasm32-unknown-unknown"},
-    {"fixtures/rust_algorithms", "algorithms", "fixtures/rust_algorithms.wasm", "wasm32-unknown-unknown"},
+    {"fixtures/rust_algorithms", "algorithms", "fixtures/rust_algorithms.wasm",
+     "wasm32-unknown-unknown"},
     {"fixtures/rust_float", "float_math", "fixtures/rust_float.wasm", "wasm32-unknown-unknown"},
     {"fixtures/rust_wasi", "wasi_demo", "fixtures/rust_wasi.wasm", "wasm32-wasip1"}
   ]
@@ -69,14 +70,18 @@ defmodule Mix.Tasks.Firebird.Build do
       Enum.map(@rust_targets, fn {dir, crate_name, output, target} ->
         if File.dir?(dir) do
           Mix.shell().info("   Building #{dir} (#{target})...")
+
           case System.cmd("cargo", ["build", "--target", target, "--release"],
-                 cd: dir, stderr_to_stdout: true) do
+                 cd: dir,
+                 stderr_to_stdout: true
+               ) do
             {_, 0} ->
               src = Path.join([dir, "target/#{target}/release/#{crate_name}.wasm"])
               File.cp!(src, output)
               size = File.stat!(output).size
               Mix.shell().info("   ✅ #{output} (#{size} bytes)")
               {:ok, output}
+
             {err, _} ->
               Mix.shell().error("   ❌ Failed to build #{dir}: #{err}")
               {:error, dir}
@@ -99,12 +104,18 @@ defmodule Mix.Tasks.Firebird.Build do
         if File.dir?(dir) do
           Mix.shell().info("   Building #{dir}...")
           abs_output = Path.absname(output)
-          case System.cmd("tinygo", ["build", "-o", abs_output, "-target", "wasi", "-no-debug", "main.go"],
-                 cd: dir, stderr_to_stdout: true) do
+
+          case System.cmd(
+                 "tinygo",
+                 ["build", "-o", abs_output, "-target", "wasi", "-no-debug", "main.go"],
+                 cd: dir,
+                 stderr_to_stdout: true
+               ) do
             {_, 0} ->
               size = File.stat!(output).size
               Mix.shell().info("   ✅ #{output} (#{size} bytes)")
               {:ok, output}
+
             {err, _} ->
               Mix.shell().error("   ❌ Failed to build #{dir}: #{err}")
               {:error, dir}
@@ -126,11 +137,13 @@ defmodule Mix.Tasks.Firebird.Build do
       Enum.map(@wat_targets, fn {source, output} ->
         if File.exists?(source) do
           Mix.shell().info("   Building #{source}...")
+
           case System.cmd("wat2wasm", [source, "-o", output], stderr_to_stdout: true) do
             {_, 0} ->
               size = File.stat!(output).size
               Mix.shell().info("   ✅ #{output} (#{size} bytes)")
               {:ok, output}
+
             {err, _} ->
               Mix.shell().error("   ❌ Failed: #{err}")
               {:error, source}
diff --git a/lib/mix/tasks/firebird.compile.ex b/lib/mix/tasks/firebird.compile.ex
index 5fa1a2e..ed8c481 100644
--- a/lib/mix/tasks/firebird.compile.ex
+++ b/lib/mix/tasks/firebird.compile.ex
@@ -127,9 +127,10 @@ defmodule Mix.Tasks.Firebird.Compile do
     File.mkdir_p!(output_dir)
 
     # Compile each file
-    results = Enum.map(files, fn file ->
-      compile_file(file, output_dir, wat_only, verbose, verify)
-    end)
+    results =
+      Enum.map(files, fn file ->
+        compile_file(file, output_dir, wat_only, verbose, verify)
+      end)
 
     # Summary
     successes = Enum.count(results, fn {status, _} -> status == :ok end)
@@ -192,7 +193,7 @@ defmodule Mix.Tasks.Firebird.Compile do
     end
   end
 
-  defp verify_wasm(wasm_binary, module_name) do
+  defp verify_wasm(wasm_binary, _module_name) do
     case Firebird.load(wasm_binary) do
       {:ok, instance} ->
         exports = Firebird.exports(instance)
@@ -209,9 +210,11 @@ defmodule Mix.Tasks.Firebird.Compile do
   end
 
   defp format_error({:validation_errors, errors}) do
-    details = Enum.map(errors, fn {func, errs} ->
-      "  #{func}: #{Enum.join(errs, ", ")}"
-    end)
+    details =
+      Enum.map(errors, fn {func, errs} ->
+        "  #{func}: #{Enum.join(errs, ", ")}"
+      end)
+
     "Validation errors:\n#{Enum.join(details, "\n")}"
   end
 
diff --git a/lib/mix/tasks/firebird.doctor.ex b/lib/mix/tasks/firebird.doctor.ex
index 4453825..9361336 100644
--- a/lib/mix/tasks/firebird.doctor.ex
+++ b/lib/mix/tasks/firebird.doctor.ex
@@ -38,23 +38,27 @@ defmodule Mix.Tasks.Firebird.Doctor do
       {"priv/wasm directory", &check_priv_wasm/0}
     ]
 
-    results = Enum.map(checks, fn {name, check_fn} ->
-      result = check_fn.()
-      status = case result do
-        :ok -> "✅"
-        {:warn, _} -> "⚠️ "
-        {:error, _} -> "❌"
-      end
-
-      message = case result do
-        :ok -> ""
-        {:warn, msg} -> " — #{msg}"
-        {:error, msg} -> " — #{msg}"
-      end
-
-      Mix.shell().info("  #{status} #{name}#{message}")
-      result
-    end)
+    results =
+      Enum.map(checks, fn {name, check_fn} ->
+        result = check_fn.()
+
+        status =
+          case result do
+            :ok -> "✅"
+            {:warn, _} -> "⚠️ "
+            {:error, _} -> "❌"
+          end
+
+        message =
+          case result do
+            :ok -> ""
+            {:warn, msg} -> " — #{msg}"
+            {:error, msg} -> " — #{msg}"
+          end
+
+        Mix.shell().info("  #{status} #{name}#{message}")
+        result
+      end)
 
     errors = Enum.count(results, fn r -> match?({:error, _}, r) end)
     warnings = Enum.count(results, fn r -> match?({:warn, _}, r) end)
@@ -64,7 +68,10 @@ defmodule Mix.Tasks.Firebird.Doctor do
 
     cond do
       errors > 0 ->
-        Mix.shell().info("❌ #{errors} issue(s) found. Fix the errors above to get Firebird working.")
+        Mix.shell().info(
+          "❌ #{errors} issue(s) found. Fix the errors above to get Firebird working."
+        )
+
         Mix.shell().info("")
         Mix.shell().info("Common fixes:")
         Mix.shell().info("  • mix deps.get")
@@ -72,7 +79,9 @@ defmodule Mix.Tasks.Firebird.Doctor do
         Mix.shell().info("  • mix firebird.init")
 
       warnings > 0 ->
-        Mix.shell().info("⚠️  #{ok} checks passed, #{warnings} warning(s). Firebird is functional but some features may be limited.")
+        Mix.shell().info(
+          "⚠️  #{ok} checks passed, #{warnings} warning(s). Firebird is functional but some features may be limited."
+        )
 
       true ->
         Mix.shell().info("✅ All #{ok} checks passed! Firebird is ready to use.")
@@ -128,21 +137,31 @@ defmodule Mix.Tasks.Firebird.Doctor do
   defp check_wat2wasm do
     case System.find_executable("wat2wasm") do
       nil ->
-        {:warn, "Not installed. Install wabt for WAT support: brew install wabt (macOS) or apt install wabt (Ubuntu)"}
+        {:warn,
+         "Not installed. Install wabt for WAT support: brew install wabt (macOS) or apt install wabt (Ubuntu)"}
 
       path ->
         case System.cmd(path, ["--version"], stderr_to_stdout: true) do
-          {version, 0} -> Mix.shell().info("       (#{String.trim(version)})"); :ok
-          _ -> :ok
+          {version, 0} ->
+            Mix.shell().info("       (#{String.trim(version)})")
+            :ok
+
+          _ ->
+            :ok
         end
     end
   end
 
   defp check_priv_wasm do
     cond do
-      File.dir?("priv/wasm") -> :ok
-      File.dir?("wasm") -> {:warn, "Using wasm/ instead of priv/wasm/ (OK for dev, use priv/ for releases)"}
-      true -> {:warn, "No wasm directory found. Create priv/wasm/ or run: mix firebird.init"}
+      File.dir?("priv/wasm") ->
+        :ok
+
+      File.dir?("wasm") ->
+        {:warn, "Using wasm/ instead of priv/wasm/ (OK for dev, use priv/ for releases)"}
+
+      true ->
+        {:warn, "No wasm directory found. Create priv/wasm/ or run: mix firebird.init"}
     end
   end
 end
diff --git a/lib/mix/tasks/firebird.gen.ex b/lib/mix/tasks/firebird.gen.ex
index 1bc5657..b681913 100644
--- a/lib/mix/tasks/firebird.gen.ex
+++ b/lib/mix/tasks/firebird.gen.ex
@@ -50,7 +50,9 @@ defmodule Mix.Tasks.Firebird.Gen do
       end
 
     unless File.exists?(wasm_path) do
-      Mix.raise("WASM file not found: #{wasm_path}\n\nMake sure the file exists and the path is correct.")
+      Mix.raise(
+        "WASM file not found: #{wasm_path}\n\nMake sure the file exists and the path is correct."
+      )
     end
 
     # Start the application so we can use Wasmex
@@ -103,7 +105,9 @@ defmodule Mix.Tasks.Firebird.Gen do
 
   defp write_module(path, code, force) do
     if File.exists?(path) && !force do
-      Mix.raise("File already exists: #{path}\n\nUse --force to overwrite, or --out to specify a different path.")
+      Mix.raise(
+        "File already exists: #{path}\n\nUse --force to overwrite, or --out to specify a different path."
+      )
     end
 
     File.mkdir_p!(Path.dirname(path))
@@ -118,7 +122,9 @@ defmodule Mix.Tasks.Firebird.Gen do
     fn_lines =
       public_fns
       |> Enum.map(fn f ->
-        param_doc = if f.params == [], do: "", else: " (#{Enum.join(Enum.map(f.params, &inspect/1), ", ")})"
+        param_doc =
+          if f.params == [], do: "", else: " (#{Enum.join(Enum.map(f.params, &inspect/1), ", ")})"
+
         doc_line = "  @doc \"Call `#{f.name}`#{param_doc} → #{inspect(f.results)}\""
         "#{doc_line}\n  wasm_fn :#{f.name}, args: #{f.arity}"
       end)
@@ -151,14 +157,19 @@ defmodule Mix.Tasks.Firebird.Gen do
   defp generate_code(module_name, wasm_path, info, :pool, wasi) do
     public_fns = Enum.reject(info.functions, &String.starts_with?(&1.name, "_"))
 
-    pool_name = module_name |> String.split(".") |> List.last() |> Macro.underscore() |> String.to_atom()
+    pool_name =
+      module_name |> String.split(".") |> List.last() |> Macro.underscore() |> String.to_atom()
+
     wasi_opt = if wasi, do: ", wasi: true", else: ""
 
     fn_lines =
       public_fns
       |> Enum.map(fn f ->
         args = Enum.map_join(1..max(f.arity, 1), ", ", fn i -> "arg#{i}" end)
-        arg_vars = if f.arity > 0, do: Enum.map_join(1..f.arity, ", ", fn i -> "arg#{i}" end), else: ""
+
+        arg_vars =
+          if f.arity > 0, do: Enum.map_join(1..f.arity, ", ", fn i -> "arg#{i}" end), else: ""
+
         arg_list = if f.arity > 0, do: "[#{arg_vars}]", else: "[]"
 
         """
@@ -225,7 +236,9 @@ defmodule Mix.Tasks.Firebird.Gen do
     fn_lines =
       public_fns
       |> Enum.map(fn f ->
-        args = if f.arity > 0, do: Enum.map_join(1..f.arity, ", ", fn i -> "arg#{i}" end), else: ""
+        args =
+          if f.arity > 0, do: Enum.map_join(1..f.arity, ", ", fn i -> "arg#{i}" end), else: ""
+
         arg_list = if f.arity > 0, do: "[#{args}]", else: "[]"
 
         """
@@ -280,6 +293,7 @@ defmodule Mix.Tasks.Firebird.Gen do
       |> Enum.take(5)
       |> Enum.map(fn f ->
         zeros = List.duplicate(0, f.arity)
+
         """
           test "#{f.name} is callable", %{wasm: wasm} do
             assert {:ok, result} = Firebird.call(wasm, :#{f.name}, #{inspect(zeros)})
diff --git a/lib/mix/tasks/firebird.init.ex b/lib/mix/tasks/firebird.init.ex
index 1a279e8..bcc7a4d 100644
--- a/lib/mix/tasks/firebird.init.ex
+++ b/lib/mix/tasks/firebird.init.ex
@@ -29,10 +29,11 @@ defmodule Mix.Tasks.Firebird.Init do
 
   @impl Mix.Task
   def run(args) do
-    {opts, _, _} = OptionParser.parse(args,
-      switches: [example: :string, force: :boolean, rust: :boolean, phoenix: :boolean],
-      aliases: [e: :example, f: :force, r: :rust, p: :phoenix]
-    )
+    {opts, _, _} =
+      OptionParser.parse(args,
+        switches: [example: :string, force: :boolean, rust: :boolean, phoenix: :boolean],
+        aliases: [e: :example, f: :force, r: :rust, p: :phoenix]
+      )
 
     Mix.shell().info("🔥 Initializing Firebird WASM integration...")
 
@@ -300,6 +301,7 @@ defmodule Mix.Tasks.Firebird.Init do
       Mix.shell().info("  #{test_path} already exists, skipping")
     else
       File.mkdir_p!("test")
+
       content = ~S'''
       defmodule WasmTest do
         use ExUnit.Case
diff --git a/lib/mix/tasks/firebird.inspect.ex b/lib/mix/tasks/firebird.inspect.ex
index fbdd0bf..75ea0e6 100644
--- a/lib/mix/tasks/firebird.inspect.ex
+++ b/lib/mix/tasks/firebird.inspect.ex
@@ -39,10 +39,12 @@ defmodule Mix.Tasks.Firebird.Inspect do
         case Firebird.Inspector.inspect_file(path, wasi: wasi) do
           {:ok, info} ->
             if gen_name = Keyword.get(opts, :generate) do
-              style = case Keyword.get(opts, :style, "module") do
-                "wasm_module" -> :wasm_module
-                _ -> :module
-              end
+              style =
+                case Keyword.get(opts, :style, "module") do
+                  "wasm_module" -> :wasm_module
+                  _ -> :module
+                end
+
               code = Firebird.Inspector.generate_module(gen_name, path, wasi: wasi, style: style)
               Mix.shell().info(code)
             else
@@ -66,6 +68,7 @@ defmodule Mix.Tasks.Firebird.Inspect do
 
     if length(info.functions) > 0 do
       Mix.shell().info("   Functions:")
+
       for f <- info.functions do
         params = Enum.join(Enum.map(f.params, &to_string/1), ", ")
         results = Enum.join(Enum.map(f.results, &to_string/1), ", ")
@@ -77,6 +80,7 @@ defmodule Mix.Tasks.Firebird.Inspect do
     if length(info.memories) > 0 do
       Mix.shell().info("")
       Mix.shell().info("   Memories:")
+
       for m <- info.memories do
         Mix.shell().info("     #{m.name}: #{m.min_pages} pages (#{m.min_pages * 64}KB)")
       end
@@ -85,6 +89,7 @@ defmodule Mix.Tasks.Firebird.Inspect do
     if length(info.globals) > 0 do
       Mix.shell().info("")
       Mix.shell().info("   Globals:")
+
       for g <- info.globals do
         Mix.shell().info("     #{g.name}: #{g.type} (#{g.mutability})")
       end
diff --git a/lib/mix/tasks/firebird.phoenix.ex b/lib/mix/tasks/firebird.phoenix.ex
index 67c9b70..3235bc4 100644
--- a/lib/mix/tasks/firebird.phoenix.ex
+++ b/lib/mix/tasks/firebird.phoenix.ex
@@ -37,9 +37,15 @@ defmodule Mix.Tasks.Firebird.Phoenix do
   @impl Mix.Task
   def run(args) do
     case args do
-      ["build" | _] -> build()
-      ["bench" | _] -> bench()
-      ["info" | _] -> info()
+      ["build" | _] ->
+        build()
+
+      ["bench" | _] ->
+        bench()
+
+      ["info" | _] ->
+        info()
+
       _ ->
         Mix.shell().info("""
         Usage: mix firebird.phoenix <command>
@@ -57,39 +63,50 @@ defmodule Mix.Tasks.Firebird.Phoenix do
 
     fixtures_dir = Path.join(File.cwd!(), "fixtures")
 
-    results = Enum.map(@phoenix_modules, fn module ->
-      src_dir = Path.join(fixtures_dir, module)
-      wasm_output = Path.join(fixtures_dir, "#{module}.wasm")
-
-      if File.dir?(src_dir) do
-        Mix.shell().info("  📦 Building #{module}...")
-        {output, code} = System.cmd("cargo", [
-          "build",
-          "--target", "wasm32-unknown-unknown",
-          "--release"
-        ], cd: src_dir, stderr_to_stdout: true)
-
-        if code == 0 do
-          # Copy the built WASM to fixtures root
-          built_wasm = Path.join([src_dir, "target", "wasm32-unknown-unknown", "release", "#{module}.wasm"])
-          if File.exists?(built_wasm) do
-            File.cp!(built_wasm, wasm_output)
-            size = File.stat!(wasm_output).size
-            Mix.shell().info("     ✅ #{module}.wasm (#{format_bytes(size)})")
-            {:ok, module}
+    results =
+      Enum.map(@phoenix_modules, fn module ->
+        src_dir = Path.join(fixtures_dir, module)
+        wasm_output = Path.join(fixtures_dir, "#{module}.wasm")
+
+        if File.dir?(src_dir) do
+          Mix.shell().info("  📦 Building #{module}...")
+
+          {output, code} =
+            System.cmd(
+              "cargo",
+              [
+                "build",
+                "--target",
+                "wasm32-unknown-unknown",
+                "--release"
+              ],
+              cd: src_dir,
+              stderr_to_stdout: true
+            )
+
+          if code == 0 do
+            # Copy the built WASM to fixtures root
+            built_wasm =
+              Path.join([src_dir, "target", "wasm32-unknown-unknown", "release", "#{module}.wasm"])
+
+            if File.exists?(built_wasm) do
+              File.cp!(built_wasm, wasm_output)
+              size = File.stat!(wasm_output).size
+              Mix.shell().info("     ✅ #{module}.wasm (#{format_bytes(size)})")
+              {:ok, module}
+            else
+              Mix.shell().info("     ❌ WASM file not found after build")
+              {:error, module}
+            end
           else
-            Mix.shell().info("     ❌ WASM file not found after build")
+            Mix.shell().info("     ❌ Build failed: #{String.slice(output, 0..200)}")
             {:error, module}
           end
         else
-          Mix.shell().info("     ❌ Build failed: #{String.slice(output, 0..200)}")
-          {:error, module}
+          Mix.shell().info("  ⏭️  #{module} - no source directory")
+          {:skip, module}
         end
-      else
-        Mix.shell().info("  ⏭️  #{module} - no source directory")
-        {:skip, module}
-      end
-    end)
+      end)
 
     ok = Enum.count(results, &(elem(&1, 0) == :ok))
     fail = Enum.count(results, &(elem(&1, 0) == :error))
@@ -135,6 +152,7 @@ defmodule Mix.Tasks.Firebird.Phoenix do
             exports = Firebird.exports(instance)
             Mix.shell().info("     Exports: #{inspect(exports)}")
             Firebird.stop(instance)
+
           {:error, reason} ->
             Mix.shell().info("     Error loading: #{inspect(reason)}")
         end
diff --git a/lib/mix/tasks/firebird.phoenix.gen.ex b/lib/mix/tasks/firebird.phoenix.gen.ex
index c1f7ae1..665461a 100644
--- a/lib/mix/tasks/firebird.phoenix.gen.ex
+++ b/lib/mix/tasks/firebird.phoenix.gen.ex
@@ -35,15 +35,19 @@ defmodule Mix.Tasks.Firebird.Phoenix.Gen do
 
   @impl Mix.Task
   def run(args) do
-    {opts, positional, _} = OptionParser.parse(args,
-      strict: [module: :string, path: :string]
-    )
+    {opts, positional, _} =
+      OptionParser.parse(args,
+        strict: [module: :string, path: :string]
+      )
 
     case positional do
       [app_name | _] ->
         generate(app_name, opts)
+
       [] ->
-        Mix.shell().error("Usage: mix firebird.phoenix.gen APP_NAME [--module MODULE] [--path PATH]")
+        Mix.shell().error(
+          "Usage: mix firebird.phoenix.gen APP_NAME [--module MODULE] [--path PATH]"
+        )
     end
   end
 
diff --git a/lib/mix/tasks/firebird.target.bench.ex b/lib/mix/tasks/firebird.target.bench.ex
index c51cf24..bcd6e62 100644
--- a/lib/mix/tasks/firebird.target.bench.ex
+++ b/lib/mix/tasks/firebird.target.bench.ex
@@ -111,15 +111,16 @@ defmodule Mix.Tasks.Firebird.Target.Bench do
   end
 
   defp run_standard_mode(opts, iterations, warmup, filter) do
-    results = Firebird.Target.Benchmark.run_suite(
-      iterations: iterations,
-      warmup: warmup,
-      filter: filter,
-      optimize: Keyword.get(opts, :optimize, true),
-      tco: Keyword.get(opts, :tco, true),
-      inline: Keyword.get(opts, :inline, true),
-      licm: Keyword.get(opts, :licm, true)
-    )
+    results =
+      Firebird.Target.Benchmark.run_suite(
+        iterations: iterations,
+        warmup: warmup,
+        filter: filter,
+        optimize: Keyword.get(opts, :optimize, true),
+        tco: Keyword.get(opts, :tco, true),
+        inline: Keyword.get(opts, :inline, true),
+        licm: Keyword.get(opts, :licm, true)
+      )
 
     cond do
       Keyword.get(opts, :json, false) ->
@@ -141,11 +142,12 @@ defmodule Mix.Tasks.Firebird.Target.Bench do
   end
 
   defp run_comparison_mode(opts, iterations, warmup, filter) do
-    results = Firebird.Target.Benchmark.run_comparison_suite(
-      iterations: iterations,
-      warmup: warmup,
-      filter: filter
-    )
+    results =
+      Firebird.Target.Benchmark.run_comparison_suite(
+        iterations: iterations,
+        warmup: warmup,
+        filter: filter
+      )
 
     cond do
       Keyword.get(opts, :markdown, false) ->
@@ -167,8 +169,15 @@ defmodule Mix.Tasks.Firebird.Target.Bench do
     Enum.each(results, fn r ->
       Mix.shell().info("")
       Mix.shell().info("  #{r.name}:")
-      Mix.shell().info("    WASM: avg=#{Float.round(r.wasm.avg, 1)}μs min=#{r.wasm.min}μs max=#{r.wasm.max}μs p95=#{Float.round(r.wasm.p95, 1)}μs")
-      Mix.shell().info("    BEAM: avg=#{Float.round(r.beam.avg, 1)}μs min=#{r.beam.min}μs max=#{r.beam.max}μs p95=#{Float.round(r.beam.p95, 1)}μs")
+
+      Mix.shell().info(
+        "    WASM: avg=#{Float.round(r.wasm.avg, 1)}μs min=#{r.wasm.min}μs max=#{r.wasm.max}μs p95=#{Float.round(r.wasm.p95, 1)}μs"
+      )
+
+      Mix.shell().info(
+        "    BEAM: avg=#{Float.round(r.beam.avg, 1)}μs min=#{r.beam.min}μs max=#{r.beam.max}μs p95=#{Float.round(r.beam.p95, 1)}μs"
+      )
+
       Mix.shell().info("    Speedup: #{r.speedup}x, Correct: #{r.correct}")
       Mix.shell().info("    WASM binary: #{Map.get(r, :wasm_size, 0)} bytes")
       Mix.shell().info("    Optimizations: #{Map.get(r, :optimizations, []) |> Enum.join(", ")}")
@@ -182,12 +191,25 @@ defmodule Mix.Tasks.Firebird.Target.Bench do
     Enum.each(results, fn r ->
       Mix.shell().info("")
       Mix.shell().info("  #{r.name}:")
-      Mix.shell().info("    Raw WASM:  avg=#{Float.round(r.unoptimized.avg, 1)}μs p95=#{Float.round(r.unoptimized.p95, 1)}μs")
-      Mix.shell().info("    Opt WASM:  avg=#{Float.round(r.optimized.avg, 1)}μs p95=#{Float.round(r.optimized.p95, 1)}μs")
-      Mix.shell().info("    BEAM:      avg=#{Float.round(r.beam.avg, 1)}μs p95=#{Float.round(r.beam.p95, 1)}μs")
+
+      Mix.shell().info(
+        "    Raw WASM:  avg=#{Float.round(r.unoptimized.avg, 1)}μs p95=#{Float.round(r.unoptimized.p95, 1)}μs"
+      )
+
+      Mix.shell().info(
+        "    Opt WASM:  avg=#{Float.round(r.optimized.avg, 1)}μs p95=#{Float.round(r.optimized.p95, 1)}μs"
+      )
+
+      Mix.shell().info(
+        "    BEAM:      avg=#{Float.round(r.beam.avg, 1)}μs p95=#{Float.round(r.beam.p95, 1)}μs"
+      )
+
       Mix.shell().info("    Opt gain:  #{r.opt_vs_raw}x faster than raw WASM")
       Mix.shell().info("    vs BEAM:   #{r.opt_vs_beam}x")
-      Mix.shell().info("    Size:      #{r.unopt_wasm_size}B → #{r.opt_wasm_size}B (#{r.size_reduction}B saved)")
+
+      Mix.shell().info(
+        "    Size:      #{r.unopt_wasm_size}B → #{r.opt_wasm_size}B (#{r.size_reduction}B saved)"
+      )
     end)
   end
 end
diff --git a/lib/mix/tasks/firebird.target.check.ex b/lib/mix/tasks/firebird.target.check.ex
index 7ae9e60..024166e 100644
--- a/lib/mix/tasks/firebird.target.check.ex
+++ b/lib/mix/tasks/firebird.target.check.ex
@@ -54,6 +54,7 @@ defmodule Mix.Tasks.Firebird.Target.Check do
         Mix.shell().info("🔍 No files to check.")
         Mix.shell().info("   Add @wasm true annotations or specify files.")
       end
+
       :ok
     else
       {:ok, reports} = Firebird.Target.Diagnostics.analyze_files(files)
@@ -112,6 +113,7 @@ defmodule Mix.Tasks.Firebird.Target.Check do
         {:ok, content} ->
           String.contains?(content, "@wasm true") or
             String.contains?(path, "wasm_modules")
+
         _ ->
           false
       end
@@ -122,18 +124,20 @@ defmodule Mix.Tasks.Firebird.Target.Check do
     data = %{
       total: length(reports),
       compilable: Enum.count(reports, & &1.compilable),
-      files: Enum.map(reports, fn r ->
-        %{
-          file: r.file,
-          module: if(r.module, do: to_string(r.module)),
-          compilable: r.compilable,
-          function_count: r.function_count,
-          estimated_wasm_size: r.estimated_wasm_size,
-          diagnostics: Enum.map(r.diagnostics, fn d ->
-            %{severity: d.severity, message: d.message, line: d.line}
-          end)
-        }
-      end)
+      files:
+        Enum.map(reports, fn r ->
+          %{
+            file: r.file,
+            module: if(r.module, do: to_string(r.module)),
+            compilable: r.compilable,
+            function_count: r.function_count,
+            estimated_wasm_size: r.estimated_wasm_size,
+            diagnostics:
+              Enum.map(r.diagnostics, fn d ->
+                %{severity: d.severity, message: d.message, line: d.line}
+              end)
+          }
+        end)
     }
 
     Mix.shell().info(Jason.encode!(data, pretty: true))
@@ -185,6 +189,8 @@ defmodule Mix.Tasks.Firebird.Target.Check do
     total = length(reports)
     total_funcs = Enum.map(reports, & &1.function_count) |> Enum.sum()
 
-    Mix.shell().info("📊 Summary: #{compilable}/#{total} files compilable, #{total_funcs} total functions")
+    Mix.shell().info(
+      "📊 Summary: #{compilable}/#{total} files compilable, #{total_funcs} total functions"
+    )
   end
 end
diff --git a/lib/mix/tasks/firebird.target.clean.ex b/lib/mix/tasks/firebird.target.clean.ex
index 6fe5fa3..27fc1ce 100644
--- a/lib/mix/tasks/firebird.target.clean.ex
+++ b/lib/mix/tasks/firebird.target.clean.ex
@@ -77,17 +77,24 @@ defmodule Mix.Tasks.Firebird.Target.Clean do
       else
         Mix.shell().info("🧹 Firebird WASM Clean")
       end
+
       Mix.shell().info("")
     end
 
     if remove_all do
       clean_entire_directory(output_dir, dry_run, quiet)
     else
-      files_removed = clean_artifacts(output_dir, %{
-        wat: clean_all_types or wat_only,
-        wasm: clean_all_types or wasm_only,
-        manifests: clean_all_types or manifests_only
-      }, dry_run, quiet)
+      files_removed =
+        clean_artifacts(
+          output_dir,
+          %{
+            wat: clean_all_types or wat_only,
+            wasm: clean_all_types or wasm_only,
+            manifests: clean_all_types or manifests_only
+          },
+          dry_run,
+          quiet
+        )
 
       # Also clean the Mix compiler manifest
       if clean_all_types or manifests_only do
@@ -119,6 +126,7 @@ defmodule Mix.Tasks.Firebird.Target.Clean do
       unless quiet do
         Mix.shell().info("   #{output_dir}/ does not exist — nothing to clean")
       end
+
       0
     else
       patterns = build_patterns(output_dir, types)
diff --git a/lib/mix/tasks/firebird.target.compile.ex b/lib/mix/tasks/firebird.target.compile.ex
index 6e2291c..bdad4e0 100644
--- a/lib/mix/tasks/firebird.target.compile.ex
+++ b/lib/mix/tasks/firebird.target.compile.ex
@@ -129,6 +129,7 @@ defmodule Mix.Tasks.Firebird.Target.Compile do
         Mix.shell().info("   No compilable sources found.")
         Mix.shell().info("   Add @wasm true annotations to your modules.")
       end
+
       :ok
     else
       # Build compiler opts fingerprint for content-hash staleness detection
@@ -151,8 +152,11 @@ defmodule Mix.Tasks.Firebird.Target.Compile do
 
       if Enum.empty?(sources_to_compile) do
         unless quiet do
-          Mix.shell().info("   All #{length(sources)} file(s) up to date. Use --force to recompile.")
+          Mix.shell().info(
+            "   All #{length(sources)} file(s) up to date. Use --force to recompile."
+          )
         end
+
         :ok
       else
         # Run diagnostics pre-flight if requested
@@ -220,7 +224,17 @@ defmodule Mix.Tasks.Firebird.Target.Compile do
 
     overrides =
       opts
-      |> Keyword.take([:optimize, :tco, :inline, :cse, :licm, :wat_only, :verify, :verbose, :force])
+      |> Keyword.take([
+        :optimize,
+        :tco,
+        :inline,
+        :cse,
+        :licm,
+        :wat_only,
+        :verify,
+        :verbose,
+        :force
+      ])
       |> Keyword.merge(
         case Keyword.get(opts, :output) do
           nil -> []
@@ -250,17 +264,18 @@ defmodule Mix.Tasks.Firebird.Target.Compile do
   def validate_environment(config) do
     cond do
       not config.wat_only and not Firebird.Compiler.wat2wasm_available?() ->
-        {:error, """
-        wat2wasm not found! Install the WebAssembly Binary Toolkit (wabt):
+        {:error,
+         """
+         wat2wasm not found! Install the WebAssembly Binary Toolkit (wabt):
 
-          # macOS
-          brew install wabt
+           # macOS
+           brew install wabt
 
-          # Ubuntu/Debian
-          apt-get install wabt
+           # Ubuntu/Debian
+           apt-get install wabt
 
-          # Or use --wat-only to generate WAT text only
-        """}
+           # Or use --wat-only to generate WAT text only
+         """}
 
       true ->
         :ok
@@ -397,6 +412,7 @@ defmodule Mix.Tasks.Firebird.Target.Compile do
         {:ok, code} ->
           diagnostics = analyze_for_diagnostics(code, source)
           print_diagnostics(source, diagnostics)
+
         {:error, _} ->
           Mix.shell().error("   ❌ Cannot read #{source}")
       end
@@ -436,7 +452,9 @@ defmodule Mix.Tasks.Firebird.Target.Compile do
 
               if config.verbose do
                 Mix.shell().info("        WAT: #{byte_size(result.wat)} bytes")
-                if result.wasm, do: Mix.shell().info("        WASM: #{byte_size(result.wasm)} bytes")
+
+                if result.wasm,
+                  do: Mix.shell().info("        WASM: #{byte_size(result.wasm)} bytes")
               end
             end
 
@@ -450,6 +468,7 @@ defmodule Mix.Tasks.Firebird.Target.Compile do
             unless quiet do
               Mix.shell().error("     ❌ #{format_error(reason)}")
             end
+
             {:error, {source, reason}}
         end
       end)
@@ -503,10 +522,13 @@ defmodule Mix.Tasks.Firebird.Target.Compile do
     case Firebird.load(result.wasm) do
       {:ok, instance} ->
         exports = Firebird.exports(instance)
+
         unless quiet do
           Mix.shell().info("        🔍 Verified: #{length(exports)} export(s)")
         end
+
         Firebird.stop(instance)
+
       {:error, reason} ->
         unless quiet do
           Mix.shell().error("        ⚠ Verification failed: #{inspect(reason)}")
@@ -541,9 +563,11 @@ defmodule Mix.Tasks.Firebird.Target.Compile do
       |> Enum.sum()
 
     Mix.shell().info("   📏 Total WAT: #{format_bytes(total_wat)}")
+
     if total_wasm > 0 do
       Mix.shell().info("   📦 Total WASM: #{format_bytes(total_wasm)}")
     end
+
     Mix.shell().info("   ⏱  Time: #{elapsed}ms")
     Mix.shell().info("")
 
@@ -560,17 +584,19 @@ defmodule Mix.Tasks.Firebird.Target.Compile do
       elapsed_ms: elapsed,
       compiled: length(successes),
       failed: length(failures),
-      modules: Enum.map(successes, fn {:ok, r} ->
-        %{
-          module: to_string(r.module),
-          wat_size: byte_size(r.wat),
-          wasm_size: if(r.wasm, do: byte_size(r.wasm), else: nil),
-          source: Map.get(r, :source_file)
-        }
-      end),
-      errors: Enum.map(failures, fn {:error, {source, reason}} ->
-        %{source: source, error: inspect(reason)}
-      end)
+      modules:
+        Enum.map(successes, fn {:ok, r} ->
+          %{
+            module: to_string(r.module),
+            wat_size: byte_size(r.wat),
+            wasm_size: if(r.wasm, do: byte_size(r.wasm), else: nil),
+            source: Map.get(r, :source_file)
+          }
+        end),
+      errors:
+        Enum.map(failures, fn {:error, {source, reason}} ->
+          %{source: source, error: inspect(reason)}
+        end)
     }
 
     Mix.shell().info(Jason.encode!(data, pretty: true))
@@ -588,17 +614,19 @@ defmodule Mix.Tasks.Firebird.Target.Compile do
         inline: config.inline,
         wat_only: config.wat_only
       },
-      modules: Enum.map(successes, fn {:ok, r} ->
-        base = Atom.to_string(r.module) |> String.replace(".", "_")
-        %{
-          module: to_string(r.module),
-          wat_file: "#{base}.wat",
-          wasm_file: if(r.wasm, do: "#{base}.wasm"),
-          wat_size: byte_size(r.wat),
-          wasm_size: if(r.wasm, do: byte_size(r.wasm), else: 0),
-          source: Map.get(r, :source_file)
-        }
-      end)
+      modules:
+        Enum.map(successes, fn {:ok, r} ->
+          base = Atom.to_string(r.module) |> String.replace(".", "_")
+
+          %{
+            module: to_string(r.module),
+            wat_file: "#{base}.wat",
+            wasm_file: if(r.wasm, do: "#{base}.wasm"),
+            wat_size: byte_size(r.wat),
+            wasm_size: if(r.wasm, do: byte_size(r.wasm), else: 0),
+            source: Map.get(r, :source_file)
+          }
+        end)
     }
 
     manifest_path = Path.join(config.output_dir, "firebird_manifest.json")
@@ -618,7 +646,10 @@ defmodule Mix.Tasks.Firebird.Target.Compile do
     # Check for unsupported features
     diagnostics =
       if String.contains?(code, "spawn") or String.contains?(code, "send") do
-        update_in(diagnostics.warnings, &["Process operations (spawn/send) not supported in WASM" | &1])
+        update_in(
+          diagnostics.warnings,
+          &["Process operations (spawn/send) not supported in WASM" | &1]
+        )
       else
         diagnostics
       end
@@ -639,7 +670,10 @@ defmodule Mix.Tasks.Firebird.Target.Compile do
 
     diagnostics =
       if Regex.match?(~r/\[.*\|.*\]/, code) or String.contains?(code, "Enum.") do
-        update_in(diagnostics.warnings, &["List operations not supported - only numeric types available" | &1])
+        update_in(
+          diagnostics.warnings,
+          &["List operations not supported - only numeric types available" | &1]
+        )
       else
         diagnostics
       end
@@ -673,7 +707,10 @@ defmodule Mix.Tasks.Firebird.Target.Compile do
       if func_count > 0 do
         update_in(diagnostics.info, &["#{func_count} @wasm annotated function(s)" | &1])
       else
-        update_in(diagnostics.info, &["No @wasm annotations - all public functions will be compiled" | &1])
+        update_in(
+          diagnostics.info,
+          &["No @wasm annotations - all public functions will be compiled" | &1]
+        )
       end
 
     diagnostics
@@ -698,6 +735,7 @@ defmodule Mix.Tasks.Firebird.Target.Compile do
     case File.stat(path) do
       {:ok, %{mtime: mtime}} ->
         :calendar.datetime_to_gregorian_seconds(mtime)
+
       _ ->
         0
     end
@@ -710,10 +748,12 @@ defmodule Mix.Tasks.Firebird.Target.Compile do
   defp format_error({:parse_error, {line, col}, msg, token}) do
     "Parse error at #{line}:#{col}: #{msg}#{token}"
   end
+
   defp format_error({:validation_errors, errors}) do
     details = Enum.map(errors, fn {func, errs} -> "  #{func}: #{Enum.join(errs, ", ")}" end)
     "Validation errors:\n#{Enum.join(details, "\n")}"
   end
+
   defp format_error({:wat2wasm_error, output}), do: "wat2wasm: #{output}"
   defp format_error({:file_error, reason, path}), do: "Cannot read #{path}: #{reason}"
   defp format_error(other), do: inspect(other)
diff --git a/lib/mix/tasks/firebird.target.ex b/lib/mix/tasks/firebird.target.ex
index b66513f..8d96be6 100644
--- a/lib/mix/tasks/firebird.target.ex
+++ b/lib/mix/tasks/firebird.target.ex
@@ -197,79 +197,89 @@ defmodule Mix.Tasks.Firebird.Target do
       if dry_run do
         run_dry_run(sources)
       else
-      # Filter to only stale sources unless --force
-      sources_to_compile =
-        if force do
-          sources
-        else
-          filter_stale(sources, output_dir)
-        end
+        # Filter to only stale sources unless --force
+        sources_to_compile =
+          if force do
+            sources
+          else
+            filter_stale(sources, output_dir)
+          end
 
-      if Enum.empty?(sources_to_compile) and not do_link do
-        Mix.shell().info("🔥 Firebird WASM Target: All #{length(sources)} file(s) up to date")
-        Mix.shell().info("   Use --force to recompile")
-        :ok
-      else
-        Mix.shell().info("🔥 Firebird WASM Target")
-        Mix.shell().info("   Sources: #{length(sources_to_compile)} file(s)#{if not force and length(sources_to_compile) < length(sources), do: " (#{length(sources) - length(sources_to_compile)} cached)", else: ""}")
-        Mix.shell().info("   Output:  #{output_dir}/")
-        Mix.shell().info("")
+        if Enum.empty?(sources_to_compile) and not do_link do
+          Mix.shell().info("🔥 Firebird WASM Target: All #{length(sources)} file(s) up to date")
+          Mix.shell().info("   Use --force to recompile")
+          :ok
+        else
+          Mix.shell().info("🔥 Firebird WASM Target")
 
-        File.mkdir_p!(output_dir)
+          Mix.shell().info(
+            "   Sources: #{length(sources_to_compile)} file(s)#{if not force and length(sources_to_compile) < length(sources), do: " (#{length(sources) - length(sources_to_compile)} cached)", else: ""}"
+          )
 
-        start_time = System.monotonic_time(:millisecond)
+          Mix.shell().info("   Output:  #{output_dir}/")
+          Mix.shell().info("")
 
-        source_map = Keyword.get(opts, :source_map, false)
-        compile_opts = [optimize: optimize, tco: tco, inline: do_inline, source_map: source_map]
+          File.mkdir_p!(output_dir)
 
-        results =
-          Enum.map(sources_to_compile, fn source ->
-            compile_source(source, output_dir, wat_only, verbose, verify, compile_opts, profile)
-          end)
+          start_time = System.monotonic_time(:millisecond)
 
-        elapsed = System.monotonic_time(:millisecond) - start_time
+          source_map = Keyword.get(opts, :source_map, false)
+          compile_opts = [optimize: optimize, tco: tco, inline: do_inline, source_map: source_map]
 
-        successes = Enum.filter(results, &match?({:ok, _}, &1))
-        failures = Enum.filter(results, &match?({:error, _}, &1))
+          results =
+            Enum.map(sources_to_compile, fn source ->
+              compile_source(source, output_dir, wat_only, verbose, verify, compile_opts, profile)
+            end)
 
-        # Update manifest
-        update_manifest(successes, output_dir)
+          elapsed = System.monotonic_time(:millisecond) - start_time
 
-        Mix.shell().info("")
+          successes = Enum.filter(results, &match?({:ok, _}, &1))
+          failures = Enum.filter(results, &match?({:error, _}, &1))
 
-        # JSON output mode
-        json_mode = Keyword.get(opts, :json, false)
+          # Update manifest
+          update_manifest(successes, output_dir)
 
-        if json_mode do
-          summary = Firebird.Compiler.Summary.generate(results)
-          summary_with_time = Map.put(summary, :elapsed_ms, elapsed)
-          Mix.shell().info(Firebird.Compiler.Summary.to_json(summary_with_time))
-        else
-          if show_stats do
-            print_stats(successes)
-          end
+          Mix.shell().info("")
 
-          Mix.shell().info("📊 Results: #{length(successes)} compiled, #{length(failures)} failed (#{elapsed}ms)")
-        end
+          # JSON output mode
+          json_mode = Keyword.get(opts, :json, false)
 
-        # Link if requested
-        link_result =
-          if do_link and Enum.any?(successes) do
-            link_modules(sources, opts)
+          if json_mode do
+            summary = Firebird.Compiler.Summary.generate(results)
+            summary_with_time = Map.put(summary, :elapsed_ms, elapsed)
+            Mix.shell().info(Firebird.Compiler.Summary.to_json(summary_with_time))
           else
-            :ok
+            if show_stats do
+              print_stats(successes)
+            end
+
+            Mix.shell().info(
+              "📊 Results: #{length(successes)} compiled, #{length(failures)} failed (#{elapsed}ms)"
+            )
           end
 
-        cond do
-          Enum.any?(failures) ->
-            {:error, {:compilation_failed, length(failures)}}
-          link_result != :ok ->
-            link_result
-          true ->
-            :ok
+          # Link if requested
+          link_result =
+            if do_link and Enum.any?(successes) do
+              link_modules(sources, opts)
+            else
+              :ok
+            end
+
+          cond do
+            Enum.any?(failures) ->
+              {:error, {:compilation_failed, length(failures)}}
+
+            link_result != :ok ->
+              link_result
+
+            true ->
+              :ok
+          end
         end
       end
-      end  # dry_run else
+
+      # dry_run else
     end
   end
 
@@ -646,12 +656,13 @@ defmodule Mix.Tasks.Firebird.Target do
     phases = []
 
     # Phase 1: Read file
-    {read_us, source_code} = :timer.tc(fn ->
-      case File.read(source) do
-        {:ok, code} -> code
-        {:error, reason} -> {:error, {:file_error, reason, source}}
-      end
-    end)
+    {read_us, source_code} =
+      :timer.tc(fn ->
+        case File.read(source) do
+          {:ok, code} -> code
+          {:error, reason} -> {:error, {:file_error, reason, source}}
+        end
+      end)
 
     phases = [{:read, read_us} | phases]
 
@@ -660,39 +671,43 @@ defmodule Mix.Tasks.Firebird.Target do
       {:error, {source, source_code}}
     else
       # Phase 2: Parse
-      {parse_us, parse_result} = :timer.tc(fn ->
-        Firebird.Compiler.parse(source_code)
-      end)
+      {parse_us, parse_result} =
+        :timer.tc(fn ->
+          Firebird.Compiler.parse(source_code)
+        end)
 
       phases = [{:parse, parse_us} | phases]
 
       case parse_result do
         {:ok, ast} ->
           # Phase 3: IR Generation
-          {ir_us, ir_result} = :timer.tc(fn ->
-            Firebird.Compiler.IRGen.generate(ast)
-          end)
+          {ir_us, ir_result} =
+            :timer.tc(fn ->
+              Firebird.Compiler.IRGen.generate(ast)
+            end)
 
           phases = [{:ir_gen, ir_us} | phases]
 
           case ir_result do
             {:ok, module_ir} ->
               # Phase 4: Type Inference
-              {type_us, type_result} = :timer.tc(fn ->
-                with :ok <- Firebird.Compiler.Validator.validate(module_ir),
-                     {:ok, typed} <- Firebird.Compiler.TypeInference.infer(module_ir) do
-                  {:ok, typed}
-                end
-              end)
+              {type_us, type_result} =
+                :timer.tc(fn ->
+                  with :ok <- Firebird.Compiler.Validator.validate(module_ir),
+                       {:ok, typed} <- Firebird.Compiler.TypeInference.infer(module_ir) do
+                    {:ok, typed}
+                  end
+                end)
 
               phases = [{:type_infer, type_us} | phases]
 
               case type_result do
                 {:ok, typed_ir} ->
                   # Phase 5: WAT Generation
-                  {wat_us, wat_result} = :timer.tc(fn ->
-                    Firebird.Compiler.WATGen.generate(typed_ir)
-                  end)
+                  {wat_us, wat_result} =
+                    :timer.tc(fn ->
+                      Firebird.Compiler.WATGen.generate(typed_ir)
+                    end)
 
                   phases = [{:wat_gen, wat_us} | phases]
 
@@ -781,7 +796,9 @@ defmodule Mix.Tasks.Firebird.Target do
       Mix.shell().info("       #{name} #{time} (#{pct}%)")
     end)
 
-    Mix.shell().info("       #{"total" |> String.pad_trailing(12)} #{format_microseconds(total) |> String.pad_leading(10)}")
+    Mix.shell().info(
+      "       #{"total" |> String.pad_trailing(12)} #{format_microseconds(total) |> String.pad_leading(10)}"
+    )
   end
 
   defp format_microseconds(us) when us < 1000, do: "#{us}μs"
@@ -789,6 +806,7 @@ defmodule Mix.Tasks.Firebird.Target do
   defp format_microseconds(us), do: "#{Float.round(us / 1_000_000, 2)}s"
 
   defp print_verbose(result, false), do: result
+
   defp print_verbose(result, true) do
     Mix.shell().info("     Module: #{result.module}")
     Mix.shell().info("     WAT: #{byte_size(result.wat)} bytes")
@@ -816,6 +834,7 @@ defmodule Mix.Tasks.Firebird.Target do
   end
 
   defp maybe_verify(_result, false), do: :ok
+
   defp maybe_verify(result, true) do
     if result.wasm do
       verify_module(result)
@@ -856,7 +875,10 @@ defmodule Mix.Tasks.Firebird.Target do
     Enum.each(results, fn r ->
       name = inspect(r.module) |> String.pad_trailing(26) |> String.slice(0, 26)
       wat_sz = byte_size(r.wat) |> to_string() |> String.pad_leading(12)
-      wasm_sz = if(r.wasm, do: byte_size(r.wasm), else: 0) |> to_string() |> String.pad_leading(12)
+
+      wasm_sz =
+        if(r.wasm, do: byte_size(r.wasm), else: 0) |> to_string() |> String.pad_leading(12)
+
       Mix.shell().info("   │ #{name} │ #{wat_sz} │ #{wasm_sz} │")
     end)
 
@@ -864,7 +886,11 @@ defmodule Mix.Tasks.Firebird.Target do
 
     total_wat_s = total_wat |> to_string() |> String.pad_leading(12)
     total_wasm_s = total_wasm |> to_string() |> String.pad_leading(12)
-    Mix.shell().info("   │ #{"TOTAL" |> String.pad_trailing(26)} │ #{total_wat_s} │ #{total_wasm_s} │")
+
+    Mix.shell().info(
+      "   │ #{"TOTAL" |> String.pad_trailing(26)} │ #{total_wat_s} │ #{total_wasm_s} │"
+    )
+
     Mix.shell().info("   └────────────────────────────┴──────────────┴──────────────┘")
 
     if total_wat > 0 and total_wasm > 0 do
@@ -924,14 +950,3 @@ defmodule Mix.Tasks.Firebird.Target do
   defp format_error({:file_error, reason, path}), do: "Cannot read #{path}: #{reason}"
   defp format_error(other), do: inspect(other)
 end
-
-
-
-
-
-
-
-
-
-
-
diff --git a/lib/mix/tasks/firebird.target.inspect.ex b/lib/mix/tasks/firebird.target.inspect.ex
index f7737b1..5b4ea0c 100644
--- a/lib/mix/tasks/firebird.target.inspect.ex
+++ b/lib/mix/tasks/firebird.target.inspect.ex
@@ -75,11 +75,17 @@ defmodule Mix.Tasks.Firebird.Target.Inspect do
       case Firebird.Target.Pipeline.run_all(source, pipeline_opts) do
         {:ok, results} ->
           Mix.shell().info("  ✅ Parse: AST generated")
-          Mix.shell().info("  ✅ IR: #{results.ir.name} (#{length(results.ir.functions)} functions)")
+
+          Mix.shell().info(
+            "  ✅ IR: #{results.ir.name} (#{length(results.ir.functions)} functions)"
+          )
+
           Mix.shell().info("  ✅ Validated")
 
           Enum.each(results.typed_ir.functions, fn f ->
-            params = if f.type, do: Enum.map(f.type.params, &to_string/1) |> Enum.join(", "), else: "?"
+            params =
+              if f.type, do: Enum.map(f.type.params, &to_string/1) |> Enum.join(", "), else: "?"
+
             ret = if f.type, do: to_string(f.type.return), else: "?"
             Mix.shell().info("     #{f.name}(#{params}) -> #{ret}")
           end)
diff --git a/lib/mix/tasks/firebird.target.link.ex b/lib/mix/tasks/firebird.target.link.ex
index 2376693..5d35dd2 100644
--- a/lib/mix/tasks/firebird.target.link.ex
+++ b/lib/mix/tasks/firebird.target.link.ex
@@ -171,9 +171,9 @@ defmodule Mix.Tasks.Firebird.Target.Link do
     case File.read(path) do
       {:ok, content} ->
         String.contains?(content, "@wasm true") or String.contains?(path, "wasm_modules")
+
       _ ->
         false
     end
   end
 end
-
diff --git a/lib/mix/tasks/firebird.target.new.ex b/lib/mix/tasks/firebird.target.new.ex
index 0972d4b..8a741be 100644
--- a/lib/mix/tasks/firebird.target.new.ex
+++ b/lib/mix/tasks/firebird.target.new.ex
@@ -54,7 +54,8 @@ defmodule Mix.Tasks.Firebird.Target.New do
     with_test = Keyword.get(opts, :with_test, false)
 
     # Generate module path
-    filename = module_name
+    filename =
+      module_name
       |> String.split(".")
       |> List.last()
       |> Macro.underscore()
@@ -119,13 +120,16 @@ defmodule Mix.Tasks.Firebird.Target.New do
   end
 
   defp generate_module(module_name, functions) do
-    func_defs = Enum.map(functions, fn name ->
-      name = String.trim(name)
-      """
-        @wasm true
-        def #{name}(a, b), do: a + b
-      """
-    end) |> Enum.join("\n")
+    func_defs =
+      Enum.map(functions, fn name ->
+        name = String.trim(name)
+
+        """
+          @wasm true
+          def #{name}(a, b), do: a + b
+        """
+      end)
+      |> Enum.join("\n")
 
     """
     defmodule #{module_name} do
@@ -168,14 +172,17 @@ defmodule Mix.Tasks.Firebird.Target.New do
   end
 
   defp generate_test(module_name, functions) do
-    test_cases = Enum.map(functions, fn name ->
-      name = String.trim(name)
-      """
-        test "#{name}", %{instance: inst} do
-          assert {:ok, [_result]} = Firebird.call(inst, "#{name}", [1, 2])
-        end
-      """
-    end) |> Enum.join("\n")
+    test_cases =
+      Enum.map(functions, fn name ->
+        name = String.trim(name)
+
+        """
+          test "#{name}", %{instance: inst} do
+            assert {:ok, [_result]} = Firebird.call(inst, "#{name}", [1, 2])
+          end
+        """
+      end)
+      |> Enum.join("\n")
 
     """
     defmodule #{module_name}Test do
diff --git a/lib/mix/tasks/firebird.target.profile.ex b/lib/mix/tasks/firebird.target.profile.ex
index e168dc7..ff63929 100644
--- a/lib/mix/tasks/firebird.target.profile.ex
+++ b/lib/mix/tasks/firebird.target.profile.ex
@@ -74,12 +74,18 @@ defmodule Mix.Tasks.Firebird.Target.Profile do
           module: if(profile.module, do: to_string(profile.module)),
           result: profile.result,
           total_us: profile.total_us,
-          timings: Enum.map(profile.timings, fn t ->
-            %{stage: t.stage, elapsed_us: t.elapsed_us, percentage: Float.round(t.percentage, 2)}
-          end),
+          timings:
+            Enum.map(profile.timings, fn t ->
+              %{
+                stage: t.stage,
+                elapsed_us: t.elapsed_us,
+                percentage: Float.round(t.percentage, 2)
+              }
+            end),
           error: if(profile.error, do: inspect(profile.error)),
           options: Enum.into(profile.options, %{})
         }
+
         Mix.shell().info(Jason.encode!(data, pretty: true))
       else
         Mix.shell().info(Firebird.Target.Profiler.format(profile))
diff --git a/lib/mix/tasks/firebird.target.report.ex b/lib/mix/tasks/firebird.target.report.ex
index bbfcaf1..95476c6 100644
--- a/lib/mix/tasks/firebird.target.report.ex
+++ b/lib/mix/tasks/firebird.target.report.ex
@@ -134,8 +134,15 @@ defmodule Mix.Tasks.Firebird.Target.Report do
             Mix.shell().info("")
             Mix.shell().info("📊 Comparison with #{path}:")
             Mix.shell().info("   Modules: #{format_change(diff.module_count_change)}")
-            Mix.shell().info("   WAT: #{format_bytes_change(diff.wat_bytes_change, diff.wat_percent_change)}")
-            Mix.shell().info("   WASM: #{format_bytes_change(diff.wasm_bytes_change, diff.wasm_percent_change)}")
+
+            Mix.shell().info(
+              "   WAT: #{format_bytes_change(diff.wat_bytes_change, diff.wat_percent_change)}"
+            )
+
+            Mix.shell().info(
+              "   WASM: #{format_bytes_change(diff.wasm_bytes_change, diff.wasm_percent_change)}"
+            )
+
             Mix.shell().info("   Time: #{format_time_change(diff.time_change_ms)}")
 
           _ ->
diff --git a/lib/mix/tasks/firebird.target.status.ex b/lib/mix/tasks/firebird.target.status.ex
index fc780bf..317125d 100644
--- a/lib/mix/tasks/firebird.target.status.ex
+++ b/lib/mix/tasks/firebird.target.status.ex
@@ -57,7 +57,11 @@ defmodule Mix.Tasks.Firebird.Target.Status do
     # Prerequisites
     prereqs = status.prerequisites
     Mix.shell().info("  Prerequisites:")
-    Mix.shell().info("    wat2wasm:  #{if prereqs.wat2wasm, do: "✅ installed", else: "❌ not found"}")
+
+    Mix.shell().info(
+      "    wat2wasm:  #{if prereqs.wat2wasm, do: "✅ installed", else: "❌ not found"}"
+    )
+
     Mix.shell().info("    Elixir:    #{prereqs.elixir_version}")
     Mix.shell().info("    OTP:       #{prereqs.otp_version}")
     Mix.shell().info("")
diff --git a/lib/mix/tasks/firebird.target.verify.ex b/lib/mix/tasks/firebird.target.verify.ex
index e7117cc..1218e4f 100644
--- a/lib/mix/tasks/firebird.target.verify.ex
+++ b/lib/mix/tasks/firebird.target.verify.ex
@@ -83,7 +83,10 @@ defmodule Mix.Tasks.Firebird.Target.Verify do
 
   defp verify_directory(dir, verbose, json_mode) do
     unless File.dir?(dir) do
-      Mix.shell().info("Directory #{dir} does not exist. Run `mix firebird.target.compile` first.")
+      Mix.shell().info(
+        "Directory #{dir} does not exist. Run `mix firebird.target.compile` first."
+      )
+
       :ok
     else
       Mix.shell().info("🔍 Verifying WASM modules in #{dir}/")
@@ -95,9 +98,11 @@ defmodule Mix.Tasks.Firebird.Target.Verify do
             Mix.shell().info("  No WASM files found in #{dir}/")
           else
             if json_mode do
-              data = Enum.map(reports, fn r ->
-                %{file: r.file, valid: r.result.valid, exports: r.result.export_count}
-              end)
+              data =
+                Enum.map(reports, fn r ->
+                  %{file: r.file, valid: r.result.valid, exports: r.result.export_count}
+                end)
+
               Mix.shell().info(Jason.encode!(data, pretty: true))
             else
               Enum.each(reports, fn r ->
diff --git a/lib/mix/tasks/firebird.target.watch.ex b/lib/mix/tasks/firebird.target.watch.ex
index e1120ac..060716e 100644
--- a/lib/mix/tasks/firebird.target.watch.ex
+++ b/lib/mix/tasks/firebird.target.watch.ex
@@ -166,7 +166,9 @@ defmodule Mix.Tasks.Firebird.Target.Watch do
           {:ok, content} ->
             String.contains?(content, "@wasm true") or
               String.contains?(path, "wasm_modules")
-          _ -> false
+
+          _ ->
+            false
         end
       end)
 
diff --git a/lib/mix/tasks/firebird.test.ex b/lib/mix/tasks/firebird.test.ex
index 17b874c..4a47f29 100644
--- a/lib/mix/tasks/firebird.test.ex
+++ b/lib/mix/tasks/firebird.test.ex
@@ -25,14 +25,16 @@ defmodule Mix.Tasks.Firebird.Test do
       Path.wildcard("test/**/*_test.exs")
       |> Enum.filter(fn path ->
         content = File.read!(path)
+
         String.contains?(content, "Firebird") or
-        String.contains?(content, "wasm") or
-        String.contains?(content, "WASM")
+          String.contains?(content, "wasm") or
+          String.contains?(content, "WASM")
       end)
 
     if wasm_tests == [] do
       Mix.shell().info("No WASM-related tests found.")
       Mix.shell().info("Create tests using Firebird.TestHelpers:")
+
       Mix.shell().info("""
 
         defmodule MyWasmTest do
diff --git a/lib/wasm_modules/algorithms.ex b/lib/wasm_modules/algorithms.ex
index f335e23..e3be0b8 100644
--- a/lib/wasm_modules/algorithms.ex
+++ b/lib/wasm_modules/algorithms.ex
@@ -6,6 +6,8 @@ defmodule Firebird.WasmModules.Algorithms do
   All functions use only the compilable subset of Elixir.
   """
 
+  Module.register_attribute(__MODULE__, :wasm, accumulate: true)
+
   @wasm true
   def is_prime(n) do
     if n <= 1 do
@@ -56,6 +58,7 @@ defmodule Firebird.WasmModules.Algorithms do
       lo - 1
     else
       mid = div(lo + hi, 2)
+
       if mid * mid == n do
         mid
       else
diff --git a/lib/wasm_modules/crypto_utils.ex b/lib/wasm_modules/crypto_utils.ex
index 48dfa7a..831681e 100644
--- a/lib/wasm_modules/crypto_utils.ex
+++ b/lib/wasm_modules/crypto_utils.ex
@@ -6,6 +6,8 @@ defmodule Firebird.WasmModules.CryptoUtils do
   manipulation compiled to WASM for checksumming and hashing.
   """
 
+  Module.register_attribute(__MODULE__, :wasm, accumulate: true)
+
   @wasm true
   def djb2_step(hash, char) do
     # DJB2 hash: hash * 33 + char
@@ -17,13 +19,13 @@ defmodule Firebird.WasmModules.CryptoUtils do
     # FNV-1a: (hash XOR byte) * FNV_prime
     # Simplified for integer math
     xor_val = hash - 2 * (hash * byte - hash * byte)
-    xor_val * 16777619
+    xor_val * 16_777_619
   end
 
   @wasm true
   def simple_checksum(a, b, c, d) do
     # Simple additive checksum of 4 values
-    rem(a + b * 31 + c * 31 * 31 + d * 31 * 31 * 31, 1000000007)
+    rem(a + b * 31 + c * 31 * 31 + d * 31 * 31 * 31, 1_000_000_007)
   end
 
   @wasm true
@@ -38,6 +40,7 @@ defmodule Firebird.WasmModules.CryptoUtils do
 
   @wasm true
   def modular_exp(_base, 0, _mod), do: 1
+
   def modular_exp(base, exp, mod) do
     if rem(exp, 2) == 0 do
       half = modular_exp(base, div(exp, 2), mod)
diff --git a/lib/wasm_modules/math.ex b/lib/wasm_modules/math.ex
index ec89352..7660b6b 100644
--- a/lib/wasm_modules/math.ex
+++ b/lib/wasm_modules/math.ex
@@ -6,6 +6,8 @@ defmodule Firebird.WasmModules.Math do
   for common math operations.
   """
 
+  Module.register_attribute(__MODULE__, :wasm, accumulate: true)
+
   @wasm true
   def add(a, b), do: a + b
 
@@ -109,6 +111,7 @@ defmodule Firebird.WasmModules.Math do
 
   @wasm true
   def collatz_steps(1), do: 0
+
   def collatz_steps(n) do
     if rem(n, 2) == 0 do
       1 + collatz_steps(div(n, 2))
diff --git a/lib/wasm_modules/physics.ex b/lib/wasm_modules/physics.ex
index 1d14b2c..e448929 100644
--- a/lib/wasm_modules/physics.ex
+++ b/lib/wasm_modules/physics.ex
@@ -7,6 +7,8 @@ defmodule Firebird.WasmModules.Physics do
   only supports integers and floats.
   """
 
+  Module.register_attribute(__MODULE__, :wasm, accumulate: true)
+
   @wasm true
   def distance(velocity, time), do: velocity * time
 
diff --git a/mix.exs b/mix.exs
index f8f9118..886f489 100644
--- a/mix.exs
+++ b/mix.exs
@@ -9,7 +9,8 @@ defmodule Firebird.MixProject do
       start_permanent: Mix.env() == :prod,
       deps: deps(),
       name: "Firebird",
-      description: "Run WebAssembly from Elixir. Load WASM modules in Rust, Go, C — call them like native functions.",
+      description:
+        "Run WebAssembly from Elixir. Load WASM modules in Rust, Go, C — call them like native functions.",
       source_url: "https://github.com/hdresearch/firebird",
       homepage_url: "https://github.com/hdresearch/firebird",
       package: package(),
@@ -36,7 +37,8 @@ defmodule Firebird.MixProject do
         "GitHub" => "https://github.com/hdresearch/firebird",
         "Docs" => "https://hexdocs.pm/firebird"
       },
-      files: ~w(lib priv/wasm fixtures/math.wasm fixtures/wat_math.wasm mix.exs README.md CHEATSHEET.md LICENSE)
+      files:
+        ~w(lib priv/wasm fixtures/math.wasm fixtures/wat_math.wasm mix.exs README.md CHEATSHEET.md LICENSE)
     ]
   end
 
@@ -62,7 +64,7 @@ defmodule Firebird.MixProject do
         "docs/WASM_TARGET_API.md"
       ],
       groups_for_extras: [
-        "Guides": [
+        Guides: [
           "docs/GETTING_STARTED.md",
           "docs/DECISION_GUIDE.md",
           "docs/PERFORMANCE_GUIDE.md",
@@ -71,13 +73,13 @@ defmodule Firebird.MixProject do
           "docs/FAQ.md",
           "docs/TROUBLESHOOTING.md"
         ],
-        "Reference": [
+        Reference: [
           "docs/API.md",
           "docs/ARCHITECTURE.md",
           "docs/WASM_TARGET_API.md",
           "CHEATSHEET.md"
         ],
-        "Advanced": [
+        Advanced: [
           "docs/ELIXIR_TO_WASM.md",
           "docs/PHOENIX_TO_WASM.md",
           "docs/WASM_TARGET.md",
@@ -85,8 +87,20 @@ defmodule Firebird.MixProject do
         ]
       ],
       groups_for_modules: [
-        "Core": [Firebird, Firebird.Runtime, Firebird.Module, Firebird.Pool, Firebird.Lazy, Firebird.Memory],
-        "Streaming & Pipelines": [Firebird.Stream, Firebird.Pipeline, Firebird.Builder, Firebird.Batch],
+        Core: [
+          Firebird,
+          Firebird.Runtime,
+          Firebird.Module,
+          Firebird.Pool,
+          Firebird.Lazy,
+          Firebird.Memory
+        ],
+        "Streaming & Pipelines": [
+          Firebird.Stream,
+          Firebird.Pipeline,
+          Firebird.Builder,
+          Firebird.Batch
+        ],
         "Developer Tools": [
           Firebird.Inspector,
           Firebird.TestCase,
@@ -96,7 +110,7 @@ defmodule Firebird.MixProject do
           Firebird.Quick,
           Firebird.Unwrap
         ],
-        "Production": [
+        Production: [
           Firebird.Cache,
           Firebird.ModuleCache,
           Firebird.Preloader,
@@ -107,9 +121,9 @@ defmodule Firebird.MixProject do
           Firebird.Sandbox
         ],
         "WASM Target (Elixir → WASM)": ~r/Firebird\.Target/,
-        "Errors": [Firebird.WasmError, Firebird.Errors],
-        "Phoenix": ~r/Firebird\.Phoenix/,
-        "Compiler": ~r/Firebird\.Compiler/,
+        Errors: [Firebird.WasmError, Firebird.Errors],
+        Phoenix: ~r/Firebird\.Phoenix/,
+        Compiler: ~r/Firebird\.Compiler/,
         "Mix Tasks": ~r/Mix\.Tasks/
       ]
     ]
@@ -117,7 +131,8 @@ defmodule Firebird.MixProject do
 
   defp deps do
     [
-      {:wasmex, "~> 0.9"},  # WASM runtime
+      # WASM runtime
+      {:wasmex, "~> 0.9"},
       {:jason, "~> 1.4"},
       {:excoveralls, "~> 0.18", only: :test},
       {:benchee, "~> 1.3", only: :dev},
diff --git a/test/assert_wasm_table_test.exs b/test/assert_wasm_table_test.exs
index ec2f34d..d02f6ac 100644
--- a/test/assert_wasm_table_test.exs
+++ b/test/assert_wasm_table_test.exs
@@ -41,10 +41,13 @@ defmodule Firebird.AssertWasmTableTest do
   end
 
   test "assert_wasm_table with raw: true uses list-wrapped results", %{wasm: wasm} do
-    assert_wasm_table wasm, :add, [
-      {[1, 2], [3]},
-      {[5, 3], [8]}
-    ], raw: true
+    assert_wasm_table wasm,
+                      :add,
+                      [
+                        {[1, 2], [3]},
+                        {[5, 3], [8]}
+                      ],
+                      raw: true
   end
 
   test "assert_wasm_table works with a single row", %{wasm: wasm} do
diff --git a/test/batch_test.exs b/test/batch_test.exs
index 5274b73..1865be2 100644
--- a/test/batch_test.exs
+++ b/test/batch_test.exs
@@ -11,11 +11,12 @@ defmodule Firebird.BatchTest do
 
   describe "run/3" do
     test "executes batch of calls", %{pool: pool} do
-      results = Firebird.Batch.run(pool, [
-        {:add, [1, 2]},
-        {:add, [3, 4]},
-        {:multiply, [5, 6]}
-      ])
+      results =
+        Firebird.Batch.run(pool, [
+          {:add, [1, 2]},
+          {:add, [3, 4]},
+          {:multiply, [5, 6]}
+        ])
 
       assert results == [{:ok, [3]}, {:ok, [7]}, {:ok, [30]}]
     end
@@ -29,11 +30,12 @@ defmodule Firebird.BatchTest do
     end
 
     test "handles errors in batch", %{pool: pool} do
-      results = Firebird.Batch.run(pool, [
-        {:add, [1, 2]},
-        {:nonexistent, [1]},
-        {:add, [3, 4]}
-      ])
+      results =
+        Firebird.Batch.run(pool, [
+          {:add, [1, 2]},
+          {:nonexistent, [1]},
+          {:add, [3, 4]}
+        ])
 
       assert [{:ok, [3]}, {:error, _}, {:ok, [7]}] = results
     end
diff --git a/test/benchmark_test.exs b/test/benchmark_test.exs
index fb0a8a2..9b92cee 100644
--- a/test/benchmark_test.exs
+++ b/test/benchmark_test.exs
@@ -223,7 +223,8 @@ defmodule Firebird.BenchmarkTest do
 
       csv = Benchmark.format_csv(results)
       lines = String.split(csv, "\n")
-      assert length(lines) == 2  # header + 1 row
+      # header + 1 row
+      assert length(lines) == 2
 
       [header | _] = lines
       assert String.contains?(header, "name")
@@ -234,21 +235,33 @@ defmodule Firebird.BenchmarkTest do
 
     test "handles multiple results" do
       results = [
-        %{name: "a", function: :a, wasm: %{avg_us: 1.0, p50_us: 1.0, p95_us: 1.0, p99_us: 1.0},
-          beam: %{avg_us: 2.0, p50_us: 2.0, p95_us: 2.0, p99_us: 2.0}, speedup: 2.0},
-        %{name: "b", function: :b, wasm: %{avg_us: 3.0, p50_us: 3.0, p95_us: 3.0, p99_us: 3.0},
-          beam: %{avg_us: 4.0, p50_us: 4.0, p95_us: 4.0, p99_us: 4.0}, speedup: 1.33}
+        %{
+          name: "a",
+          function: :a,
+          wasm: %{avg_us: 1.0, p50_us: 1.0, p95_us: 1.0, p99_us: 1.0},
+          beam: %{avg_us: 2.0, p50_us: 2.0, p95_us: 2.0, p99_us: 2.0},
+          speedup: 2.0
+        },
+        %{
+          name: "b",
+          function: :b,
+          wasm: %{avg_us: 3.0, p50_us: 3.0, p95_us: 3.0, p99_us: 3.0},
+          beam: %{avg_us: 4.0, p50_us: 4.0, p95_us: 4.0, p99_us: 4.0},
+          speedup: 1.33
+        }
       ]
 
       csv = Benchmark.format_csv(results)
       lines = String.split(csv, "\n")
-      assert length(lines) == 3  # header + 2 rows
+      # header + 2 rows
+      assert length(lines) == 3
     end
 
     test "handles empty results" do
       csv = Benchmark.format_csv([])
       lines = String.split(csv, "\n")
-      assert length(lines) == 1  # just header
+      # just header
+      assert length(lines) == 1
     end
   end
 
@@ -335,11 +348,12 @@ defmodule Firebird.BenchmarkTest do
 
       beam_add = fn a, b -> a + b end
 
-      result = Benchmark.compare(source, :add, [[1, 2], [100, 200]],
-        beam_fun: beam_add,
-        iterations: 10,
-        warmup: 2
-      )
+      result =
+        Benchmark.compare(source, :add, [[1, 2], [100, 200]],
+          beam_fun: beam_add,
+          iterations: 10,
+          warmup: 2
+        )
 
       assert result.function == :add
       assert result.iterations == 10
diff --git a/test/builder_comprehensive_test.exs b/test/builder_comprehensive_test.exs
index 67e5a83..b20580b 100644
--- a/test/builder_comprehensive_test.exs
+++ b/test/builder_comprehensive_test.exs
@@ -113,6 +113,7 @@ defmodule Firebird.BuilderComprehensiveTest do
     test "returns not_found for nonexistent directory" do
       assert {:error, {:not_found, msg}} =
                Firebird.Builder.build_go("/nonexistent/go/project/#{:rand.uniform(100_000)}")
+
       assert msg =~ "Directory not found"
     end
 
@@ -152,14 +153,18 @@ defmodule Firebird.BuilderComprehensiveTest do
 
     test "accepts scheduler option" do
       unless @tinygo_available do
-        result = Firebird.Builder.build_go(Path.join(@fixtures_dir, "go_math"), scheduler: "coroutines")
+        result =
+          Firebird.Builder.build_go(Path.join(@fixtures_dir, "go_math"), scheduler: "coroutines")
+
         assert {:error, {:tool_missing, _}} = result
       end
     end
 
     test "accepts gc option" do
       unless @tinygo_available do
-        result = Firebird.Builder.build_go(Path.join(@fixtures_dir, "go_math"), gc: "conservative")
+        result =
+          Firebird.Builder.build_go(Path.join(@fixtures_dir, "go_math"), gc: "conservative")
+
         assert {:error, {:tool_missing, _}} = result
       end
     end
@@ -180,6 +185,7 @@ defmodule Firebird.BuilderComprehensiveTest do
     test "returns not_found for nonexistent directory" do
       assert {:error, {:not_found, msg}} =
                Firebird.Builder.build_rust("/nonexistent/rust/project/#{:rand.uniform(100_000)}")
+
       assert msg =~ "Directory not found"
     end
 
@@ -203,27 +209,33 @@ defmodule Firebird.BuilderComprehensiveTest do
 
     test "accepts release option" do
       unless @cargo_available do
-        result = Firebird.Builder.build_rust(Path.join(@fixtures_dir, "rust_math_src"), release: false)
+        result =
+          Firebird.Builder.build_rust(Path.join(@fixtures_dir, "rust_math_src"), release: false)
+
         assert {:error, {:tool_missing, _}} = result
       end
     end
 
     test "accepts features option" do
       unless @cargo_available do
-        result = Firebird.Builder.build_rust(
-          Path.join(@fixtures_dir, "rust_math_src"),
-          features: ["feature1", "feature2"]
-        )
+        result =
+          Firebird.Builder.build_rust(
+            Path.join(@fixtures_dir, "rust_math_src"),
+            features: ["feature1", "feature2"]
+          )
+
         assert {:error, {:tool_missing, _}} = result
       end
     end
 
     test "accepts custom target option" do
       unless @cargo_available do
-        result = Firebird.Builder.build_rust(
-          Path.join(@fixtures_dir, "rust_math_src"),
-          target: "wasm32-wasi"
-        )
+        result =
+          Firebird.Builder.build_rust(
+            Path.join(@fixtures_dir, "rust_math_src"),
+            target: "wasm32-wasi"
+          )
+
         assert {:error, {:tool_missing, _}} = result
       end
     end
@@ -231,10 +243,13 @@ defmodule Firebird.BuilderComprehensiveTest do
     test "accepts custom output option" do
       unless @cargo_available do
         output = Path.join(System.tmp_dir!(), "custom_rust_#{:rand.uniform(100_000)}.wasm")
-        result = Firebird.Builder.build_rust(
-          Path.join(@fixtures_dir, "rust_math_src"),
-          output: output
-        )
+
+        result =
+          Firebird.Builder.build_rust(
+            Path.join(@fixtures_dir, "rust_math_src"),
+            output: output
+          )
+
         assert {:error, {:tool_missing, _}} = result
       end
     end
@@ -246,8 +261,7 @@ defmodule Firebird.BuilderComprehensiveTest do
 
   describe "build_wat/2" do
     test "returns not_found for nonexistent WAT file" do
-      assert {:error, {:not_found, msg}} =
-               Firebird.Builder.build_wat("/nonexistent/file.wat")
+      assert {:error, {:not_found, msg}} = Firebird.Builder.build_wat("/nonexistent/file.wat")
       assert msg =~ "WAT file not found"
     end
 
@@ -365,6 +379,7 @@ defmodule Firebird.BuilderComprehensiveTest do
     test "auto-detects standalone Go files and sets wasi" do
       tmp = Path.join(System.tmp_dir!(), "firebird_go_standalone_#{:rand.uniform(100_000)}")
       File.mkdir_p!(tmp)
+
       File.write!(Path.join(tmp, "main.go"), """
       package main
       //export add
@@ -386,20 +401,24 @@ defmodule Firebird.BuilderComprehensiveTest do
 
     test "passes load_opts like memory_limit through" do
       unless @tinygo_available do
-        result = Firebird.Builder.build_and_load(
-          Path.join(@fixtures_dir, "go_math"),
-          memory_limit: 1_048_576
-        )
+        result =
+          Firebird.Builder.build_and_load(
+            Path.join(@fixtures_dir, "go_math"),
+            memory_limit: 1_048_576
+          )
+
         assert {:error, {:tool_missing, _}} = result
       end
     end
 
     test "wasi option can be explicitly set" do
       unless @tinygo_available do
-        result = Firebird.Builder.build_and_load(
-          Path.join(@fixtures_dir, "go_math"),
-          wasi: false
-        )
+        result =
+          Firebird.Builder.build_and_load(
+            Path.join(@fixtures_dir, "go_math"),
+            wasi: false
+          )
+
         assert {:error, {:tool_missing, _}} = result
       end
     end
@@ -526,13 +545,20 @@ defmodule Firebird.BuilderComprehensiveTest do
     end
 
     test "creates directory if it doesn't exist" do
-      tmp = Path.join(System.tmp_dir!(), "firebird_scaffold_nested_#{:rand.uniform(100_000)}/deep/dir")
+      tmp =
+        Path.join(
+          System.tmp_dir!(),
+          "firebird_scaffold_nested_#{:rand.uniform(100_000)}/deep/dir"
+        )
+
       refute File.exists?(tmp)
 
       :ok = Firebird.Builder.scaffold_go(tmp)
       assert File.dir?(tmp)
 
-      File.rm_rf!(Path.join(System.tmp_dir!(), "firebird_scaffold_nested_#{:rand.uniform(100_000)}"))
+      File.rm_rf!(
+        Path.join(System.tmp_dir!(), "firebird_scaffold_nested_#{:rand.uniform(100_000)}")
+      )
     end
 
     test "single function scaffold" do
@@ -578,7 +604,8 @@ defmodule Firebird.BuilderComprehensiveTest do
     end
 
     test "uses default functions [:add, :multiply]" do
-      tmp = Path.join(System.tmp_dir!(), "firebird_scaffold_rust_default_#{:rand.uniform(100_000)}")
+      tmp =
+        Path.join(System.tmp_dir!(), "firebird_scaffold_rust_default_#{:rand.uniform(100_000)}")
 
       :ok = Firebird.Builder.scaffold_rust(tmp)
 
@@ -590,7 +617,8 @@ defmodule Firebird.BuilderComprehensiveTest do
     end
 
     test "uses custom functions" do
-      tmp = Path.join(System.tmp_dir!(), "firebird_scaffold_rust_custom_#{:rand.uniform(100_000)}")
+      tmp =
+        Path.join(System.tmp_dir!(), "firebird_scaffold_rust_custom_#{:rand.uniform(100_000)}")
 
       :ok = Firebird.Builder.scaffold_rust(tmp, functions: [:hash, :verify])
 
diff --git a/test/builder_test.exs b/test/builder_test.exs
index 5ba87a5..5da0f4f 100644
--- a/test/builder_test.exs
+++ b/test/builder_test.exs
@@ -17,7 +17,9 @@ defmodule Firebird.BuilderTest do
 
     @tag :tinygo_required
     test "tinygo is available" do
-      if !@tinygo_available, do: flunk("TinyGo not installed (skippable with --exclude tinygo_required)")
+      if !@tinygo_available,
+        do: flunk("TinyGo not installed (skippable with --exclude tinygo_required)")
+
       tools = Firebird.Builder.check_tools()
       assert tools.tinygo != nil, "TinyGo should be installed"
     end
@@ -31,14 +33,16 @@ defmodule Firebird.BuilderTest do
   describe "build/2 auto-detection" do
     @tag :tinygo_required
     test "detects Go project" do
-      if !@tinygo_available, do: flunk("TinyGo not installed (skippable with --exclude tinygo_required)")
+      if !@tinygo_available,
+        do: flunk("TinyGo not installed (skippable with --exclude tinygo_required)")
+
       {:ok, wasm_path} = Firebird.Builder.build(Path.join(@fixtures_dir, "go_math"))
       assert File.exists?(wasm_path)
       assert String.ends_with?(wasm_path, ".wasm")
     end
 
     test "returns error for unknown project type" do
-      tmp = Path.join(System.tmp_dir!(), "firebird_builder_test_#{:rand.uniform(100000)}")
+      tmp = Path.join(System.tmp_dir!(), "firebird_builder_test_#{:rand.uniform(100_000)}")
       File.mkdir_p!(tmp)
 
       assert {:error, {:unknown_project, _}} = Firebird.Builder.build(tmp)
@@ -54,7 +58,9 @@ defmodule Firebird.BuilderTest do
   describe "build_go/2" do
     @tag :tinygo_required
     test "builds a Go WASM module" do
-      if !@tinygo_available, do: flunk("TinyGo not installed (skippable with --exclude tinygo_required)")
+      if !@tinygo_available,
+        do: flunk("TinyGo not installed (skippable with --exclude tinygo_required)")
+
       {:ok, wasm_path} = Firebird.Builder.build_go(Path.join(@fixtures_dir, "go_math"))
       assert File.exists?(wasm_path)
       bytes = File.read!(wasm_path)
@@ -64,13 +70,16 @@ defmodule Firebird.BuilderTest do
 
     @tag :tinygo_required
     test "builds to custom output path" do
-      if !@tinygo_available, do: flunk("TinyGo not installed (skippable with --exclude tinygo_required)")
-      output = Path.join(System.tmp_dir!(), "firebird_test_#{:rand.uniform(100000)}.wasm")
+      if !@tinygo_available,
+        do: flunk("TinyGo not installed (skippable with --exclude tinygo_required)")
+
+      output = Path.join(System.tmp_dir!(), "firebird_test_#{:rand.uniform(100_000)}.wasm")
 
-      {:ok, ^output} = Firebird.Builder.build_go(
-        Path.join(@fixtures_dir, "go_math"),
-        output: output
-      )
+      {:ok, ^output} =
+        Firebird.Builder.build_go(
+          Path.join(@fixtures_dir, "go_math"),
+          output: output
+        )
 
       assert File.exists?(output)
       File.rm!(output)
@@ -78,7 +87,9 @@ defmodule Firebird.BuilderTest do
 
     @tag :tinygo_required
     test "builds go_bitwise module" do
-      if !@tinygo_available, do: flunk("TinyGo not installed (skippable with --exclude tinygo_required)")
+      if !@tinygo_available,
+        do: flunk("TinyGo not installed (skippable with --exclude tinygo_required)")
+
       {:ok, wasm_path} = Firebird.Builder.build_go(Path.join(@fixtures_dir, "go_bitwise"))
       assert File.exists?(wasm_path)
     end
@@ -91,7 +102,9 @@ defmodule Firebird.BuilderTest do
   describe "build_and_load/2" do
     @tag :tinygo_required
     test "builds Go and loads with auto WASI" do
-      if !@tinygo_available, do: flunk("TinyGo not installed (skippable with --exclude tinygo_required)")
+      if !@tinygo_available,
+        do: flunk("TinyGo not installed (skippable with --exclude tinygo_required)")
+
       {:ok, instance} = Firebird.Builder.build_and_load(Path.join(@fixtures_dir, "go_math"))
       assert Process.alive?(instance)
       {:ok, [8]} = Firebird.call(instance, :add, [5, 3])
@@ -100,7 +113,9 @@ defmodule Firebird.BuilderTest do
 
     @tag :tinygo_required
     test "builds go_bitwise and loads" do
-      if !@tinygo_available, do: flunk("TinyGo not installed (skippable with --exclude tinygo_required)")
+      if !@tinygo_available,
+        do: flunk("TinyGo not installed (skippable with --exclude tinygo_required)")
+
       {:ok, instance} = Firebird.Builder.build_and_load(Path.join(@fixtures_dir, "go_bitwise"))
       assert Process.alive?(instance)
 
@@ -118,7 +133,7 @@ defmodule Firebird.BuilderTest do
 
       if length(wat_files) > 0 do
         wat_file = hd(wat_files)
-        output = Path.join(System.tmp_dir!(), "firebird_wat_test_#{:rand.uniform(100000)}.wasm")
+        output = Path.join(System.tmp_dir!(), "firebird_wat_test_#{:rand.uniform(100_000)}.wasm")
 
         {:ok, ^output} = Firebird.Builder.build_wat(wat_file, output: output)
         assert File.exists?(output)
@@ -133,7 +148,7 @@ defmodule Firebird.BuilderTest do
 
   describe "scaffold_go/2" do
     test "creates a Go project scaffold" do
-      tmp = Path.join(System.tmp_dir!(), "firebird_scaffold_go_#{:rand.uniform(100000)}")
+      tmp = Path.join(System.tmp_dir!(), "firebird_scaffold_go_#{:rand.uniform(100_000)}")
 
       :ok = Firebird.Builder.scaffold_go(tmp, functions: [:add, :multiply, :power])
 
@@ -152,7 +167,7 @@ defmodule Firebird.BuilderTest do
 
   describe "scaffold_rust/2" do
     test "creates a Rust project scaffold" do
-      tmp = Path.join(System.tmp_dir!(), "firebird_scaffold_rust_#{:rand.uniform(100000)}")
+      tmp = Path.join(System.tmp_dir!(), "firebird_scaffold_rust_#{:rand.uniform(100_000)}")
 
       :ok = Firebird.Builder.scaffold_rust(tmp, functions: [:add, :fib])
 
diff --git a/test/cache_test.exs b/test/cache_test.exs
index 7800300..da0c928 100644
--- a/test/cache_test.exs
+++ b/test/cache_test.exs
@@ -4,7 +4,12 @@ defmodule Firebird.CacheTest do
   @rust_wasm Path.join(__DIR__, "../fixtures/math.wasm")
 
   setup do
-    cache_dir = Path.join(System.tmp_dir!(), "firebird_cache_test_#{:rand.uniform(1_000_000)}_#{System.monotonic_time()}")
+    cache_dir =
+      Path.join(
+        System.tmp_dir!(),
+        "firebird_cache_test_#{:rand.uniform(1_000_000)}_#{System.monotonic_time()}"
+      )
+
     File.rm_rf(cache_dir)
 
     # Clear in-memory cache between tests to ensure isolation
@@ -35,9 +40,10 @@ defmodule Firebird.CacheTest do
       Firebird.stop(inst1)
 
       # Second load - should use ETS precompiled module (no recompilation)
-      {time_us, {:ok, inst2}} = :timer.tc(fn ->
-        Firebird.Cache.load_cached(@rust_wasm, cache_dir: cache_dir)
-      end)
+      {time_us, {:ok, inst2}} =
+        :timer.tc(fn ->
+          Firebird.Cache.load_cached(@rust_wasm, cache_dir: cache_dir)
+        end)
 
       {:ok, [8]} = Firebird.call(inst2, :add, [5, 3])
       Firebird.stop(inst2)
@@ -73,9 +79,10 @@ defmodule Firebird.CacheTest do
       :ok = Firebird.Cache.warm(@rust_wasm, cache_dir: cache_dir)
 
       # After warming, load_cached should be fast (uses ETS)
-      {time_us, {:ok, instance}} = :timer.tc(fn ->
-        Firebird.Cache.load_cached(@rust_wasm, cache_dir: cache_dir)
-      end)
+      {time_us, {:ok, instance}} =
+        :timer.tc(fn ->
+          Firebird.Cache.load_cached(@rust_wasm, cache_dir: cache_dir)
+        end)
 
       {:ok, [8]} = Firebird.call(instance, :add, [5, 3])
       Firebird.stop(instance)
@@ -133,7 +140,8 @@ defmodule Firebird.CacheTest do
     end
 
     test "clear is safe when no cache dir exists" do
-      :ok = Firebird.Cache.clear(cache_dir: "/tmp/nonexistent_cache_dir_#{:rand.uniform(100000)}")
+      :ok =
+        Firebird.Cache.clear(cache_dir: "/tmp/nonexistent_cache_dir_#{:rand.uniform(100_000)}")
     end
   end
 
@@ -189,9 +197,11 @@ defmodule Firebird.CacheTest do
       # Measure cached load time (uses precompiled module from ETS)
       cached_times =
         for _ <- 1..5 do
-          {time, {:ok, pid}} = :timer.tc(fn ->
-            Firebird.Cache.load_cached(@rust_wasm, cache_dir: cache_dir)
-          end)
+          {time, {:ok, pid}} =
+            :timer.tc(fn ->
+              Firebird.Cache.load_cached(@rust_wasm, cache_dir: cache_dir)
+            end)
+
           Firebird.stop(pid)
           time
         end
@@ -202,7 +212,7 @@ defmodule Firebird.CacheTest do
       # Cached should not be significantly slower than cold (and typically faster).
       # Use generous threshold for CI variance.
       assert avg_cached <= avg_cold * 3,
-        "Cached (#{avg_cached}μs) should not be much slower than cold (#{avg_cold}μs)"
+             "Cached (#{avg_cached}μs) should not be much slower than cold (#{avg_cold}μs)"
     end
   end
 end
diff --git a/test/call_many_ordering_test.exs b/test/call_many_ordering_test.exs
index 51b7567..2e5778a 100644
--- a/test/call_many_ordering_test.exs
+++ b/test/call_many_ordering_test.exs
@@ -7,9 +7,11 @@ defmodule Firebird.CallManyOrderingTest do
 
   setup do
     {:ok, wasm} = Firebird.load("fixtures/math.wasm")
+
     on_exit(fn ->
       if Process.alive?(wasm), do: Firebird.stop(wasm)
     end)
+
     %{wasm: wasm}
   end
 
@@ -17,11 +19,16 @@ defmodule Firebird.CallManyOrderingTest do
     test "returns results in the same order as the input calls", %{wasm: wasm} do
       # Use calls with distinct results to verify ordering
       calls = [
-        {:add, [1, 2]},       # => [3]
-        {:add, [10, 20]},     # => [30]
-        {:add, [100, 200]},   # => [300]
-        {:multiply, [3, 7]},  # => [21]
-        {:add, [0, 0]}        # => [0]
+        # => [3]
+        {:add, [1, 2]},
+        # => [30]
+        {:add, [10, 20]},
+        # => [300]
+        {:add, [100, 200]},
+        # => [21]
+        {:multiply, [3, 7]},
+        # => [0]
+        {:add, [0, 0]}
       ]
 
       {:ok, results} = Firebird.Runtime.call_many(wasm, calls)
diff --git a/test/compiler/advanced_patterns_test.exs b/test/compiler/advanced_patterns_test.exs
index 8cf6fe8..605ffb3 100644
--- a/test/compiler/advanced_patterns_test.exs
+++ b/test/compiler/advanced_patterns_test.exs
@@ -212,4 +212,3 @@ defmodule Firebird.Compiler.AdvancedPatternsTest do
     end
   end
 end
-
diff --git a/test/compiler/analyzer_edge_cases_test.exs b/test/compiler/analyzer_edge_cases_test.exs
index 964bc2f..67a9478 100644
--- a/test/compiler/analyzer_edge_cases_test.exs
+++ b/test/compiler/analyzer_edge_cases_test.exs
@@ -78,7 +78,7 @@ defmodule Firebird.Compiler.AnalyzerEdgeCasesTest do
       {:ok, analysis} = Analyzer.analyze_source(source)
       assert length(analysis.functions) == 4
       assert analysis.compilable == true
-      assert Enum.all?(analysis.functions, & &1.estimated_complexity == "O(1)")
+      assert Enum.all?(analysis.functions, &(&1.estimated_complexity == "O(1)"))
       assert Enum.all?(analysis.functions, &(!&1.recursive))
     end
 
@@ -189,7 +189,7 @@ defmodule Firebird.Compiler.AnalyzerEdgeCasesTest do
 
     test "handles syntax error gracefully" do
       assert {:error, {:parse_error, _, _, _}} =
-        Analyzer.analyze_source("defmodule Bad do def foo(")
+               Analyzer.analyze_source("defmodule Bad do def foo(")
     end
 
     test "handles non-module code" do
@@ -305,13 +305,15 @@ defmodule Firebird.Compiler.AnalyzerEdgeCasesTest do
 
     test "function with self-call in non-tail position" do
       # n * factorial(n - 1) — self-call is in operand of mul, not tail position
-      func = make_function(:factorial, 1, [:n],
-        {:if,
-          {:binop, :eq, {:var, :n}, {:literal, 0}},
-          {:literal, 1},
-          {:binop, :mul, {:var, :n},
-            {:call, :factorial, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}
-        })
+      func =
+        make_function(
+          :factorial,
+          1,
+          [:n],
+          {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:literal, 1},
+           {:binop, :mul, {:var, :n},
+            {:call, :factorial, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}}
+        )
 
       analysis = Analyzer.analyze_function(func)
       assert analysis.recursive == true
@@ -320,12 +322,14 @@ defmodule Firebird.Compiler.AnalyzerEdgeCasesTest do
     end
 
     test "function with self-call in tail position" do
-      func = make_function(:count_down, 1, [:n],
-        {:if,
-          {:binop, :eq, {:var, :n}, {:literal, 0}},
-          {:literal, 0},
-          {:call, :count_down, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}
-        })
+      func =
+        make_function(
+          :count_down,
+          1,
+          [:n],
+          {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:literal, 0},
+           {:call, :count_down, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}
+        )
 
       analysis = Analyzer.analyze_function(func)
       assert analysis.recursive == true
@@ -335,14 +339,15 @@ defmodule Firebird.Compiler.AnalyzerEdgeCasesTest do
 
     test "function with double recursion detects exponential complexity" do
       # fib(n) = fib(n-1) + fib(n-2)
-      func = make_function(:fib, 1, [:n],
-        {:if,
-          {:binop, :le_s, {:var, :n}, {:literal, 1}},
-          {:var, :n},
-          {:binop, :add,
-            {:call, :fib, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
-            {:call, :fib, [{:binop, :sub, {:var, :n}, {:literal, 2}}]}}
-        })
+      func =
+        make_function(
+          :fib,
+          1,
+          [:n],
+          {:if, {:binop, :le_s, {:var, :n}, {:literal, 1}}, {:var, :n},
+           {:binop, :add, {:call, :fib, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
+            {:call, :fib, [{:binop, :sub, {:var, :n}, {:literal, 2}}]}}}
+        )
 
       analysis = Analyzer.analyze_function(func)
       assert analysis.recursive == true
@@ -366,42 +371,65 @@ defmodule Firebird.Compiler.AnalyzerEdgeCasesTest do
     end
 
     test "function calling other functions (not self)" do
-      func = make_function(:wrapper, 1, [:n],
-        {:call, :helper, [{:binop, :add, {:var, :n}, {:literal, 1}}]})
+      func =
+        make_function(
+          :wrapper,
+          1,
+          [:n],
+          {:call, :helper, [{:binop, :add, {:var, :n}, {:literal, 1}}]}
+        )
+
       analysis = Analyzer.analyze_function(func)
       assert analysis.recursive == false
       assert analysis.estimated_complexity == "O(1)"
     end
 
     test "function with block body" do
-      func = make_function(:block_fn, 1, [:n],
-        {:block, [
-          {:let, :x, {:binop, :mul, {:var, :n}, {:literal, 2}}},
-          {:binop, :add, {:var, :x}, {:literal, 1}}
-        ]})
+      func =
+        make_function(
+          :block_fn,
+          1,
+          [:n],
+          {:block,
+           [
+             {:let, :x, {:binop, :mul, {:var, :n}, {:literal, 2}}},
+             {:binop, :add, {:var, :x}, {:literal, 1}}
+           ]}
+        )
+
       analysis = Analyzer.analyze_function(func)
       assert analysis.compilable == true
       assert analysis.recursive == false
     end
 
     test "function with case body" do
-      func = make_function(:sign, 1, [:n],
-        {:case, {:var, :n}, [
-          {{:literal_pat, 0}, nil, {:literal, 0}},
-          {:wildcard, nil, {:if,
-            {:binop, :gt_s, {:var, :n}, {:literal, 0}},
-            {:literal, 1},
-            {:literal, -1}
-          }}
-        ]})
+      func =
+        make_function(
+          :sign,
+          1,
+          [:n],
+          {:case, {:var, :n},
+           [
+             {{:literal_pat, 0}, nil, {:literal, 0}},
+             {:wildcard, nil,
+              {:if, {:binop, :gt_s, {:var, :n}, {:literal, 0}}, {:literal, 1}, {:literal, -1}}}
+           ]}
+        )
+
       analysis = Analyzer.analyze_function(func)
       assert analysis.compilable == true
       assert analysis.recursive == false
     end
 
     test "function with unaryop" do
-      func = make_function(:is_positive, 1, [:n],
-        {:unaryop, :not, {:binop, :le_s, {:var, :n}, {:literal, 0}}})
+      func =
+        make_function(
+          :is_positive,
+          1,
+          [:n],
+          {:unaryop, :not, {:binop, :le_s, {:var, :n}, {:literal, 0}}}
+        )
+
       analysis = Analyzer.analyze_function(func)
       assert analysis.compilable == true
     end
@@ -410,12 +438,11 @@ defmodule Firebird.Compiler.AnalyzerEdgeCasesTest do
   describe "analyze_file/1 edge cases" do
     test "returns error for non-existent file" do
       assert {:error, {:file_error, :enoent, _}} =
-        Analyzer.analyze_file("/nonexistent/path/module.ex")
+               Analyzer.analyze_file("/nonexistent/path/module.ex")
     end
 
     test "returns error for directory path" do
-      assert {:error, {:file_error, :eisdir, _}} =
-        Analyzer.analyze_file("/tmp")
+      assert {:error, {:file_error, :eisdir, _}} = Analyzer.analyze_file("/tmp")
     end
 
     test "analyzes real wasm_modules/math.ex" do
@@ -431,46 +458,51 @@ defmodule Firebird.Compiler.AnalyzerEdgeCasesTest do
       assert length(analysis.functions) > 0
       # Check that it detects recursion in algorithms
       recursive_fns = Enum.filter(analysis.functions, & &1.recursive)
-      assert length(recursive_fns) >= 0  # May or may not have recursive functions
+      # May or may not have recursive functions
+      assert length(recursive_fns) >= 0
     end
   end
 
   describe "complexity estimation edge cases" do
     test "single self-call is linear, not exponential" do
-      func = make_function(:linear_rec, 1, [:n],
-        {:if,
-          {:binop, :eq, {:var, :n}, {:literal, 0}},
-          {:literal, 0},
-          {:binop, :add,
-            {:literal, 1},
-            {:call, :linear_rec, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}
-        })
+      func =
+        make_function(
+          :linear_rec,
+          1,
+          [:n],
+          {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:literal, 0},
+           {:binop, :add, {:literal, 1},
+            {:call, :linear_rec, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}}
+        )
 
       analysis = Analyzer.analyze_function(func)
       assert analysis.estimated_complexity == "O(n) linear"
     end
 
     test "two self-calls in same expression is exponential" do
-      func = make_function(:double_rec, 1, [:n],
-        {:if,
-          {:binop, :le_s, {:var, :n}, {:literal, 0}},
-          {:literal, 1},
-          {:binop, :add,
-            {:call, :double_rec, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
-            {:call, :double_rec, [{:binop, :sub, {:var, :n}, {:literal, 2}}]}}
-        })
+      func =
+        make_function(
+          :double_rec,
+          1,
+          [:n],
+          {:if, {:binop, :le_s, {:var, :n}, {:literal, 0}}, {:literal, 1},
+           {:binop, :add, {:call, :double_rec, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
+            {:call, :double_rec, [{:binop, :sub, {:var, :n}, {:literal, 2}}]}}}
+        )
 
       analysis = Analyzer.analyze_function(func)
       assert analysis.estimated_complexity == "O(2^n) exponential"
     end
 
     test "self-call only in one branch of if still counts as recursive" do
-      func = make_function(:conditional_rec, 1, [:n],
-        {:if,
-          {:binop, :gt_s, {:var, :n}, {:literal, 0}},
-          {:call, :conditional_rec, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
-          {:literal, 0}
-        })
+      func =
+        make_function(
+          :conditional_rec,
+          1,
+          [:n],
+          {:if, {:binop, :gt_s, {:var, :n}, {:literal, 0}},
+           {:call, :conditional_rec, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}, {:literal, 0}}
+        )
 
       analysis = Analyzer.analyze_function(func)
       assert analysis.recursive == true
@@ -486,13 +518,16 @@ defmodule Firebird.Compiler.AnalyzerEdgeCasesTest do
     end
 
     test "accumulator suggestion includes function names" do
-      func = make_function(:factorial, 1, [:n],
-        {:if,
-          {:binop, :eq, {:var, :n}, {:literal, 0}},
-          {:literal, 1},
-          {:binop, :mul, {:var, :n},
-            {:call, :factorial, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}
-        })
+      func =
+        make_function(
+          :factorial,
+          1,
+          [:n],
+          {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:literal, 1},
+           {:binop, :mul, {:var, :n},
+            {:call, :factorial, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}}
+        )
+
       module = make_module(:Test, [func])
 
       analysis = Analyzer.analyze_module(module)
@@ -502,19 +537,25 @@ defmodule Firebird.Compiler.AnalyzerEdgeCasesTest do
     end
 
     test "TCO suggestion for multiple tail-recursive functions" do
-      f1 = make_function(:count, 1, [:n],
-        {:if,
-          {:binop, :eq, {:var, :n}, {:literal, 0}},
-          {:literal, 0},
-          {:call, :count, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}
-        })
-      f2 = make_function(:sum_to, 2, [:n, :acc],
-        {:if,
-          {:binop, :eq, {:var, :n}, {:literal, 0}},
-          {:var, :acc},
-          {:call, :sum_to, [{:binop, :sub, {:var, :n}, {:literal, 1}},
-                            {:binop, :add, {:var, :acc}, {:var, :n}}]}
-        })
+      f1 =
+        make_function(
+          :count,
+          1,
+          [:n],
+          {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:literal, 0},
+           {:call, :count, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}
+        )
+
+      f2 =
+        make_function(
+          :sum_to,
+          2,
+          [:n, :acc],
+          {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:var, :acc},
+           {:call, :sum_to,
+            [{:binop, :sub, {:var, :n}, {:literal, 1}}, {:binop, :add, {:var, :acc}, {:var, :n}}]}}
+        )
+
       module = make_module(:Test, [f1, f2])
 
       analysis = Analyzer.analyze_module(module)
@@ -522,12 +563,15 @@ defmodule Firebird.Compiler.AnalyzerEdgeCasesTest do
     end
 
     test "no accumulator suggestion when all recursive functions are tail-recursive" do
-      func = make_function(:count, 1, [:n],
-        {:if,
-          {:binop, :eq, {:var, :n}, {:literal, 0}},
-          {:literal, 0},
-          {:call, :count, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}
-        })
+      func =
+        make_function(
+          :count,
+          1,
+          [:n],
+          {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:literal, 0},
+           {:call, :count, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}
+        )
+
       module = make_module(:Test, [func])
 
       analysis = Analyzer.analyze_module(module)
@@ -535,13 +579,16 @@ defmodule Firebird.Compiler.AnalyzerEdgeCasesTest do
     end
 
     test "no TCO suggestion when no tail-recursive functions" do
-      func = make_function(:factorial, 1, [:n],
-        {:if,
-          {:binop, :eq, {:var, :n}, {:literal, 0}},
-          {:literal, 1},
-          {:binop, :mul, {:var, :n},
-            {:call, :factorial, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}
-        })
+      func =
+        make_function(
+          :factorial,
+          1,
+          [:n],
+          {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:literal, 1},
+           {:binop, :mul, {:var, :n},
+            {:call, :factorial, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}}
+        )
+
       module = make_module(:Test, [func])
 
       analysis = Analyzer.analyze_module(module)
@@ -552,8 +599,7 @@ defmodule Firebird.Compiler.AnalyzerEdgeCasesTest do
   describe "compilability with various IR nodes" do
     test "all arithmetic ops are compilable" do
       for op <- [:add, :sub, :mul, :div_s, :rem_s] do
-        func = make_function(:"test_#{op}", 2, [:a, :b],
-          {:binop, op, {:var, :a}, {:var, :b}})
+        func = make_function(:"test_#{op}", 2, [:a, :b], {:binop, op, {:var, :a}, {:var, :b}})
         analysis = Analyzer.analyze_function(func)
         assert analysis.compilable == true, "Expected #{op} to be compilable"
       end
@@ -561,8 +607,7 @@ defmodule Firebird.Compiler.AnalyzerEdgeCasesTest do
 
     test "all comparison ops are compilable" do
       for op <- [:eq, :ne, :lt_s, :gt_s, :le_s, :ge_s] do
-        func = make_function(:"test_#{op}", 2, [:a, :b],
-          {:binop, op, {:var, :a}, {:var, :b}})
+        func = make_function(:"test_#{op}", 2, [:a, :b], {:binop, op, {:var, :a}, {:var, :b}})
         analysis = Analyzer.analyze_function(func)
         assert analysis.compilable == true, "Expected #{op} to be compilable"
       end
@@ -570,8 +615,7 @@ defmodule Firebird.Compiler.AnalyzerEdgeCasesTest do
 
     test "boolean ops are compilable" do
       for op <- [:and_, :or_] do
-        func = make_function(:"test_#{op}", 2, [:a, :b],
-          {:binop, op, {:var, :a}, {:var, :b}})
+        func = make_function(:"test_#{op}", 2, [:a, :b], {:binop, op, {:var, :a}, {:var, :b}})
         analysis = Analyzer.analyze_function(func)
         assert analysis.compilable == true, "Expected #{op} to be compilable"
       end
@@ -579,8 +623,7 @@ defmodule Firebird.Compiler.AnalyzerEdgeCasesTest do
 
     test "shift ops are compilable" do
       for op <- [:shl, :shr_s] do
-        func = make_function(:"test_#{op}", 2, [:a, :b],
-          {:binop, op, {:var, :a}, {:var, :b}})
+        func = make_function(:"test_#{op}", 2, [:a, :b], {:binop, op, {:var, :a}, {:var, :b}})
         analysis = Analyzer.analyze_function(func)
         assert analysis.compilable == true, "Expected #{op} to be compilable"
       end
@@ -599,38 +642,49 @@ defmodule Firebird.Compiler.AnalyzerEdgeCasesTest do
     end
 
     test "if expression is compilable" do
-      func = make_function(:test_if, 1, [:n],
-        {:if, {:binop, :gt_s, {:var, :n}, {:literal, 0}}, {:literal, 1}, {:literal, 0}})
+      func =
+        make_function(
+          :test_if,
+          1,
+          [:n],
+          {:if, {:binop, :gt_s, {:var, :n}, {:literal, 0}}, {:literal, 1}, {:literal, 0}}
+        )
+
       analysis = Analyzer.analyze_function(func)
       assert analysis.compilable == true
     end
 
     test "let expression is compilable" do
-      func = make_function(:test_let, 1, [:n],
-        {:let, :x, {:binop, :add, {:var, :n}, {:literal, 1}}})
+      func =
+        make_function(:test_let, 1, [:n], {:let, :x, {:binop, :add, {:var, :n}, {:literal, 1}}})
+
       analysis = Analyzer.analyze_function(func)
       assert analysis.compilable == true
     end
 
     test "block expression is compilable" do
-      func = make_function(:test_block, 1, [:n],
-        {:block, [{:let, :x, {:literal, 1}}, {:var, :x}]})
+      func =
+        make_function(:test_block, 1, [:n], {:block, [{:let, :x, {:literal, 1}}, {:var, :x}]})
+
       analysis = Analyzer.analyze_function(func)
       assert analysis.compilable == true
     end
 
     test "tail_loop and tail_call are compilable" do
-      func = make_function(:test_tco, 2, [:n, :acc],
-        {:tail_loop, [:n, :acc],
-          {:if,
-            {:binop, :eq, {:var, :n}, {:literal, 0}},
-            {:var, :acc},
-            {:tail_call, :test_tco, [
-              {:binop, :sub, {:var, :n}, {:literal, 1}},
-              {:binop, :add, {:var, :acc}, {:var, :n}}
-            ]}
-          }
-        })
+      func =
+        make_function(
+          :test_tco,
+          2,
+          [:n, :acc],
+          {:tail_loop, [:n, :acc],
+           {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:var, :acc},
+            {:tail_call, :test_tco,
+             [
+               {:binop, :sub, {:var, :n}, {:literal, 1}},
+               {:binop, :add, {:var, :acc}, {:var, :n}}
+             ]}}}
+        )
+
       analysis = Analyzer.analyze_function(func)
       assert analysis.compilable == true
     end
@@ -654,18 +708,24 @@ defmodule Firebird.Compiler.AnalyzerEdgeCasesTest do
     end
 
     test "function call is compilable" do
-      func = make_function(:test_call, 1, [:n],
-        {:call, :other_fn, [{:var, :n}]})
+      func = make_function(:test_call, 1, [:n], {:call, :other_fn, [{:var, :n}]})
       analysis = Analyzer.analyze_function(func)
       assert analysis.compilable == true
     end
 
     test "case expression is compilable" do
-      func = make_function(:test_case, 1, [:n],
-        {:case, {:var, :n}, [
-          {{:literal_pat, 0}, nil, {:literal, 1}},
-          {:wildcard, nil, {:literal, 0}}
-        ]})
+      func =
+        make_function(
+          :test_case,
+          1,
+          [:n],
+          {:case, {:var, :n},
+           [
+             {{:literal_pat, 0}, nil, {:literal, 1}},
+             {:wildcard, nil, {:literal, 0}}
+           ]}
+        )
+
       analysis = Analyzer.analyze_function(func)
       assert analysis.compilable == true
     end
diff --git a/test/compiler/bitwise_ops_test.exs b/test/compiler/bitwise_ops_test.exs
index 1e5d92d..ee50312 100644
--- a/test/compiler/bitwise_ops_test.exs
+++ b/test/compiler/bitwise_ops_test.exs
@@ -15,6 +15,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def mask(x), do: band(x, 0xFF)
       end
       """
+
       {:ok, ast} = Compiler.parse(source)
       {:ok, ir} = IRGen.generate(ast)
       func = hd(ir.functions)
@@ -28,6 +29,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def set_bit(x), do: bor(x, 1)
       end
       """
+
       {:ok, ast} = Compiler.parse(source)
       {:ok, ir} = IRGen.generate(ast)
       func = hd(ir.functions)
@@ -41,6 +43,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def toggle(x), do: bxor(x, 1)
       end
       """
+
       {:ok, ast} = Compiler.parse(source)
       {:ok, ir} = IRGen.generate(ast)
       func = hd(ir.functions)
@@ -54,6 +57,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def shift_left(x), do: bsl(x, 4)
       end
       """
+
       {:ok, ast} = Compiler.parse(source)
       {:ok, ir} = IRGen.generate(ast)
       func = hd(ir.functions)
@@ -67,6 +71,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def shift_right(x), do: bsr(x, 4)
       end
       """
+
       {:ok, ast} = Compiler.parse(source)
       {:ok, ir} = IRGen.generate(ast)
       func = hd(ir.functions)
@@ -80,6 +85,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def invert(x), do: bnot(x)
       end
       """
+
       {:ok, ast} = Compiler.parse(source)
       {:ok, ir} = IRGen.generate(ast)
       func = hd(ir.functions)
@@ -97,6 +103,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def mask(x), do: Bitwise.band(x, 0xFF)
       end
       """
+
       {:ok, ast} = Compiler.parse(source)
       {:ok, ir} = IRGen.generate(ast)
       func = hd(ir.functions)
@@ -110,6 +117,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def flag(x), do: Bitwise.bor(x, 8)
       end
       """
+
       {:ok, ast} = Compiler.parse(source)
       {:ok, ir} = IRGen.generate(ast)
       func = hd(ir.functions)
@@ -123,6 +131,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def flip(x), do: Bitwise.bxor(x, 42)
       end
       """
+
       {:ok, ast} = Compiler.parse(source)
       {:ok, ir} = IRGen.generate(ast)
       func = hd(ir.functions)
@@ -136,6 +145,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def shl(x), do: Bitwise.bsl(x, 3)
       end
       """
+
       {:ok, ast} = Compiler.parse(source)
       {:ok, ir} = IRGen.generate(ast)
       func = hd(ir.functions)
@@ -149,6 +159,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def shr(x), do: Bitwise.bsr(x, 3)
       end
       """
+
       {:ok, ast} = Compiler.parse(source)
       {:ok, ir} = IRGen.generate(ast)
       func = hd(ir.functions)
@@ -162,6 +173,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def inv(x), do: Bitwise.bnot(x)
       end
       """
+
       {:ok, ast} = Compiler.parse(source)
       {:ok, ir} = IRGen.generate(ast)
       func = hd(ir.functions)
@@ -268,6 +280,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def mask(x), do: band(x, 255)
       end
       """
+
       {:ok, wat} = Pipeline.run_to(:wat, source)
       assert wat =~ "i64.and"
     end
@@ -279,6 +292,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def set_flag(x), do: bor(x, 8)
       end
       """
+
       {:ok, wat} = Pipeline.run_to(:wat, source)
       assert wat =~ "i64.or"
     end
@@ -290,6 +304,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def toggle(x), do: bxor(x, 42)
       end
       """
+
       {:ok, wat} = Pipeline.run_to(:wat, source)
       assert wat =~ "i64.xor"
     end
@@ -301,6 +316,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def shift(x), do: bsl(x, 4)
       end
       """
+
       {:ok, wat} = Pipeline.run_to(:wat, source)
       assert wat =~ "i64.shl"
     end
@@ -312,6 +328,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def shift(x), do: bsr(x, 4)
       end
       """
+
       {:ok, wat} = Pipeline.run_to(:wat, source)
       assert wat =~ "i64.shr_s"
     end
@@ -323,6 +340,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def invert(x), do: bnot(x)
       end
       """
+
       {:ok, wat} = Pipeline.run_to(:wat, source)
       assert wat =~ "i64.const -1"
       assert wat =~ "i64.xor"
@@ -340,6 +358,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def mask(x), do: band(x, 255)
       end
       """
+
       case Compiler.compile_source(source) do
         {:ok, %{wasm: wasm}} when is_binary(wasm) ->
           # WASM magic number
@@ -370,6 +389,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def toggle_bit(value, bit), do: bxor(value, bsl(1, bit))
       end
       """
+
       case Compiler.compile_source(source) do
         {:ok, %{wasm: wasm, wat: wat}} when is_binary(wasm) ->
           assert <<0x00, 0x61, 0x73, 0x6D, _rest::binary>> = wasm
@@ -396,6 +416,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def hash_step(h, k), do: Bitwise.bxor(h, Bitwise.bsl(k, 5))
       end
       """
+
       case Compiler.compile_source(source) do
         {:ok, %{wasm: wasm}} when is_binary(wasm) ->
           assert <<0x00, 0x61, 0x73, 0x6D, _rest::binary>> = wasm
@@ -419,6 +440,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def constant_mask(), do: band(255, 15)
       end
       """
+
       {:ok, ir} = Pipeline.run_to(:optimize, source, optimize: true)
       func = hd(ir.functions)
       # Should fold to literal 15
@@ -432,6 +454,7 @@ defmodule Firebird.Compiler.BitwiseOpsTest do
         def noop(x), do: band(x, -1)
       end
       """
+
       {:ok, ir} = Pipeline.run_to(:optimize, source, optimize: true)
       func = hd(ir.functions)
       # Should simplify to just the variable
diff --git a/test/compiler/br_table_test.exs b/test/compiler/br_table_test.exs
index 370cd99..6b2bcf9 100644
--- a/test/compiler/br_table_test.exs
+++ b/test/compiler/br_table_test.exs
@@ -116,11 +116,14 @@ defmodule Firebird.Compiler.BrTableTest do
       {:ok, instance} = Firebird.load(result.wasm)
 
       assert {:ok, [100]} = Firebird.call(instance, "sparse", [0])
-      assert {:ok, [0]}   = Firebird.call(instance, "sparse", [1])  # gap → default
+      # gap → default
+      assert {:ok, [0]} = Firebird.call(instance, "sparse", [1])
       assert {:ok, [200]} = Firebird.call(instance, "sparse", [2])
-      assert {:ok, [0]}   = Firebird.call(instance, "sparse", [3])  # gap → default
+      # gap → default
+      assert {:ok, [0]} = Firebird.call(instance, "sparse", [3])
       assert {:ok, [300]} = Firebird.call(instance, "sparse", [4])
-      assert {:ok, [0]}   = Firebird.call(instance, "sparse", [10]) # out of range → default
+      # out of range → default
+      assert {:ok, [0]} = Firebird.call(instance, "sparse", [10])
 
       Firebird.stop(instance)
     end
@@ -139,6 +142,7 @@ defmodule Firebird.Compiler.BrTableTest do
       """
 
       {:ok, result} = Compiler.compile_source(source, optimize: true, wat_only: true)
+
       assert String.contains?(result.wat, "br_table"),
              "Expected br_table for 3-clause multi-clause function"
     end
@@ -157,11 +161,13 @@ defmodule Firebird.Compiler.BrTableTest do
       {:ok, result} = Compiler.compile_source(source, optimize: true)
       {:ok, instance} = Firebird.load(result.wasm)
 
-      assert {:ok, [0]}  = Firebird.call(instance, "score", [0])
+      assert {:ok, [0]} = Firebird.call(instance, "score", [0])
       assert {:ok, [10]} = Firebird.call(instance, "score", [1])
       assert {:ok, [25]} = Firebird.call(instance, "score", [2])
-      assert {:ok, [15]} = Firebird.call(instance, "score", [3])  # 3 * 5
-      assert {:ok, [50]} = Firebird.call(instance, "score", [10]) # 10 * 5
+      # 3 * 5
+      assert {:ok, [15]} = Firebird.call(instance, "score", [3])
+      # 10 * 5
+      assert {:ok, [50]} = Firebird.call(instance, "score", [10])
 
       Firebird.stop(instance)
     end
@@ -177,6 +183,7 @@ defmodule Firebird.Compiler.BrTableTest do
       """
 
       {:ok, result} = Compiler.compile_source(source, optimize: true, wat_only: true)
+
       refute String.contains?(result.wat, "br_table"),
              "2-literal-clause function should NOT use br_table"
     end
diff --git a/test/compiler/combiner_edge_cases_test.exs b/test/compiler/combiner_edge_cases_test.exs
index 02a0503..017eee6 100644
--- a/test/compiler/combiner_edge_cases_test.exs
+++ b/test/compiler/combiner_edge_cases_test.exs
@@ -3,7 +3,10 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
 
   alias Firebird.Compiler.Combiner
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_combiner_edge_test_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_combiner_edge_test_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -44,12 +47,13 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
     end
 
     test "returns error if one file is bad and others are good", %{tmp: tmp} do
-      good = write_source(tmp, "good.ex", """
-      defmodule CombGood do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      good =
+        write_source(tmp, "good.ex", """
+        defmodule CombGood do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
       bad = write_source(tmp, "bad.ex", "invalid (( code")
 
@@ -60,15 +64,16 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
 
   describe "combine/2 with optimization flags" do
     test "combines with optimize: true", %{tmp: tmp} do
-      a = write_source(tmp, "a.ex", """
-      defmodule CombOptA do
-        @wasm true
-        def add(a, b), do: a + b
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule CombOptA do
+          @wasm true
+          def add(a, b), do: a + b
 
-        @wasm true
-        def double(a), do: a + a
-      end
-      """)
+          @wasm true
+          def double(a), do: a + a
+        end
+        """)
 
       {:ok, result} = Combiner.combine([a], optimize: true)
       assert is_binary(result.wasm)
@@ -80,13 +85,14 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
     end
 
     test "combines with tco: true", %{tmp: tmp} do
-      a = write_source(tmp, "a.ex", """
-      defmodule CombTcoA do
-        @wasm true
-        def sum_acc(0, acc), do: acc
-        def sum_acc(n, acc), do: sum_acc(n - 1, acc + n)
-      end
-      """)
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule CombTcoA do
+          @wasm true
+          def sum_acc(0, acc), do: acc
+          def sum_acc(n, acc), do: sum_acc(n - 1, acc + n)
+        end
+        """)
 
       {:ok, result} = Combiner.combine([a], tco: true)
       assert is_binary(result.wasm)
@@ -97,15 +103,16 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
     end
 
     test "combines with inline: true", %{tmp: tmp} do
-      a = write_source(tmp, "a.ex", """
-      defmodule CombInlineA do
-        @wasm true
-        def double(a), do: a * 2
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule CombInlineA do
+          @wasm true
+          def double(a), do: a * 2
 
-        @wasm true
-        def quad(a), do: double(double(a))
-      end
-      """)
+          @wasm true
+          def quad(a), do: double(double(a))
+        end
+        """)
 
       {:ok, result} = Combiner.combine([a], inline: true)
       assert is_binary(result.wasm)
@@ -116,12 +123,13 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
     end
 
     test "combines with all optimization flags", %{tmp: tmp} do
-      a = write_source(tmp, "a.ex", """
-      defmodule CombAllOpts do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule CombAllOpts do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
       {:ok, result} = Combiner.combine([a], optimize: true, tco: true, inline: true)
       assert is_binary(result.wasm)
@@ -130,26 +138,29 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
 
   describe "combine/2 with multiple modules" do
     test "three modules combined", %{tmp: tmp} do
-      a = write_source(tmp, "a.ex", """
-      defmodule CombTriA do
-        @wasm true
-        def inc(a), do: a + 1
-      end
-      """)
-
-      b = write_source(tmp, "b.ex", """
-      defmodule CombTriB do
-        @wasm true
-        def dec(a), do: a - 1
-      end
-      """)
-
-      c = write_source(tmp, "c.ex", """
-      defmodule CombTriC do
-        @wasm true
-        def dbl(a), do: a * 2
-      end
-      """)
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule CombTriA do
+          @wasm true
+          def inc(a), do: a + 1
+        end
+        """)
+
+      b =
+        write_source(tmp, "b.ex", """
+        defmodule CombTriB do
+          @wasm true
+          def dec(a), do: a - 1
+        end
+        """)
+
+      c =
+        write_source(tmp, "c.ex", """
+        defmodule CombTriC do
+          @wasm true
+          def dbl(a), do: a * 2
+        end
+        """)
 
       {:ok, result} = Combiner.combine([a, b, c])
       assert is_binary(result.wasm)
@@ -162,22 +173,24 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
     end
 
     test "exports list contains all functions", %{tmp: tmp} do
-      a = write_source(tmp, "a.ex", """
-      defmodule CombExpA do
-        @wasm true
-        def f1(a), do: a + 1
-
-        @wasm true
-        def f2(a), do: a + 2
-      end
-      """)
-
-      b = write_source(tmp, "b.ex", """
-      defmodule CombExpB do
-        @wasm true
-        def f3(a), do: a * 2
-      end
-      """)
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule CombExpA do
+          @wasm true
+          def f1(a), do: a + 1
+
+          @wasm true
+          def f2(a), do: a + 2
+        end
+        """)
+
+      b =
+        write_source(tmp, "b.ex", """
+        defmodule CombExpB do
+          @wasm true
+          def f3(a), do: a * 2
+        end
+        """)
 
       {:ok, result} = Combiner.combine([a, b])
       assert :f1 in result.exports
@@ -189,19 +202,21 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
 
   describe "combine/2 with prefix" do
     test "prefix avoids name collision for same function names", %{tmp: tmp} do
-      a = write_source(tmp, "a.ex", """
-      defmodule CombPfxColA do
-        @wasm true
-        def compute(a), do: a + 100
-      end
-      """)
-
-      b = write_source(tmp, "b.ex", """
-      defmodule CombPfxColB do
-        @wasm true
-        def compute(a), do: a * 100
-      end
-      """)
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule CombPfxColA do
+          @wasm true
+          def compute(a), do: a + 100
+        end
+        """)
+
+      b =
+        write_source(tmp, "b.ex", """
+        defmodule CombPfxColB do
+          @wasm true
+          def compute(a), do: a * 100
+        end
+        """)
 
       {:ok, result} = Combiner.combine([a, b], prefix: true)
       assert is_binary(result.wasm)
@@ -213,12 +228,13 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
     end
 
     test "prefix uses last segment of nested module name", %{tmp: tmp} do
-      a = write_source(tmp, "a.ex", """
-      defmodule My.Deep.Nested.ModA do
-        @wasm true
-        def val(a), do: a + 1
-      end
-      """)
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule My.Deep.Nested.ModA do
+          @wasm true
+          def val(a), do: a + 1
+        end
+        """)
 
       {:ok, result} = Combiner.combine([a], prefix: true)
       assert is_binary(result.wasm)
@@ -231,12 +247,13 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
 
   describe "combine/2 output options" do
     test "wat_only skips WASM binary generation", %{tmp: tmp} do
-      a = write_source(tmp, "a.ex", """
-      defmodule CombWatOnlyEdge do
-        @wasm true
-        def id(a), do: a
-      end
-      """)
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule CombWatOnlyEdge do
+          @wasm true
+          def id(a), do: a
+        end
+        """)
 
       {:ok, result} = Combiner.combine([a], wat_only: true)
       assert is_binary(result.wat)
@@ -248,12 +265,13 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
     test "output_dir creates directory if needed", %{tmp: tmp} do
       out = Path.join(tmp, "nested/deep/out")
 
-      a = write_source(tmp, "a.ex", """
-      defmodule CombDirEdge do
-        @wasm true
-        def id(a), do: a
-      end
-      """)
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule CombDirEdge do
+          @wasm true
+          def id(a), do: a
+        end
+        """)
 
       {:ok, _} = Combiner.combine([a], output_dir: out, name: "DirTest")
       assert File.exists?(Path.join(out, "DirTest.wat"))
@@ -263,12 +281,13 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
     test "output_dir with wat_only only writes .wat", %{tmp: tmp} do
       out = Path.join(tmp, "wat_out")
 
-      a = write_source(tmp, "a.ex", """
-      defmodule CombWatDirEdge do
-        @wasm true
-        def id(a), do: a
-      end
-      """)
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule CombWatDirEdge do
+          @wasm true
+          def id(a), do: a
+        end
+        """)
 
       {:ok, _} = Combiner.combine([a], output_dir: out, name: "WatDir", wat_only: true)
       assert File.exists?(Path.join(out, "WatDir.wat"))
@@ -278,12 +297,14 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
 
   describe "combine_sources/2 edge cases" do
     test "single source string" do
-      sources = ["""
-      defmodule CombSrcSingle do
-        @wasm true
-        def id(a), do: a
-      end
-      """]
+      sources = [
+        """
+        defmodule CombSrcSingle do
+          @wasm true
+          def id(a), do: a
+        end
+        """
+      ]
 
       {:ok, result} = Combiner.combine_sources(sources)
       {:ok, inst} = Firebird.load(result.wasm)
@@ -297,18 +318,20 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
     end
 
     test "source with multiple functions" do
-      sources = ["""
-      defmodule CombSrcMultiFn do
-        @wasm true
-        def add(a, b), do: a + b
+      sources = [
+        """
+        defmodule CombSrcMultiFn do
+          @wasm true
+          def add(a, b), do: a + b
 
-        @wasm true
-        def sub(a, b), do: a - b
+          @wasm true
+          def sub(a, b), do: a - b
 
-        @wasm true
-        def mul(a, b), do: a * b
-      end
-      """]
+          @wasm true
+          def mul(a, b), do: a * b
+        end
+        """
+      ]
 
       {:ok, result} = Combiner.combine_sources(sources)
       {:ok, inst} = Firebird.load(result.wasm)
@@ -347,24 +370,28 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
     end
 
     test "combine_sources with custom name" do
-      sources = ["""
-      defmodule CombSrcNamed do
-        @wasm true
-        def id(a), do: a
-      end
-      """]
+      sources = [
+        """
+        defmodule CombSrcNamed do
+          @wasm true
+          def id(a), do: a
+        end
+        """
+      ]
 
       {:ok, result} = Combiner.combine_sources(sources, name: "CustomName")
       assert result.module == :CustomName
     end
 
     test "combine_sources with wat_only" do
-      sources = ["""
-      defmodule CombSrcWatOnly do
-        @wasm true
-        def id(a), do: a
-      end
-      """]
+      sources = [
+        """
+        defmodule CombSrcWatOnly do
+          @wasm true
+          def id(a), do: a
+        end
+        """
+      ]
 
       {:ok, result} = Combiner.combine_sources(sources, wat_only: true)
       assert is_binary(result.wat)
@@ -374,13 +401,14 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
 
   describe "combine/2 with modules having pattern matching" do
     test "modules with multi-clause functions", %{tmp: tmp} do
-      a = write_source(tmp, "a.ex", """
-      defmodule CombPatA do
-        @wasm true
-        def factorial(0), do: 1
-        def factorial(n), do: n * factorial(n - 1)
-      end
-      """)
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule CombPatA do
+          @wasm true
+          def factorial(0), do: 1
+          def factorial(n), do: n * factorial(n - 1)
+        end
+        """)
 
       {:ok, result} = Combiner.combine([a])
       {:ok, inst} = Firebird.load(result.wasm)
@@ -390,13 +418,14 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
     end
 
     test "combined modules with guards", %{tmp: tmp} do
-      a = write_source(tmp, "a.ex", """
-      defmodule CombGuardA do
-        @wasm true
-        def abs_val(n) when n < 0, do: 0 - n
-        def abs_val(n), do: n
-      end
-      """)
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule CombGuardA do
+          @wasm true
+          def abs_val(n) when n < 0, do: 0 - n
+          def abs_val(n), do: n
+        end
+        """)
 
       {:ok, result} = Combiner.combine([a])
       {:ok, inst} = Firebird.load(result.wasm)
@@ -409,14 +438,15 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
 
   describe "combine/2 with conditional logic" do
     test "modules with if/else", %{tmp: tmp} do
-      a = write_source(tmp, "a.ex", """
-      defmodule CombIfA do
-        @wasm true
-        def max_val(a, b) do
-          if a > b, do: a, else: b
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule CombIfA do
+          @wasm true
+          def max_val(a, b) do
+            if a > b, do: a, else: b
+          end
         end
-      end
-      """)
+        """)
 
       {:ok, result} = Combiner.combine([a])
       {:ok, inst} = Firebird.load(result.wasm)
@@ -429,22 +459,24 @@ defmodule Firebird.Compiler.CombinerEdgeCasesTest do
 
   describe "combine/2 result correctness" do
     test "combined module returns correct results for all functions", %{tmp: tmp} do
-      a = write_source(tmp, "a.ex", """
-      defmodule CombCorrectA do
-        @wasm true
-        def add(a, b), do: a + b
-
-        @wasm true
-        def sub(a, b), do: a - b
-      end
-      """)
-
-      b = write_source(tmp, "b.ex", """
-      defmodule CombCorrectB do
-        @wasm true
-        def mul(a, b), do: a * b
-      end
-      """)
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule CombCorrectA do
+          @wasm true
+          def add(a, b), do: a + b
+
+          @wasm true
+          def sub(a, b), do: a - b
+        end
+        """)
+
+      b =
+        write_source(tmp, "b.ex", """
+        defmodule CombCorrectB do
+          @wasm true
+          def mul(a, b), do: a * b
+        end
+        """)
 
       {:ok, result} = Combiner.combine([a, b])
       {:ok, inst} = Firebird.load(result.wasm)
diff --git a/test/compiler/combiner_test.exs b/test/compiler/combiner_test.exs
index b011ded..6662ce9 100644
--- a/test/compiler/combiner_test.exs
+++ b/test/compiler/combiner_test.exs
@@ -19,19 +19,21 @@ defmodule Firebird.Compiler.CombinerTest do
 
   describe "combine/2" do
     test "combines two modules into one WASM", %{tmp: tmp} do
-      a = write_source(tmp, "a.ex", """
-      defmodule CombA do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
-
-      b = write_source(tmp, "b.ex", """
-      defmodule CombB do
-        @wasm true
-        def mul(a, b), do: a * b
-      end
-      """)
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule CombA do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
+
+      b =
+        write_source(tmp, "b.ex", """
+        defmodule CombB do
+          @wasm true
+          def mul(a, b), do: a * b
+        end
+        """)
 
       {:ok, result} = Combiner.combine([a, b])
       assert is_binary(result.wasm)
@@ -44,19 +46,21 @@ defmodule Firebird.Compiler.CombinerTest do
     end
 
     test "combines with prefix option", %{tmp: tmp} do
-      a = write_source(tmp, "a.ex", """
-      defmodule CombPrefA do
-        @wasm true
-        def compute(a), do: a + 1
-      end
-      """)
-
-      b = write_source(tmp, "b.ex", """
-      defmodule CombPrefB do
-        @wasm true
-        def compute(a), do: a * 2
-      end
-      """)
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule CombPrefA do
+          @wasm true
+          def compute(a), do: a + 1
+        end
+        """)
+
+      b =
+        write_source(tmp, "b.ex", """
+        defmodule CombPrefB do
+          @wasm true
+          def compute(a), do: a * 2
+        end
+        """)
 
       {:ok, result} = Combiner.combine([a, b], prefix: true)
       assert is_binary(result.wasm)
@@ -68,24 +72,26 @@ defmodule Firebird.Compiler.CombinerTest do
     end
 
     test "combines with custom name", %{tmp: tmp} do
-      a = write_source(tmp, "a.ex", """
-      defmodule CombNamed do
-        @wasm true
-        def id(a), do: a
-      end
-      """)
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule CombNamed do
+          @wasm true
+          def id(a), do: a
+        end
+        """)
 
       {:ok, result} = Combiner.combine([a], name: "MyApp")
       assert result.module == :MyApp
     end
 
     test "handles single source", %{tmp: tmp} do
-      a = write_source(tmp, "single.ex", """
-      defmodule CombSingle do
-        @wasm true
-        def double(a), do: a * 2
-      end
-      """)
+      a =
+        write_source(tmp, "single.ex", """
+        defmodule CombSingle do
+          @wasm true
+          def double(a), do: a * 2
+        end
+        """)
 
       {:ok, result} = Combiner.combine([a])
       {:ok, inst} = Firebird.load(result.wasm)
@@ -101,12 +107,13 @@ defmodule Firebird.Compiler.CombinerTest do
     test "writes output to directory", %{tmp: tmp} do
       out = Path.join(tmp, "out")
 
-      a = write_source(tmp, "a.ex", """
-      defmodule CombOut do
-        @wasm true
-        def id(a), do: a
-      end
-      """)
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule CombOut do
+          @wasm true
+          def id(a), do: a
+        end
+        """)
 
       {:ok, _} = Combiner.combine([a], output_dir: out, name: "OutTest")
       assert File.exists?(Path.join(out, "OutTest.wat"))
@@ -114,12 +121,13 @@ defmodule Firebird.Compiler.CombinerTest do
     end
 
     test "wat_only option", %{tmp: tmp} do
-      a = write_source(tmp, "a.ex", """
-      defmodule CombWatOnly do
-        @wasm true
-        def id(a), do: a
-      end
-      """)
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule CombWatOnly do
+          @wasm true
+          def id(a), do: a
+        end
+        """)
 
       {:ok, result} = Combiner.combine([a], wat_only: true)
       assert is_binary(result.wat)
@@ -175,5 +183,3 @@ defmodule Firebird.Compiler.CombinerTest do
     end
   end
 end
-
-
diff --git a/test/compiler/constant_propagation_test.exs b/test/compiler/constant_propagation_test.exs
index 2aee058..674aaa1 100644
--- a/test/compiler/constant_propagation_test.exs
+++ b/test/compiler/constant_propagation_test.exs
@@ -7,151 +7,170 @@ defmodule Firebird.Compiler.ConstantPropagationTest do
   describe "propagate_expr/3" do
     test "substitutes let-bound literal into variable reference" do
       # let x = 5; x + 3
-      body = {:block, [
-        {:let, :x, {:literal, 5}},
-        {:binop, :add, {:var, :x}, {:literal, 3}}
-      ]}
+      body =
+        {:block,
+         [
+           {:let, :x, {:literal, 5}},
+           {:binop, :add, {:var, :x}, {:literal, 3}}
+         ]}
 
       result = ConstantPropagation.propagate_expr(body)
 
-      assert {:block, [
-        {:let, :x, {:literal, 5}},
-        {:binop, :add, {:literal, 5}, {:literal, 3}}
-      ]} = result
+      assert {:block,
+              [
+                {:let, :x, {:literal, 5}},
+                {:binop, :add, {:literal, 5}, {:literal, 3}}
+              ]} = result
     end
 
     test "does not substitute non-literal let bindings" do
       # let x = a + b; x * 2
-      body = {:block, [
-        {:let, :x, {:binop, :add, {:var, :a}, {:var, :b}}},
-        {:binop, :mul, {:var, :x}, {:literal, 2}}
-      ]}
+      body =
+        {:block,
+         [
+           {:let, :x, {:binop, :add, {:var, :a}, {:var, :b}}},
+           {:binop, :mul, {:var, :x}, {:literal, 2}}
+         ]}
 
       result = ConstantPropagation.propagate_expr(body)
 
       # x should NOT be substituted since its value is not a literal
-      assert {:block, [
-        {:let, :x, {:binop, :add, {:var, :a}, {:var, :b}}},
-        {:binop, :mul, {:var, :x}, {:literal, 2}}
-      ]} = result
+      assert {:block,
+              [
+                {:let, :x, {:binop, :add, {:var, :a}, {:var, :b}}},
+                {:binop, :mul, {:var, :x}, {:literal, 2}}
+              ]} = result
     end
 
     test "chains propagation through multiple let bindings" do
       # let x = 5; let y = 10; x + y
-      body = {:block, [
-        {:let, :x, {:literal, 5}},
-        {:let, :y, {:literal, 10}},
-        {:binop, :add, {:var, :x}, {:var, :y}}
-      ]}
+      body =
+        {:block,
+         [
+           {:let, :x, {:literal, 5}},
+           {:let, :y, {:literal, 10}},
+           {:binop, :add, {:var, :x}, {:var, :y}}
+         ]}
 
       result = ConstantPropagation.propagate_expr(body)
 
-      assert {:block, [
-        {:let, :x, {:literal, 5}},
-        {:let, :y, {:literal, 10}},
-        {:binop, :add, {:literal, 5}, {:literal, 10}}
-      ]} = result
+      assert {:block,
+              [
+                {:let, :x, {:literal, 5}},
+                {:let, :y, {:literal, 10}},
+                {:binop, :add, {:literal, 5}, {:literal, 10}}
+              ]} = result
     end
 
     test "handles shadowed variables by updating env" do
       # let x = 5; let x = a; x + 3
-      body = {:block, [
-        {:let, :x, {:literal, 5}},
-        {:let, :x, {:var, :a}},
-        {:binop, :add, {:var, :x}, {:literal, 3}}
-      ]}
+      body =
+        {:block,
+         [
+           {:let, :x, {:literal, 5}},
+           {:let, :x, {:var, :a}},
+           {:binop, :add, {:var, :x}, {:literal, 3}}
+         ]}
 
       result = ConstantPropagation.propagate_expr(body)
 
       # x was rebound to a non-literal, so should NOT be substituted
-      assert {:block, [
-        {:let, :x, {:literal, 5}},
-        {:let, :x, {:var, :a}},
-        {:binop, :add, {:var, :x}, {:literal, 3}}
-      ]} = result
+      assert {:block,
+              [
+                {:let, :x, {:literal, 5}},
+                {:let, :x, {:var, :a}},
+                {:binop, :add, {:var, :x}, {:literal, 3}}
+              ]} = result
     end
 
     test "propagates into if branches" do
       # let x = 5; if (x == 5) then x + 1 else x + 2
-      body = {:block, [
-        {:let, :x, {:literal, 5}},
-        {:if,
-          {:binop, :eq, {:var, :x}, {:literal, 5}},
-          {:binop, :add, {:var, :x}, {:literal, 1}},
-          {:binop, :add, {:var, :x}, {:literal, 2}}}
-      ]}
+      body =
+        {:block,
+         [
+           {:let, :x, {:literal, 5}},
+           {:if, {:binop, :eq, {:var, :x}, {:literal, 5}},
+            {:binop, :add, {:var, :x}, {:literal, 1}}, {:binop, :add, {:var, :x}, {:literal, 2}}}
+         ]}
 
       result = ConstantPropagation.propagate_expr(body)
 
-      assert {:block, [
-        {:let, :x, {:literal, 5}},
-        {:if,
-          {:binop, :eq, {:literal, 5}, {:literal, 5}},
-          {:binop, :add, {:literal, 5}, {:literal, 1}},
-          {:binop, :add, {:literal, 5}, {:literal, 2}}}
-      ]} = result
+      assert {:block,
+              [
+                {:let, :x, {:literal, 5}},
+                {:if, {:binop, :eq, {:literal, 5}, {:literal, 5}},
+                 {:binop, :add, {:literal, 5}, {:literal, 1}},
+                 {:binop, :add, {:literal, 5}, {:literal, 2}}}
+              ]} = result
     end
 
     test "propagates into function calls" do
       # let x = 5; foo(x, x + 1)
-      body = {:block, [
-        {:let, :x, {:literal, 5}},
-        {:call, :foo, [{:var, :x}, {:binop, :add, {:var, :x}, {:literal, 1}}]}
-      ]}
+      body =
+        {:block,
+         [
+           {:let, :x, {:literal, 5}},
+           {:call, :foo, [{:var, :x}, {:binop, :add, {:var, :x}, {:literal, 1}}]}
+         ]}
 
       result = ConstantPropagation.propagate_expr(body)
 
-      assert {:block, [
-        {:let, :x, {:literal, 5}},
-        {:call, :foo, [{:literal, 5}, {:binop, :add, {:literal, 5}, {:literal, 1}}]}
-      ]} = result
+      assert {:block,
+              [
+                {:let, :x, {:literal, 5}},
+                {:call, :foo, [{:literal, 5}, {:binop, :add, {:literal, 5}, {:literal, 1}}]}
+              ]} = result
     end
 
     test "does not propagate through case pattern variables" do
-      body = {:case, {:var, :n}, [
-        {{:literal_pat, 0}, nil, {:literal, 1}},
-        {{:var_pat, :x}, nil, {:binop, :add, {:var, :x}, {:literal, 1}}}
-      ]}
+      body =
+        {:case, {:var, :n},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 1}},
+           {{:var_pat, :x}, nil, {:binop, :add, {:var, :x}, {:literal, 1}}}
+         ]}
 
       # x is pattern-bound, not let-bound, so should not be propagated
       result = ConstantPropagation.propagate_expr(body)
 
-      assert {:case, {:var, :n}, [
-        {{:literal_pat, 0}, nil, {:literal, 1}},
-        {{:var_pat, :x}, nil, {:binop, :add, {:var, :x}, {:literal, 1}}}
-      ]} = result
+      assert {:case, {:var, :n},
+              [
+                {{:literal_pat, 0}, nil, {:literal, 1}},
+                {{:var_pat, :x}, nil, {:binop, :add, {:var, :x}, {:literal, 1}}}
+              ]} = result
     end
 
     test "does not propagate loop params (they change per iteration)" do
       # tail_loop with param x = 10: body uses x
-      body = {:tail_loop, [{:x, {:literal, 10}}],
-        {:if,
-          {:binop, :gt_s, {:var, :x}, {:literal, 0}},
-          {:tail_call, :loop, [{:binop, :sub, {:var, :x}, {:literal, 1}}]},
-          {:var, :x}}}
+      body =
+        {:tail_loop, [{:x, {:literal, 10}}],
+         {:if, {:binop, :gt_s, {:var, :x}, {:literal, 0}},
+          {:tail_call, :loop, [{:binop, :sub, {:var, :x}, {:literal, 1}}]}, {:var, :x}}}
 
       result = ConstantPropagation.propagate_expr(body)
 
       # x is a loop variable — must NOT be substituted
       assert {:tail_loop, [{:x, {:literal, 10}}],
-        {:if,
-          {:binop, :gt_s, {:var, :x}, {:literal, 0}},
-          {:tail_call, :loop, [{:binop, :sub, {:var, :x}, {:literal, 1}}]},
-          {:var, :x}}} = result
+              {:if, {:binop, :gt_s, {:var, :x}, {:literal, 0}},
+               {:tail_call, :loop, [{:binop, :sub, {:var, :x}, {:literal, 1}}]},
+               {:var, :x}}} = result
     end
 
     test "propagates float literals" do
-      body = {:block, [
-        {:let, :pi, {:literal, 3.14}},
-        {:binop, :mul, {:var, :pi}, {:literal, 2.0}}
-      ]}
+      body =
+        {:block,
+         [
+           {:let, :pi, {:literal, 3.14}},
+           {:binop, :mul, {:var, :pi}, {:literal, 2.0}}
+         ]}
 
       result = ConstantPropagation.propagate_expr(body)
 
-      assert {:block, [
-        {:let, :pi, {:literal, 3.14}},
-        {:binop, :mul, {:literal, 3.14}, {:literal, 2.0}}
-      ]} = result
+      assert {:block,
+              [
+                {:let, :pi, {:literal, 3.14}},
+                {:binop, :mul, {:literal, 3.14}, {:literal, 2.0}}
+              ]} = result
     end
   end
 
@@ -164,10 +183,12 @@ defmodule Firebird.Compiler.ConstantPropagationTest do
             name: :f,
             arity: 1,
             params: [:a],
-            body: {:block, [
-              {:let, :x, {:literal, 42}},
-              {:binop, :add, {:var, :a}, {:var, :x}}
-            ]},
+            body:
+              {:block,
+               [
+                 {:let, :x, {:literal, 42}},
+                 {:binop, :add, {:var, :a}, {:var, :x}}
+               ]},
             clauses: [],
             type: nil
           }
@@ -178,10 +199,11 @@ defmodule Firebird.Compiler.ConstantPropagationTest do
       {:ok, result} = ConstantPropagation.propagate(module)
       [func] = result.functions
 
-      assert {:block, [
-        {:let, :x, {:literal, 42}},
-        {:binop, :add, {:var, :a}, {:literal, 42}}
-      ]} = func.body
+      assert {:block,
+              [
+                {:let, :x, {:literal, 42}},
+                {:binop, :add, {:var, :a}, {:literal, 42}}
+              ]} = func.body
     end
 
     test "does not propagate function parameters" do
@@ -224,7 +246,9 @@ defmodule Firebird.Compiler.ConstantPropagationTest do
       """
 
       # Compile with inline + optimize (which now includes const prop)
-      {:ok, result} = Firebird.Compiler.compile_source(source, inline: true, optimize: true, wat_only: true)
+      {:ok, result} =
+        Firebird.Compiler.compile_source(source, inline: true, optimize: true, wat_only: true)
+
       assert result.wat != nil
 
       # The WAT should contain the optimized result
@@ -246,7 +270,8 @@ defmodule Firebird.Compiler.ConstantPropagationTest do
       end
       """
 
-      assert {:ok, %IR.Module{}} = Firebird.Target.Pipeline.run_to(:const_prop, source, inline: true)
+      assert {:ok, %IR.Module{}} =
+               Firebird.Target.Pipeline.run_to(:const_prop, source, inline: true)
     end
   end
 end
diff --git a/test/compiler/cse_test.exs b/test/compiler/cse_test.exs
index b31d3ae..96890f8 100644
--- a/test/compiler/cse_test.exs
+++ b/test/compiler/cse_test.exs
@@ -64,10 +64,13 @@ defmodule Firebird.Compiler.CSETest do
 
     test "counts across case clauses" do
       add = {:binop, :add, {:var, :p0}, {:var, :p1}}
-      expr = {:case, {:var, :p0}, [
-        {{:literal_pat, 0}, nil, add},
-        {:wildcard, nil, add}
-      ]}
+
+      expr =
+        {:case, {:var, :p0},
+         [
+           {{:literal_pat, 0}, nil, add},
+           {:wildcard, nil, add}
+         ]}
 
       freq = CSE.count_subexpressions(expr)
       assert Map.get(freq, add) == 2
@@ -158,10 +161,14 @@ defmodule Firebird.Compiler.CSETest do
       # x = a + 1; (x + b) * (x + b)
       # (x + b) references local `x`, so it shouldn't be CSE'd
       add_xb = {:binop, :add, {:var, :x}, {:var, :p1}}
-      body = {:block, [
-        {:let, :x, {:binop, :add, {:var, :p0}, {:literal, 1}}},
-        {:binop, :mul, add_xb, add_xb}
-      ]}
+
+      body =
+        {:block,
+         [
+           {:let, :x, {:binop, :add, {:var, :p0}, {:literal, 1}}},
+           {:binop, :mul, add_xb, add_xb}
+         ]}
+
       module = make_module(:Test, :f, [:p0, :p1], body)
 
       {:ok, result} = CSE.eliminate(module)
@@ -211,6 +218,7 @@ defmodule Firebird.Compiler.CSETest do
 
     test "handles multiple functions in module" do
       add = {:binop, :add, {:var, :p0}, {:var, :p1}}
+
       module = %IR.Module{
         name: :Test,
         functions: [
@@ -313,7 +321,9 @@ defmodule Firebird.Compiler.CSETest do
       end
       """
 
-      assert {:ok, result} = Firebird.Compiler.compile_source(source, cse: true, optimize: true, wat_only: true)
+      assert {:ok, result} =
+               Firebird.Compiler.compile_source(source, cse: true, optimize: true, wat_only: true)
+
       assert is_binary(result.wat)
     end
 
diff --git a/test/compiler/dead_let_elim_test.exs b/test/compiler/dead_let_elim_test.exs
index 2ff3d6e..eb43506 100644
--- a/test/compiler/dead_let_elim_test.exs
+++ b/test/compiler/dead_let_elim_test.exs
@@ -6,146 +6,170 @@ defmodule Firebird.Compiler.DeadLetElimTest do
   describe "dead_let_elim/1" do
     test "removes unused let binding from block" do
       # {:let, :n, {:literal, 5}} is never referenced
-      expr = {:block, [
-        {:let, :n, {:literal, 5}},
-        {:literal, 42}
-      ]}
+      expr =
+        {:block,
+         [
+           {:let, :n, {:literal, 5}},
+           {:literal, 42}
+         ]}
 
       result = Optimizer.dead_let_elim(expr)
       assert result == {:literal, 42}
     end
 
     test "keeps used let binding" do
-      expr = {:block, [
-        {:let, :n, {:literal, 5}},
-        {:binop, :add, {:var, :n}, {:literal, 1}}
-      ]}
+      expr =
+        {:block,
+         [
+           {:let, :n, {:literal, 5}},
+           {:binop, :add, {:var, :n}, {:literal, 1}}
+         ]}
 
       result = Optimizer.dead_let_elim(expr)
-      assert result == {:block, [
-        {:let, :n, {:literal, 5}},
-        {:binop, :add, {:var, :n}, {:literal, 1}}
-      ]}
+
+      assert result ==
+               {:block,
+                [
+                  {:let, :n, {:literal, 5}},
+                  {:binop, :add, {:var, :n}, {:literal, 1}}
+                ]}
     end
 
     test "removes multiple unused let bindings" do
-      expr = {:block, [
-        {:let, :a, {:literal, 1}},
-        {:let, :b, {:literal, 2}},
-        {:let, :c, {:literal, 3}},
-        {:literal, 99}
-      ]}
+      expr =
+        {:block,
+         [
+           {:let, :a, {:literal, 1}},
+           {:let, :b, {:literal, 2}},
+           {:let, :c, {:literal, 3}},
+           {:literal, 99}
+         ]}
 
       result = Optimizer.dead_let_elim(expr)
       assert result == {:literal, 99}
     end
 
     test "keeps used, removes unused in mixed block" do
-      expr = {:block, [
-        {:let, :used, {:literal, 10}},
-        {:let, :dead, {:literal, 20}},
-        {:binop, :add, {:var, :used}, {:literal, 1}}
-      ]}
+      expr =
+        {:block,
+         [
+           {:let, :used, {:literal, 10}},
+           {:let, :dead, {:literal, 20}},
+           {:binop, :add, {:var, :used}, {:literal, 1}}
+         ]}
 
       result = Optimizer.dead_let_elim(expr)
-      assert result == {:block, [
-        {:let, :used, {:literal, 10}},
-        {:binop, :add, {:var, :used}, {:literal, 1}}
-      ]}
+
+      assert result ==
+               {:block,
+                [
+                  {:let, :used, {:literal, 10}},
+                  {:binop, :add, {:var, :used}, {:literal, 1}}
+                ]}
     end
 
     test "handles chained let bindings where one references another" do
       # :a is used by :b's value, :b is used by the final expr
-      expr = {:block, [
-        {:let, :a, {:literal, 5}},
-        {:let, :b, {:binop, :add, {:var, :a}, {:literal, 1}}},
-        {:var, :b}
-      ]}
+      expr =
+        {:block,
+         [
+           {:let, :a, {:literal, 5}},
+           {:let, :b, {:binop, :add, {:var, :a}, {:literal, 1}}},
+           {:var, :b}
+         ]}
 
       result = Optimizer.dead_let_elim(expr)
-      assert result == {:block, [
-        {:let, :a, {:literal, 5}},
-        {:let, :b, {:binop, :add, {:var, :a}, {:literal, 1}}},
-        {:var, :b}
-      ]}
+
+      assert result ==
+               {:block,
+                [
+                  {:let, :a, {:literal, 5}},
+                  {:let, :b, {:binop, :add, {:var, :a}, {:literal, 1}}},
+                  {:var, :b}
+                ]}
     end
 
     test "removes intermediate dead binding in chain" do
       # :a is used by :b, but :b is never used — both should be removed
-      expr = {:block, [
-        {:let, :a, {:literal, 5}},
-        {:let, :b, {:binop, :add, {:var, :a}, {:literal, 1}}},
-        {:literal, 42}
-      ]}
+      expr =
+        {:block,
+         [
+           {:let, :a, {:literal, 5}},
+           {:let, :b, {:binop, :add, {:var, :a}, {:literal, 1}}},
+           {:literal, 42}
+         ]}
 
       result = Optimizer.dead_let_elim(expr)
       assert result == {:literal, 42}
     end
 
     test "recurses into if expressions" do
-      expr = {:if,
-        {:literal, 1},
-        {:block, [
-          {:let, :dead, {:literal, 1}},
-          {:literal, 10}
-        ]},
-        {:literal, 20}
-      }
+      expr =
+        {:if, {:literal, 1},
+         {:block,
+          [
+            {:let, :dead, {:literal, 1}},
+            {:literal, 10}
+          ]}, {:literal, 20}}
 
       result = Optimizer.dead_let_elim(expr)
       assert result == {:if, {:literal, 1}, {:literal, 10}, {:literal, 20}}
     end
 
     test "recurses into case clauses" do
-      expr = {:case, {:var, :x}, [
-        {{:literal_pat, 0}, nil,
-         {:block, [
-           {:let, :dead, {:literal, 99}},
-           {:literal, 0}
-         ]}},
-        {{:var_pat, :y}, nil, {:var, :y}}
-      ]}
+      expr =
+        {:case, {:var, :x},
+         [
+           {{:literal_pat, 0}, nil,
+            {:block,
+             [
+               {:let, :dead, {:literal, 99}},
+               {:literal, 0}
+             ]}},
+           {{:var_pat, :y}, nil, {:var, :y}}
+         ]}
 
       result = Optimizer.dead_let_elim(expr)
 
-      assert {:case, {:var, :x}, [
-        {{:literal_pat, 0}, nil, {:literal, 0}},
-        {{:var_pat, :y}, nil, {:var, :y}}
-      ]} = result
+      assert {:case, {:var, :x},
+              [
+                {{:literal_pat, 0}, nil, {:literal, 0}},
+                {{:var_pat, :y}, nil, {:var, :y}}
+              ]} = result
     end
 
     test "recurses into tail_loop body" do
-      expr = {:tail_loop, [{:n, {:var, :p0}}],
-        {:block, [
-          {:let, :dead, {:literal, 0}},
-          {:tail_call, :func, [{:literal, 1}]}
-        ]}
-      }
+      expr =
+        {:tail_loop, [{:n, {:var, :p0}}],
+         {:block,
+          [
+            {:let, :dead, {:literal, 0}},
+            {:tail_call, :func, [{:literal, 1}]}
+          ]}}
 
       result = Optimizer.dead_let_elim(expr)
-      assert {:tail_loop, [{:n, {:var, :p0}}],
-        {:tail_call, :func, [{:literal, 1}]}
-      } = result
+      assert {:tail_loop, [{:n, {:var, :p0}}], {:tail_call, :func, [{:literal, 1}]}} = result
     end
 
     test "preserves let binding used in nested if" do
-      expr = {:block, [
-        {:let, :x, {:literal, 5}},
-        {:if, {:binop, :gt_s, {:var, :x}, {:literal, 0}},
-          {:var, :x},
-          {:literal, 0}
-        }
-      ]}
+      expr =
+        {:block,
+         [
+           {:let, :x, {:literal, 5}},
+           {:if, {:binop, :gt_s, {:var, :x}, {:literal, 0}}, {:var, :x}, {:literal, 0}}
+         ]}
 
       result = Optimizer.dead_let_elim(expr)
       assert result == expr
     end
 
     test "preserves let binding used in nested call" do
-      expr = {:block, [
-        {:let, :x, {:literal, 5}},
-        {:call, :foo, [{:var, :x}]}
-      ]}
+      expr =
+        {:block,
+         [
+           {:let, :x, {:literal, 5}},
+           {:call, :foo, [{:var, :x}]}
+         ]}
 
       result = Optimizer.dead_let_elim(expr)
       assert result == expr
@@ -172,10 +196,12 @@ defmodule Firebird.Compiler.DeadLetElimTest do
             name: :foo,
             arity: 1,
             params: [:p0],
-            body: {:block, [
-              {:let, :dead, {:literal, 99}},
-              {:binop, :add, {:var, :p0}, {:literal, 1}}
-            ]},
+            body:
+              {:block,
+               [
+                 {:let, :dead, {:literal, 99}},
+                 {:binop, :add, {:var, :p0}, {:literal, 1}}
+               ]},
             clauses: [],
             type: nil
           }
@@ -200,10 +226,12 @@ defmodule Firebird.Compiler.DeadLetElimTest do
             name: :bar,
             arity: 0,
             params: [],
-            body: {:block, [
-              {:let, :n, {:literal, 5}},
-              {:binop, :mul, {:literal, 5}, {:literal, 2}}
-            ]},
+            body:
+              {:block,
+               [
+                 {:let, :n, {:literal, 5}},
+                 {:binop, :mul, {:literal, 5}, {:literal, 2}}
+               ]},
             clauses: [],
             type: nil
           }
diff --git a/test/compiler/dependency_tracker_edge_cases_test.exs b/test/compiler/dependency_tracker_edge_cases_test.exs
index 8178f7b..75ee0a9 100644
--- a/test/compiler/dependency_tracker_edge_cases_test.exs
+++ b/test/compiler/dependency_tracker_edge_cases_test.exs
@@ -3,7 +3,10 @@ defmodule Firebird.Compiler.DependencyTrackerEdgeCasesTest do
 
   alias Firebird.Compiler.DependencyTracker
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_dep_tracker_edge_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_dep_tracker_edge_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -21,29 +24,33 @@ defmodule Firebird.Compiler.DependencyTrackerEdgeCasesTest do
 
   describe "diamond dependency graph" do
     test "handles A -> B, A -> C, B -> D, C -> D", %{tmp: tmp} do
-      d = write_source(tmp, "d.ex", """
-      defmodule DiamondD do
-        def base(x), do: x
-      end
-      """)
+      d =
+        write_source(tmp, "d.ex", """
+        defmodule DiamondD do
+          def base(x), do: x
+        end
+        """)
 
-      b = write_source(tmp, "b.ex", """
-      defmodule DiamondB do
-        def compute(x), do: DiamondD.base(x) + 1
-      end
-      """)
+      b =
+        write_source(tmp, "b.ex", """
+        defmodule DiamondB do
+          def compute(x), do: DiamondD.base(x) + 1
+        end
+        """)
 
-      c = write_source(tmp, "c.ex", """
-      defmodule DiamondC do
-        def compute(x), do: DiamondD.base(x) * 2
-      end
-      """)
+      c =
+        write_source(tmp, "c.ex", """
+        defmodule DiamondC do
+          def compute(x), do: DiamondD.base(x) * 2
+        end
+        """)
 
-      a = write_source(tmp, "a.ex", """
-      defmodule DiamondA do
-        def compute(x), do: DiamondB.compute(x) + DiamondC.compute(x)
-      end
-      """)
+      a =
+        write_source(tmp, "a.ex", """
+        defmodule DiamondA do
+          def compute(x), do: DiamondB.compute(x) + DiamondC.compute(x)
+        end
+        """)
 
       {:ok, graph} = DependencyTracker.analyze([a, b, c, d])
 
@@ -239,11 +246,12 @@ defmodule Firebird.Compiler.DependencyTrackerEdgeCasesTest do
 
       # Both cycles should be found (as supersets since paths include repeat)
       assert Enum.any?(cycle_sets, fn cs ->
-        MapSet.subset?(ab_cycle, cs)
-      end)
+               MapSet.subset?(ab_cycle, cs)
+             end)
+
       assert Enum.any?(cycle_sets, fn cs ->
-        MapSet.subset?(cd_cycle, cs)
-      end)
+               MapSet.subset?(cd_cycle, cs)
+             end)
     end
 
     test "graph with cycle and acyclic parts" do
@@ -274,9 +282,12 @@ defmodule Firebird.Compiler.DependencyTrackerEdgeCasesTest do
     end
 
     test "many independent nodes are all included" do
-      graph = Map.new(Enum.map(1..10, fn i ->
-        {String.to_atom("M#{i}"), MapSet.new()}
-      end))
+      graph =
+        Map.new(
+          Enum.map(1..10, fn i ->
+            {String.to_atom("M#{i}"), MapSet.new()}
+          end)
+        )
 
       {:ok, order} = DependencyTracker.compilation_order(graph)
       assert length(order) == 10
@@ -303,6 +314,7 @@ defmodule Firebird.Compiler.DependencyTrackerEdgeCasesTest do
 
       # A must come before everything
       a_idx = Enum.find_index(order, &(&1 == :A))
+
       for mod <- [:B, :C, :D, :E, :F] do
         mod_idx = Enum.find_index(order, &(&1 == mod))
         assert a_idx < mod_idx, "A should come before #{mod}"
@@ -363,9 +375,13 @@ defmodule Firebird.Compiler.DependencyTrackerEdgeCasesTest do
 
     test "module with many dependencies" do
       deps = MapSet.new([:A, :B, :C, :D, :E])
+
       graph = %{
-        A: MapSet.new(), B: MapSet.new(), C: MapSet.new(),
-        D: MapSet.new(), E: MapSet.new(),
+        A: MapSet.new(),
+        B: MapSet.new(),
+        C: MapSet.new(),
+        D: MapSet.new(),
+        E: MapSet.new(),
         F: deps
       }
 
@@ -377,21 +393,23 @@ defmodule Firebird.Compiler.DependencyTrackerEdgeCasesTest do
 
   describe "analyze/1 edge cases" do
     test "handles source with nested module references", %{tmp: tmp} do
-      a = write_source(tmp, "nested.ex", """
-      defmodule EdgeNested do
-        def compute(x) do
-          y = EdgeHelper.step1(x)
-          EdgeHelper.step2(y)
+      a =
+        write_source(tmp, "nested.ex", """
+        defmodule EdgeNested do
+          def compute(x) do
+            y = EdgeHelper.step1(x)
+            EdgeHelper.step2(y)
+          end
         end
-      end
-      """)
+        """)
 
-      b = write_source(tmp, "helper.ex", """
-      defmodule EdgeHelper do
-        def step1(x), do: x + 1
-        def step2(x), do: x * 2
-      end
-      """)
+      b =
+        write_source(tmp, "helper.ex", """
+        defmodule EdgeHelper do
+          def step1(x), do: x + 1
+          def step2(x), do: x * 2
+        end
+        """)
 
       {:ok, graph} = DependencyTracker.analyze([a, b])
       assert MapSet.member?(graph[:EdgeNested], :EdgeHelper)
@@ -400,23 +418,26 @@ defmodule Firebird.Compiler.DependencyTrackerEdgeCasesTest do
     end
 
     test "handles source with module in function args", %{tmp: tmp} do
-      a = write_source(tmp, "caller.ex", """
-      defmodule EdgeCaller do
-        def run(x), do: EdgeTarget.process(EdgeOther.prepare(x))
-      end
-      """)
+      a =
+        write_source(tmp, "caller.ex", """
+        defmodule EdgeCaller do
+          def run(x), do: EdgeTarget.process(EdgeOther.prepare(x))
+        end
+        """)
 
-      b = write_source(tmp, "target.ex", """
-      defmodule EdgeTarget do
-        def process(x), do: x
-      end
-      """)
+      b =
+        write_source(tmp, "target.ex", """
+        defmodule EdgeTarget do
+          def process(x), do: x
+        end
+        """)
 
-      c = write_source(tmp, "other.ex", """
-      defmodule EdgeOther do
-        def prepare(x), do: x
-      end
-      """)
+      c =
+        write_source(tmp, "other.ex", """
+        defmodule EdgeOther do
+          def prepare(x), do: x
+        end
+        """)
 
       {:ok, graph} = DependencyTracker.analyze([a, b, c])
       assert MapSet.member?(graph[:EdgeCaller], :EdgeTarget)
@@ -424,11 +445,12 @@ defmodule Firebird.Compiler.DependencyTrackerEdgeCasesTest do
     end
 
     test "handles mix of valid and invalid files", %{tmp: tmp} do
-      good = write_source(tmp, "good.ex", """
-      defmodule EdgeGood do
-        def hello, do: 1
-      end
-      """)
+      good =
+        write_source(tmp, "good.ex", """
+        defmodule EdgeGood do
+          def hello, do: 1
+        end
+        """)
 
       bad = write_source(tmp, "bad.ex", "not valid {{{ elixir")
 
@@ -445,32 +467,35 @@ defmodule Firebird.Compiler.DependencyTrackerEdgeCasesTest do
     end
 
     test "handles file with only comments", %{tmp: tmp} do
-      comments = write_source(tmp, "comments.ex", """
-      # This is just a comment
-      # No module here
-      """)
+      comments =
+        write_source(tmp, "comments.ex", """
+        # This is just a comment
+        # No module here
+        """)
 
       {:ok, graph} = DependencyTracker.analyze([comments])
       assert map_size(graph) == 0
     end
 
     test "handles file with plain expression (no defmodule)", %{tmp: tmp} do
-      expr = write_source(tmp, "expr.ex", """
-      x = 1 + 2
-      IO.puts(x)
-      """)
+      expr =
+        write_source(tmp, "expr.ex", """
+        x = 1 + 2
+        IO.puts(x)
+        """)
 
       {:ok, graph} = DependencyTracker.analyze([expr])
       assert map_size(graph) == 0
     end
 
     test "self-referencing module call is excluded from deps", %{tmp: tmp} do
-      a = write_source(tmp, "self_ref.ex", """
-      defmodule SelfRef do
-        def foo(x), do: SelfRef.bar(x)
-        def bar(x), do: x + 1
-      end
-      """)
+      a =
+        write_source(tmp, "self_ref.ex", """
+        defmodule SelfRef do
+          def foo(x), do: SelfRef.bar(x)
+          def bar(x), do: x + 1
+        end
+        """)
 
       {:ok, graph} = DependencyTracker.analyze([a])
       assert Map.has_key?(graph, :SelfRef)
@@ -479,11 +504,12 @@ defmodule Firebird.Compiler.DependencyTrackerEdgeCasesTest do
     end
 
     test "module depending on external (non-analyzed) module", %{tmp: tmp} do
-      a = write_source(tmp, "uses_external.ex", """
-      defmodule UsesExternal do
-        def run(x), do: Enum.map(x, &(&1 + 1))
-      end
-      """)
+      a =
+        write_source(tmp, "uses_external.ex", """
+        defmodule UsesExternal do
+          def run(x), do: Enum.map(x, &(&1 + 1))
+        end
+        """)
 
       {:ok, graph} = DependencyTracker.analyze([a])
       assert Map.has_key?(graph, :UsesExternal)
@@ -492,11 +518,12 @@ defmodule Firebird.Compiler.DependencyTrackerEdgeCasesTest do
     end
 
     test "duplicate files don't create duplicate entries", %{tmp: tmp} do
-      a = write_source(tmp, "dup.ex", """
-      defmodule DupModule do
-        def id(x), do: x
-      end
-      """)
+      a =
+        write_source(tmp, "dup.ex", """
+        defmodule DupModule do
+          def id(x), do: x
+        end
+        """)
 
       {:ok, graph} = DependencyTracker.analyze([a, a])
       # Both parse to same module, second overwrites first in map
diff --git a/test/compiler/dependency_tracker_test.exs b/test/compiler/dependency_tracker_test.exs
index f50eabe..94a8796 100644
--- a/test/compiler/dependency_tracker_test.exs
+++ b/test/compiler/dependency_tracker_test.exs
@@ -72,6 +72,7 @@ defmodule Firebird.Compiler.DependencyTrackerTest do
         C: MapSet.new([:A]),
         D: MapSet.new([:B, :C])
       }
+
       trans = DependencyTracker.transitive_dependencies(graph, :D)
       assert MapSet.member?(trans, :A)
       assert MapSet.member?(trans, :B)
diff --git a/test/compiler/edge_cases_test.exs b/test/compiler/edge_cases_test.exs
index 4a23ffe..2cfb9a5 100644
--- a/test/compiler/edge_cases_test.exs
+++ b/test/compiler/edge_cases_test.exs
@@ -251,4 +251,3 @@ defmodule Firebird.Compiler.EdgeCasesTest do
     end
   end
 end
-
diff --git a/test/compiler/error_handling_test.exs b/test/compiler/error_handling_test.exs
index 1c117e6..6f44c46 100644
--- a/test/compiler/error_handling_test.exs
+++ b/test/compiler/error_handling_test.exs
@@ -27,12 +27,12 @@ defmodule Firebird.Compiler.ErrorHandlingTest do
   describe "file errors" do
     test "nonexistent file returns file error" do
       assert {:error, {:file_error, :enoent, _}} =
-        Firebird.Compiler.compile("/nonexistent/file.ex")
+               Firebird.Compiler.compile("/nonexistent/file.ex")
     end
 
     test "directory instead of file" do
       assert {:error, {:file_error, _, _}} =
-        Firebird.Compiler.compile("/tmp/nonexistent_dir/missing.ex")
+               Firebird.Compiler.compile("/tmp/nonexistent_dir/missing.ex")
     end
   end
 
@@ -48,7 +48,8 @@ defmodule Firebird.Compiler.ErrorHandlingTest do
       result = Firebird.Compiler.compile_source(source, wat_only: true)
       # May compile with error nodes or fail validation
       case result do
-        {:ok, _} -> :ok  # Compiled with error nodes
+        # Compiled with error nodes
+        {:ok, _} -> :ok
         {:error, {:validation_errors, _}} -> :ok
         {:error, _} -> :ok
       end
@@ -70,13 +71,16 @@ defmodule Firebird.Compiler.ErrorHandlingTest do
         def id(a), do: a
       end
       """
+
       {:ok, result} = Firebird.Compiler.compile_source(source, wat_only: true)
       assert result.wat != nil
       assert result.wasm == nil
     end
 
     test "output_dir writes files" do
-      dir = Path.join(System.tmp_dir!(), "firebird_err_test_#{System.unique_integer([:positive])}")
+      dir =
+        Path.join(System.tmp_dir!(), "firebird_err_test_#{System.unique_integer([:positive])}")
+
       File.mkdir_p!(dir)
 
       source = """
@@ -85,6 +89,7 @@ defmodule Firebird.Compiler.ErrorHandlingTest do
         def id(a), do: a
       end
       """
+
       {:ok, _result} = Firebird.Compiler.compile_source(source, output_dir: dir)
 
       assert File.exists?(Path.join(dir, "OutputTest.wat"))
@@ -100,6 +105,7 @@ defmodule Firebird.Compiler.ErrorHandlingTest do
         def add(a, b), do: a + b + 0
       end
       """
+
       {:ok, result} = Firebird.Compiler.compile_source(source, optimize: true)
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [8]} = Firebird.call(inst, "add", [5, 3])
@@ -113,6 +119,7 @@ defmodule Firebird.Compiler.ErrorHandlingTest do
         def add(a, b), do: a + b
       end
       """
+
       {:ok, result} = Firebird.Compiler.compile_source(source, tco: true)
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [8]} = Firebird.call(inst, "add", [5, 3])
diff --git a/test/compiler/if_chain_to_case_test.exs b/test/compiler/if_chain_to_case_test.exs
index b892458..73697b9 100644
--- a/test/compiler/if_chain_to_case_test.exs
+++ b/test/compiler/if_chain_to_case_test.exs
@@ -45,8 +45,18 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
     end
 
     test "processes all functions in the module" do
-      chain1 = build_if_chain([{0, {:literal, 10}}, {1, {:literal, 20}}, {2, {:literal, 30}}], {:literal, 99})
-      chain2 = build_if_chain([{0, {:literal, 100}}, {1, {:literal, 200}}, {2, {:literal, 300}}], {:literal, 999}, :p1)
+      chain1 =
+        build_if_chain(
+          [{0, {:literal, 10}}, {1, {:literal, 20}}, {2, {:literal, 30}}],
+          {:literal, 99}
+        )
+
+      chain2 =
+        build_if_chain(
+          [{0, {:literal, 100}}, {1, {:literal, 200}}, {2, {:literal, 300}}],
+          {:literal, 999},
+          :p1
+        )
 
       module = %IR.Module{
         name: TestModule,
@@ -71,34 +81,48 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
 
   describe "if-eq chain conversion" do
     test "converts chain of exactly 3 if-eq tests to case" do
-      chain = build_if_chain([{0, {:literal, 10}}, {1, {:literal, 20}}, {2, {:literal, 30}}], {:literal, 99})
+      chain =
+        build_if_chain(
+          [{0, {:literal, 10}}, {1, {:literal, 20}}, {2, {:literal, 30}}],
+          {:literal, 99}
+        )
+
       module = make_module(chain)
       {:ok, result} = IfChainToCase.convert(module)
       body = get_body(result)
 
       assert {:case, {:var, :p0}, clauses} = body
-      assert length(clauses) == 4  # 3 literal + 1 wildcard
+      # 3 literal + 1 wildcard
+      assert length(clauses) == 4
 
       assert [
-        {{:literal_pat, 0}, nil, {:literal, 10}},
-        {{:literal_pat, 1}, nil, {:literal, 20}},
-        {{:literal_pat, 2}, nil, {:literal, 30}},
-        {:wildcard, nil, {:literal, 99}}
-      ] = clauses
+               {{:literal_pat, 0}, nil, {:literal, 10}},
+               {{:literal_pat, 1}, nil, {:literal, 20}},
+               {{:literal_pat, 2}, nil, {:literal, 30}},
+               {:wildcard, nil, {:literal, 99}}
+             ] = clauses
     end
 
     test "converts chain of 5 if-eq tests" do
-      chain = build_if_chain(
-        [{0, {:literal, 0}}, {1, {:literal, 1}}, {2, {:literal, 2}},
-         {3, {:literal, 3}}, {4, {:literal, 4}}],
-        {:literal, -1}
-      )
+      chain =
+        build_if_chain(
+          [
+            {0, {:literal, 0}},
+            {1, {:literal, 1}},
+            {2, {:literal, 2}},
+            {3, {:literal, 3}},
+            {4, {:literal, 4}}
+          ],
+          {:literal, -1}
+        )
+
       module = make_module(chain)
       {:ok, result} = IfChainToCase.convert(module)
       body = get_body(result)
 
       assert {:case, {:var, :p0}, clauses} = body
-      assert length(clauses) == 6  # 5 literal + 1 wildcard
+      # 5 literal + 1 wildcard
+      assert length(clauses) == 6
     end
 
     test "does NOT convert chain of only 2 if-eq tests (below threshold)" do
@@ -122,10 +146,10 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
 
     test "does NOT convert if tests are on different variables" do
       # if p0 == 0 then 10 else (if p1 == 1 then 20 else (if p0 == 2 then 30 else 99))
-      mixed = {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:literal, 10},
-        {:if, {:binop, :eq, {:var, :p1}, {:literal, 1}}, {:literal, 20},
-          {:if, {:binop, :eq, {:var, :p0}, {:literal, 2}}, {:literal, 30},
-            {:literal, 99}}}}
+      mixed =
+        {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:literal, 10},
+         {:if, {:binop, :eq, {:var, :p1}, {:literal, 1}}, {:literal, 20},
+          {:if, {:binop, :eq, {:var, :p0}, {:literal, 2}}, {:literal, 30}, {:literal, 99}}}}
 
       module = make_module(mixed)
       {:ok, result} = IfChainToCase.convert(module)
@@ -137,10 +161,10 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
 
     test "preserves non-integer literal comparisons as if" do
       # Non-integer literals shouldn't be chain-matched
-      expr = {:if, {:binop, :eq, {:var, :p0}, {:literal, 1.0}}, {:literal, 10},
-        {:if, {:binop, :eq, {:var, :p0}, {:literal, 2.0}}, {:literal, 20},
-          {:if, {:binop, :eq, {:var, :p0}, {:literal, 3.0}}, {:literal, 30},
-            {:literal, 99}}}}
+      expr =
+        {:if, {:binop, :eq, {:var, :p0}, {:literal, 1.0}}, {:literal, 10},
+         {:if, {:binop, :eq, {:var, :p0}, {:literal, 2.0}}, {:literal, 20},
+          {:if, {:binop, :eq, {:var, :p0}, {:literal, 3.0}}, {:literal, 30}, {:literal, 99}}}}
 
       module = make_module(expr)
       {:ok, result} = IfChainToCase.convert(module)
@@ -151,7 +175,12 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
     end
 
     test "handles negative integer values in chain" do
-      chain = build_if_chain([{-1, {:literal, 10}}, {0, {:literal, 20}}, {1, {:literal, 30}}], {:literal, 99})
+      chain =
+        build_if_chain(
+          [{-1, {:literal, 10}}, {0, {:literal, 20}}, {1, {:literal, 30}}],
+          {:literal, 99}
+        )
+
       module = make_module(chain)
       {:ok, result} = IfChainToCase.convert(module)
       body = get_body(result)
@@ -161,10 +190,12 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
     end
 
     test "handles large integer values" do
-      chain = build_if_chain(
-        [{1000, {:literal, 1}}, {2000, {:literal, 2}}, {3000, {:literal, 3}}],
-        {:literal, 0}
-      )
+      chain =
+        build_if_chain(
+          [{1000, {:literal, 1}}, {2000, {:literal, 2}}, {3000, {:literal, 3}}],
+          {:literal, 0}
+        )
+
       module = make_module(chain)
       {:ok, result} = IfChainToCase.convert(module)
       body = get_body(result)
@@ -179,11 +210,13 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
 
   describe "convert_expr/1 recursion" do
     test "converts chains nested inside then-branches" do
-      inner_chain = build_if_chain(
-        [{0, {:literal, 100}}, {1, {:literal, 200}}, {2, {:literal, 300}}],
-        {:literal, 999},
-        :inner
-      )
+      inner_chain =
+        build_if_chain(
+          [{0, {:literal, 100}}, {1, {:literal, 200}}, {2, {:literal, 300}}],
+          {:literal, 999},
+          :inner
+        )
+
       outer = {:if, {:binop, :gt, {:var, :p0}, {:literal, 0}}, inner_chain, {:literal, -1}}
 
       module = make_module(outer)
@@ -195,11 +228,13 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
     end
 
     test "converts chains nested inside else-branches" do
-      inner_chain = build_if_chain(
-        [{0, {:literal, 100}}, {1, {:literal, 200}}, {2, {:literal, 300}}],
-        {:literal, 999},
-        :inner
-      )
+      inner_chain =
+        build_if_chain(
+          [{0, {:literal, 100}}, {1, {:literal, 200}}, {2, {:literal, 300}}],
+          {:literal, 999},
+          :inner
+        )
+
       outer = {:if, {:binop, :gt, {:var, :p0}, {:literal, 0}}, {:literal, 1}, inner_chain}
 
       module = make_module(outer)
@@ -212,16 +247,18 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
 
     test "recursively converts bodies within the generated case clauses" do
       # Inner chain as a body of an outer chain clause
-      inner_chain = build_if_chain(
-        [{10, {:literal, 100}}, {20, {:literal, 200}}, {30, {:literal, 300}}],
-        {:literal, 999},
-        :q0
-      )
-
-      outer_chain = build_if_chain(
-        [{0, inner_chain}, {1, {:literal, 2}}, {2, {:literal, 3}}],
-        {:literal, -1}
-      )
+      inner_chain =
+        build_if_chain(
+          [{10, {:literal, 100}}, {20, {:literal, 200}}, {30, {:literal, 300}}],
+          {:literal, 999},
+          :q0
+        )
+
+      outer_chain =
+        build_if_chain(
+          [{0, inner_chain}, {1, {:literal, 2}}, {2, {:literal, 3}}],
+          {:literal, -1}
+        )
 
       module = make_module(outer_chain)
       {:ok, result} = IfChainToCase.convert(module)
@@ -248,25 +285,32 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
 
     test "recurses into let expressions" do
       expr = {:let, :x, {:binop, :add, {:literal, 1}, {:literal, 2}}}
-      assert {:let, :x, {:binop, :add, {:literal, 1}, {:literal, 2}}} = IfChainToCase.convert_expr(expr)
+
+      assert {:let, :x, {:binop, :add, {:literal, 1}, {:literal, 2}}} =
+               IfChainToCase.convert_expr(expr)
     end
 
     test "recurses into block expressions" do
       expr = {:block, [{:literal, 1}, {:literal, 2}, {:literal, 3}]}
-      assert {:block, [{:literal, 1}, {:literal, 2}, {:literal, 3}]} = IfChainToCase.convert_expr(expr)
+
+      assert {:block, [{:literal, 1}, {:literal, 2}, {:literal, 3}]} =
+               IfChainToCase.convert_expr(expr)
     end
 
     test "recurses into case expressions" do
-      inner_chain = build_if_chain(
-        [{0, {:literal, 10}}, {1, {:literal, 20}}, {2, {:literal, 30}}],
-        {:literal, 99},
-        :inner
-      )
-
-      expr = {:case, {:var, :x}, [
-        {{:literal_pat, 1}, nil, inner_chain},
-        {:wildcard, nil, {:literal, 0}}
-      ]}
+      inner_chain =
+        build_if_chain(
+          [{0, {:literal, 10}}, {1, {:literal, 20}}, {2, {:literal, 30}}],
+          {:literal, 99},
+          :inner
+        )
+
+      expr =
+        {:case, {:var, :x},
+         [
+           {{:literal_pat, 1}, nil, inner_chain},
+           {:wildcard, nil, {:literal, 0}}
+         ]}
 
       result = IfChainToCase.convert_expr(expr)
 
@@ -277,7 +321,9 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
     test "recurses into tail_loop expressions" do
       expr = {:tail_loop, [{:x, {:literal, 0}}], {:binop, :add, {:var, :x}, {:literal, 1}}}
       result = IfChainToCase.convert_expr(expr)
-      assert {:tail_loop, [{:x, {:literal, 0}}], {:binop, :add, {:var, :x}, {:literal, 1}}} = result
+
+      assert {:tail_loop, [{:x, {:literal, 0}}], {:binop, :add, {:var, :x}, {:literal, 1}}} =
+               result
     end
 
     test "recurses into tail_call expressions" do
@@ -317,10 +363,10 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
 
     test "chain broken by non-eq middle test stays as nested if" do
       # if p0 == 0 then 10, else (if p0 > 1 then 20, else (if p0 == 2 then 30, else 99))
-      expr = {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:literal, 10},
-        {:if, {:binop, :gt, {:var, :p0}, {:literal, 1}}, {:literal, 20},
-          {:if, {:binop, :eq, {:var, :p0}, {:literal, 2}}, {:literal, 30},
-            {:literal, 99}}}}
+      expr =
+        {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:literal, 10},
+         {:if, {:binop, :gt, {:var, :p0}, {:literal, 1}}, {:literal, 20},
+          {:if, {:binop, :eq, {:var, :p0}, {:literal, 2}}, {:literal, 30}, {:literal, 99}}}}
 
       result = IfChainToCase.convert_expr(expr)
       # Only 1 eq clause extracted before chain breaks at :gt, stays as if
@@ -329,10 +375,12 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
 
     test "default body can be a complex expression" do
       default = {:block, [{:let, :x, {:literal, 42}}, {:binop, :mul, {:var, :x}, {:literal, 2}}]}
-      chain = build_if_chain(
-        [{0, {:literal, 0}}, {1, {:literal, 1}}, {2, {:literal, 2}}],
-        default
-      )
+
+      chain =
+        build_if_chain(
+          [{0, {:literal, 0}}, {1, {:literal, 1}}, {2, {:literal, 2}}],
+          default
+        )
 
       module = make_module(chain)
       {:ok, result} = IfChainToCase.convert(module)
@@ -344,12 +392,15 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
     end
 
     test "clause bodies can contain calls" do
-      chain = build_if_chain(
-        [{0, {:call, :foo, [{:literal, 0}]}},
-         {1, {:call, :bar, [{:literal, 1}]}},
-         {2, {:call, :baz, [{:literal, 2}]}}],
-        {:call, :default, []}
-      )
+      chain =
+        build_if_chain(
+          [
+            {0, {:call, :foo, [{:literal, 0}]}},
+            {1, {:call, :bar, [{:literal, 1}]}},
+            {2, {:call, :baz, [{:literal, 2}]}}
+          ],
+          {:call, :default, []}
+        )
 
       module = make_module(chain)
       {:ok, result} = IfChainToCase.convert(module)
@@ -367,10 +418,12 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
 
     test "handles deeply nested blocks inside chain bodies" do
       deep_block = {:block, [{:block, [{:block, [{:literal, 42}]}]}]}
-      chain = build_if_chain(
-        [{0, deep_block}, {1, {:literal, 1}}, {2, {:literal, 2}}],
-        {:literal, -1}
-      )
+
+      chain =
+        build_if_chain(
+          [{0, deep_block}, {1, {:literal, 1}}, {2, {:literal, 2}}],
+          {:literal, -1}
+        )
 
       module = make_module(chain)
       {:ok, result} = IfChainToCase.convert(module)
@@ -381,10 +434,11 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
 
     test "duplicate literal values in chain are still converted" do
       # Even if the same value appears twice, the chain structure is valid
-      chain = build_if_chain(
-        [{0, {:literal, 10}}, {0, {:literal, 20}}, {0, {:literal, 30}}],
-        {:literal, 99}
-      )
+      chain =
+        build_if_chain(
+          [{0, {:literal, 10}}, {0, {:literal, 20}}, {0, {:literal, 30}}],
+          {:literal, 99}
+        )
 
       module = make_module(chain)
       {:ok, result} = IfChainToCase.convert(module)
@@ -395,11 +449,12 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
     end
 
     test "convert_expr with chain inside call arguments" do
-      inner = build_if_chain(
-        [{0, {:literal, 10}}, {1, {:literal, 20}}, {2, {:literal, 30}}],
-        {:literal, 99},
-        :x
-      )
+      inner =
+        build_if_chain(
+          [{0, {:literal, 10}}, {1, {:literal, 20}}, {2, {:literal, 30}}],
+          {:literal, 99},
+          :x
+        )
 
       expr = {:call, :foo, [inner]}
       result = IfChainToCase.convert_expr(expr)
@@ -408,11 +463,12 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
     end
 
     test "convert_expr with chain inside let value" do
-      inner = build_if_chain(
-        [{0, {:literal, 10}}, {1, {:literal, 20}}, {2, {:literal, 30}}],
-        {:literal, 99},
-        :x
-      )
+      inner =
+        build_if_chain(
+          [{0, {:literal, 10}}, {1, {:literal, 20}}, {2, {:literal, 30}}],
+          {:literal, 99},
+          :x
+        )
 
       expr = {:let, :result, inner}
       result = IfChainToCase.convert_expr(expr)
@@ -421,11 +477,12 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
     end
 
     test "convert_expr with chain inside binop operands" do
-      inner = build_if_chain(
-        [{0, {:literal, 10}}, {1, {:literal, 20}}, {2, {:literal, 30}}],
-        {:literal, 99},
-        :x
-      )
+      inner =
+        build_if_chain(
+          [{0, {:literal, 10}}, {1, {:literal, 20}}, {2, {:literal, 30}}],
+          {:literal, 99},
+          :x
+        )
 
       expr = {:binop, :add, inner, {:literal, 1}}
       result = IfChainToCase.convert_expr(expr)
@@ -434,11 +491,12 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
     end
 
     test "convert_expr with chain inside unaryop" do
-      inner = build_if_chain(
-        [{0, {:literal, 10}}, {1, {:literal, 20}}, {2, {:literal, 30}}],
-        {:literal, 99},
-        :x
-      )
+      inner =
+        build_if_chain(
+          [{0, {:literal, 10}}, {1, {:literal, 20}}, {2, {:literal, 30}}],
+          {:literal, 99},
+          :x
+        )
 
       expr = {:unaryop, :negate, inner}
       result = IfChainToCase.convert_expr(expr)
@@ -458,33 +516,38 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
       #   def dispatch(1), do: :one
       #   def dispatch(2), do: :two
       #   def dispatch(n), do: :other
-      chain = {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:literal, 0},
-        {:if, {:binop, :eq, {:var, :p0}, {:literal, 1}}, {:literal, 1},
+      chain =
+        {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:literal, 0},
+         {:if, {:binop, :eq, {:var, :p0}, {:literal, 1}}, {:literal, 1},
           {:if, {:binop, :eq, {:var, :p0}, {:literal, 2}}, {:literal, 2},
-            {:binop, :mul, {:var, :p0}, {:literal, 10}}}}}
+           {:binop, :mul, {:var, :p0}, {:literal, 10}}}}}
 
       module = make_module(chain)
       {:ok, result} = IfChainToCase.convert(module)
       body = get_body(result)
 
       assert {:case, {:var, :p0}, clauses} = body
+
       assert [
-        {{:literal_pat, 0}, nil, {:literal, 0}},
-        {{:literal_pat, 1}, nil, {:literal, 1}},
-        {{:literal_pat, 2}, nil, {:literal, 2}},
-        {:wildcard, nil, {:binop, :mul, {:var, :p0}, {:literal, 10}}}
-      ] = clauses
+               {{:literal_pat, 0}, nil, {:literal, 0}},
+               {{:literal_pat, 1}, nil, {:literal, 1}},
+               {{:literal_pat, 2}, nil, {:literal, 2}},
+               {:wildcard, nil, {:binop, :mul, {:var, :p0}, {:literal, 10}}}
+             ] = clauses
     end
 
     test "tail-recursive function with case dispatch" do
       # Body that has a tail_loop containing a chain
-      inner_chain = build_if_chain(
-        [{0, {:tail_call, :recur, [{:literal, 0}]}},
-         {1, {:tail_call, :recur, [{:literal, 1}]}},
-         {2, {:var, :acc}}],
-        {:tail_call, :recur, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
-        :n
-      )
+      inner_chain =
+        build_if_chain(
+          [
+            {0, {:tail_call, :recur, [{:literal, 0}]}},
+            {1, {:tail_call, :recur, [{:literal, 1}]}},
+            {2, {:var, :acc}}
+          ],
+          {:tail_call, :recur, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
+          :n
+        )
 
       expr = {:tail_loop, [{:n, {:var, :p0}}, {:acc, {:literal, 0}}], inner_chain}
 
@@ -494,24 +557,28 @@ defmodule Firebird.Compiler.IfChainToCaseTest do
     end
 
     test "multiple independent chains in a block" do
-      chain1 = build_if_chain(
-        [{0, {:literal, 10}}, {1, {:literal, 20}}, {2, {:literal, 30}}],
-        {:literal, -1},
-        :x
-      )
-      chain2 = build_if_chain(
-        [{5, {:literal, 50}}, {6, {:literal, 60}}, {7, {:literal, 70}}],
-        {:literal, -2},
-        :y
-      )
+      chain1 =
+        build_if_chain(
+          [{0, {:literal, 10}}, {1, {:literal, 20}}, {2, {:literal, 30}}],
+          {:literal, -1},
+          :x
+        )
+
+      chain2 =
+        build_if_chain(
+          [{5, {:literal, 50}}, {6, {:literal, 60}}, {7, {:literal, 70}}],
+          {:literal, -2},
+          :y
+        )
 
       expr = {:block, [chain1, chain2]}
       result = IfChainToCase.convert_expr(expr)
 
-      assert {:block, [
-        {:case, {:var, :x}, _},
-        {:case, {:var, :y}, _}
-      ]} = result
+      assert {:block,
+              [
+                {:case, {:var, :x}, _},
+                {:case, {:var, :y}, _}
+              ]} = result
     end
   end
 end
diff --git a/test/compiler/inline_integration_test.exs b/test/compiler/inline_integration_test.exs
index c2dc24c..568990e 100644
--- a/test/compiler/inline_integration_test.exs
+++ b/test/compiler/inline_integration_test.exs
@@ -72,8 +72,9 @@ defmodule Firebird.Compiler.InlineIntegrationTest do
       end
       """
 
-      {:ok, result} = Firebird.Compiler.compile_source(source,
-        inline: true, optimize: true, tco: true)
+      {:ok, result} =
+        Firebird.Compiler.compile_source(source, inline: true, optimize: true, tco: true)
+
       {:ok, inst} = Firebird.load(result.wasm)
 
       # sum of (1+1) + (2+1) + ... + (10+1) = 2+3+...+11 = 65
diff --git a/test/compiler/inliner_edge_cases_test.exs b/test/compiler/inliner_edge_cases_test.exs
index 12d51ec..00dabab 100644
--- a/test/compiler/inliner_edge_cases_test.exs
+++ b/test/compiler/inliner_edge_cases_test.exs
@@ -38,10 +38,13 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
     end
 
     test "case expression counts subject + clause bodies" do
-      expr = {:case, {:var, :x}, [
-        {{:literal_pat, 0}, nil, {:literal, 1}},
-        {:wildcard, nil, {:literal, 2}}
-      ]}
+      expr =
+        {:case, {:var, :x},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 1}},
+           {:wildcard, nil, {:literal, 2}}
+         ]}
+
       # 1 (case) + 1 (var) + 1 (literal) + 1 (literal) = 4
       assert Inliner.ir_size(expr) == 4
     end
@@ -71,13 +74,11 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
 
     test "deeply nested expression" do
       # (((1 + 2) + 3) + 4) = 4 binops + 4 literals = 4*1 + 4*1 + 3 binops overhead
-      expr = {:binop, :add,
+      expr =
         {:binop, :add,
-          {:binop, :add,
-            {:literal, 1},
-            {:literal, 2}},
-          {:literal, 3}},
-        {:literal, 4}}
+         {:binop, :add, {:binop, :add, {:literal, 1}, {:literal, 2}}, {:literal, 3}},
+         {:literal, 4}}
+
       # Each binop: 1 for itself
       # 3 binops = 3, 4 literals = 4, total = 7
       assert Inliner.ir_size(expr) == 7
@@ -86,11 +87,17 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
 
   describe "inlinable?/2 edge cases" do
     test "function with tail_loop body is treated as recursive" do
-      func = make_function(:sum_acc, 2, [:n, :acc],
-        {:tail_loop, [:n, :acc],
-          {:if, {:binop, :eq, {:var, :n}, {:literal, 0}},
-            {:var, :acc},
-            {:tail_call, :sum_acc, [{:binop, :sub, {:var, :n}, {:literal, 1}}, {:binop, :add, {:var, :acc}, {:var, :n}}]}}})
+      func =
+        make_function(
+          :sum_acc,
+          2,
+          [:n, :acc],
+          {:tail_loop, [:n, :acc],
+           {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:var, :acc},
+            {:tail_call, :sum_acc,
+             [{:binop, :sub, {:var, :n}, {:literal, 1}}, {:binop, :add, {:var, :acc}, {:var, :n}}]}}}
+        )
+
       # tail_loop doesn't contain :call to :sum_acc, so has_self_calls? returns false
       # The function should be inlinable since TCO already transformed it
       # Actually TCO-transformed functions don't have self-calls anymore
@@ -101,15 +108,13 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
 
     test "exactly at max_size boundary is inlinable" do
       # {:binop, :add, {:var, :p0}, {:literal, 1}} has size 3
-      func = make_function(:inc, 1, [:p0],
-        {:binop, :add, {:var, :p0}, {:literal, 1}})
+      func = make_function(:inc, 1, [:p0], {:binop, :add, {:var, :p0}, {:literal, 1}})
       assert Inliner.ir_size(func.body) == 3
       assert Inliner.inlinable?(func, 3) == true
     end
 
     test "one over max_size is not inlinable" do
-      func = make_function(:inc, 1, [:p0],
-        {:binop, :add, {:var, :p0}, {:literal, 1}})
+      func = make_function(:inc, 1, [:p0], {:binop, :add, {:var, :p0}, {:literal, 1}})
       assert Inliner.ir_size(func.body) == 3
       assert Inliner.inlinable?(func, 2) == false
     end
@@ -126,8 +131,7 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
 
     test "mutually recursive function A calling B is inlinable (if B doesn't call A)" do
       # A calls B (not itself) - it IS inlinable
-      func_a = make_function(:a, 1, [:p0],
-        {:call, :b, [{:var, :p0}]})
+      func_a = make_function(:a, 1, [:p0], {:call, :b, [{:var, :p0}]})
       assert Inliner.inlinable?(func_a, 10) == true
     end
   end
@@ -136,7 +140,7 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
     test "builds map from inlinable functions" do
       functions = [
         make_function(:double, 1, [:p0], {:binop, :mul, {:var, :p0}, {:literal, 2}}),
-        make_function(:inc, 1, [:p0], {:binop, :add, {:var, :p0}, {:literal, 1}}),
+        make_function(:inc, 1, [:p0], {:binop, :add, {:var, :p0}, {:literal, 1}})
       ]
 
       map = Inliner.build_inline_map(functions, 10)
@@ -148,12 +152,14 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
     test "excludes recursive functions" do
       functions = [
         make_function(:double, 1, [:p0], {:binop, :mul, {:var, :p0}, {:literal, 2}}),
-        make_function(:fib, 1, [:p0],
-          {:if, {:binop, :le_s, {:var, :p0}, {:literal, 1}},
-            {:var, :p0},
-            {:binop, :add,
-              {:call, :fib, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]},
-              {:call, :fib, [{:binop, :sub, {:var, :p0}, {:literal, 2}}]}}}),
+        make_function(
+          :fib,
+          1,
+          [:p0],
+          {:if, {:binop, :le_s, {:var, :p0}, {:literal, 1}}, {:var, :p0},
+           {:binop, :add, {:call, :fib, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]},
+            {:call, :fib, [{:binop, :sub, {:var, :p0}, {:literal, 2}}]}}}
+        )
       ]
 
       map = Inliner.build_inline_map(functions, 100)
@@ -164,10 +170,13 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
     test "excludes functions larger than max_size" do
       functions = [
         make_function(:small, 1, [:p0], {:var, :p0}),
-        make_function(:big, 1, [:p0],
-          {:binop, :add,
-            {:binop, :mul, {:var, :p0}, {:literal, 2}},
-            {:binop, :sub, {:var, :p0}, {:literal, 1}}}),
+        make_function(
+          :big,
+          1,
+          [:p0],
+          {:binop, :add, {:binop, :mul, {:var, :p0}, {:literal, 2}},
+           {:binop, :sub, {:var, :p0}, {:literal, 1}}}
+        )
       ]
 
       map = Inliner.build_inline_map(functions, 3)
@@ -183,12 +192,16 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
   describe "inline/2 with no inlinable functions" do
     test "returns module unchanged when no functions are inlinable" do
       # Only a recursive function - nothing to inline
-      fib = make_function(:fib, 1, [:p0],
-        {:if, {:binop, :le_s, {:var, :p0}, {:literal, 1}},
-          {:var, :p0},
-          {:binop, :add,
-            {:call, :fib, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]},
-            {:call, :fib, [{:binop, :sub, {:var, :p0}, {:literal, 2}}]}}})
+      fib =
+        make_function(
+          :fib,
+          1,
+          [:p0],
+          {:if, {:binop, :le_s, {:var, :p0}, {:literal, 1}}, {:var, :p0},
+           {:binop, :add, {:call, :fib, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]},
+            {:call, :fib, [{:binop, :sub, {:var, :p0}, {:literal, 2}}]}}}
+        )
+
       module = make_module([fib])
 
       {:ok, result} = Inliner.inline(module)
@@ -196,10 +209,15 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
     end
 
     test "returns module unchanged when all functions exceed max_size" do
-      func = make_function(:big, 1, [:p0],
-        {:binop, :add,
-          {:binop, :mul, {:var, :p0}, {:literal, 2}},
-          {:binop, :sub, {:var, :p0}, {:literal, 1}}})
+      func =
+        make_function(
+          :big,
+          1,
+          [:p0],
+          {:binop, :add, {:binop, :mul, {:var, :p0}, {:literal, 2}},
+           {:binop, :sub, {:var, :p0}, {:literal, 1}}}
+        )
+
       module = make_module([func])
 
       {:ok, result} = Inliner.inline(module, max_size: 1)
@@ -210,10 +228,16 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
 
   describe "inline/2 with multiple parameters" do
     test "inlines function with two parameters" do
-      add = make_function(:add, 2, [:a, :b],
-        {:binop, :add, {:var, :a}, {:var, :b}})
-      compute = make_function(:compute, 2, [:x, :y],
-        {:call, :add, [{:var, :x}, {:binop, :mul, {:var, :y}, {:literal, 2}}]})
+      add = make_function(:add, 2, [:a, :b], {:binop, :add, {:var, :a}, {:var, :b}})
+
+      compute =
+        make_function(
+          :compute,
+          2,
+          [:x, :y],
+          {:call, :add, [{:var, :x}, {:binop, :mul, {:var, :y}, {:literal, 2}}]}
+        )
+
       module = make_module([add, compute])
 
       {:ok, result} = Inliner.inline(module)
@@ -226,8 +250,10 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
 
     test "inlines function with zero parameters" do
       zero = make_function(:zero, 0, [], {:literal, 0})
-      use_zero = make_function(:use_zero, 1, [:p0],
-        {:binop, :add, {:var, :p0}, {:call, :zero, []}})
+
+      use_zero =
+        make_function(:use_zero, 1, [:p0], {:binop, :add, {:var, :p0}, {:call, :zero, []}})
+
       module = make_module([zero, use_zero])
 
       {:ok, result} = Inliner.inline(module)
@@ -240,10 +266,16 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
 
   describe "inline/2 with complex expression contexts" do
     test "inlines inside if condition" do
-      is_pos = make_function(:is_pos, 1, [:n],
-        {:binop, :gt_s, {:var, :n}, {:literal, 0}})
-      check = make_function(:check, 1, [:p0],
-        {:if, {:call, :is_pos, [{:var, :p0}]}, {:literal, 1}, {:literal, 0}})
+      is_pos = make_function(:is_pos, 1, [:n], {:binop, :gt_s, {:var, :n}, {:literal, 0}})
+
+      check =
+        make_function(
+          :check,
+          1,
+          [:p0],
+          {:if, {:call, :is_pos, [{:var, :p0}]}, {:literal, 1}, {:literal, 0}}
+        )
+
       module = make_module([is_pos, check])
 
       {:ok, result} = Inliner.inline(module)
@@ -254,30 +286,38 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
     end
 
     test "inlines inside case clause body" do
-      double = make_function(:double, 1, [:n],
-        {:binop, :mul, {:var, :n}, {:literal, 2}})
-      use_case = make_function(:use_case, 1, [:p0],
-        {:case, {:var, :p0}, [
-          {{:literal_pat, 0}, nil, {:literal, 0}},
-          {:wildcard, nil, {:call, :double, [{:var, :p0}]}}
-        ]})
+      double = make_function(:double, 1, [:n], {:binop, :mul, {:var, :n}, {:literal, 2}})
+
+      use_case =
+        make_function(
+          :use_case,
+          1,
+          [:p0],
+          {:case, {:var, :p0},
+           [
+             {{:literal_pat, 0}, nil, {:literal, 0}},
+             {:wildcard, nil, {:call, :double, [{:var, :p0}]}}
+           ]}
+        )
+
       module = make_module([double, use_case])
 
       {:ok, result} = Inliner.inline(module)
       uc = Enum.find(result.functions, &(&1.name == :use_case))
 
-      expected = {:case, {:var, :p0}, [
-        {{:literal_pat, 0}, nil, {:literal, 0}},
-        {:wildcard, nil, {:binop, :mul, {:var, :p0}, {:literal, 2}}}
-      ]}
+      expected =
+        {:case, {:var, :p0},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 0}},
+           {:wildcard, nil, {:binop, :mul, {:var, :p0}, {:literal, 2}}}
+         ]}
+
       assert uc.body == expected
     end
 
     test "inlines inside let binding" do
-      inc = make_function(:inc, 1, [:n],
-        {:binop, :add, {:var, :n}, {:literal, 1}})
-      use_let = make_function(:use_let, 1, [:p0],
-        {:let, :x, {:call, :inc, [{:var, :p0}]}})
+      inc = make_function(:inc, 1, [:n], {:binop, :add, {:var, :n}, {:literal, 1}})
+      use_let = make_function(:use_let, 1, [:p0], {:let, :x, {:call, :inc, [{:var, :p0}]}})
       module = make_module([inc, use_let])
 
       {:ok, result} = Inliner.inline(module)
@@ -288,27 +328,37 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
     end
 
     test "inlines inside block" do
-      inc = make_function(:inc, 1, [:n],
-        {:binop, :add, {:var, :n}, {:literal, 1}})
-      use_block = make_function(:use_block, 1, [:p0],
-        {:block, [{:call, :inc, [{:literal, 5}]}, {:call, :inc, [{:var, :p0}]}]})
+      inc = make_function(:inc, 1, [:n], {:binop, :add, {:var, :n}, {:literal, 1}})
+
+      use_block =
+        make_function(
+          :use_block,
+          1,
+          [:p0],
+          {:block, [{:call, :inc, [{:literal, 5}]}, {:call, :inc, [{:var, :p0}]}]}
+        )
+
       module = make_module([inc, use_block])
 
       {:ok, result} = Inliner.inline(module)
       ub = Enum.find(result.functions, &(&1.name == :use_block))
 
-      expected = {:block, [
-        {:binop, :add, {:literal, 5}, {:literal, 1}},
-        {:binop, :add, {:var, :p0}, {:literal, 1}}
-      ]}
+      expected =
+        {:block,
+         [
+           {:binop, :add, {:literal, 5}, {:literal, 1}},
+           {:binop, :add, {:var, :p0}, {:literal, 1}}
+         ]}
+
       assert ub.body == expected
     end
 
     test "inlines inside unaryop" do
-      is_zero = make_function(:is_zero, 1, [:n],
-        {:binop, :eq, {:var, :n}, {:literal, 0}})
-      not_zero = make_function(:not_zero, 1, [:p0],
-        {:unaryop, :not, {:call, :is_zero, [{:var, :p0}]}})
+      is_zero = make_function(:is_zero, 1, [:n], {:binop, :eq, {:var, :n}, {:literal, 0}})
+
+      not_zero =
+        make_function(:not_zero, 1, [:p0], {:unaryop, :not, {:call, :is_zero, [{:var, :p0}]}})
+
       module = make_module([is_zero, not_zero])
 
       {:ok, result} = Inliner.inline(module)
@@ -336,10 +386,11 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
   describe "inline/2 with arity mismatch" do
     test "does not inline when arg count doesn't match param count" do
       # Define add/2 but call with 3 args (wrong arity)
-      add = make_function(:add, 2, [:a, :b],
-        {:binop, :add, {:var, :a}, {:var, :b}})
-      bad_caller = make_function(:bad, 1, [:p0],
-        {:call, :add, [{:var, :p0}, {:literal, 1}, {:literal, 2}]})
+      add = make_function(:add, 2, [:a, :b], {:binop, :add, {:var, :a}, {:var, :b}})
+
+      bad_caller =
+        make_function(:bad, 1, [:p0], {:call, :add, [{:var, :p0}, {:literal, 1}, {:literal, 2}]})
+
       module = make_module([add, bad_caller])
 
       {:ok, result} = Inliner.inline(module)
@@ -354,8 +405,10 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
     test "inlines through a chain of calls" do
       inc = make_function(:inc, 1, [:n], {:binop, :add, {:var, :n}, {:literal, 1}})
       double = make_function(:double, 1, [:n], {:binop, :mul, {:var, :n}, {:literal, 2}})
-      compute = make_function(:compute, 1, [:p0],
-        {:call, :double, [{:call, :inc, [{:var, :p0}]}]})
+
+      compute =
+        make_function(:compute, 1, [:p0], {:call, :double, [{:call, :inc, [{:var, :p0}]}]})
+
       module = make_module([inc, double, compute])
 
       {:ok, result} = Inliner.inline(module)
@@ -370,10 +423,8 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
   describe "inline/2 max_size option" do
     test "respects custom max_size" do
       # Size 3: binop + var + literal
-      double = make_function(:double, 1, [:p0],
-        {:binop, :mul, {:var, :p0}, {:literal, 2}})
-      caller = make_function(:caller, 1, [:p0],
-        {:call, :double, [{:var, :p0}]})
+      double = make_function(:double, 1, [:p0], {:binop, :mul, {:var, :p0}, {:literal, 2}})
+      caller = make_function(:caller, 1, [:p0], {:call, :double, [{:var, :p0}]})
       module = make_module([double, caller])
 
       # max_size = 2 should prevent inlining (double body has size 3)
@@ -407,6 +458,7 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
         clauses: [{:some, :clause}],
         type: %IR.FunctionType{params: [:i64], return: :i64}
       }
+
       module = make_module([func])
 
       {:ok, result} = Inliner.inline(module)
@@ -420,8 +472,7 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
 
   describe "inline/2 with calls to non-existent functions" do
     test "preserves calls to functions not in the module" do
-      caller = make_function(:caller, 1, [:p0],
-        {:call, :external_func, [{:var, :p0}]})
+      caller = make_function(:caller, 1, [:p0], {:call, :external_func, [{:var, :p0}]})
       module = make_module([caller])
 
       {:ok, result} = Inliner.inline(module)
@@ -434,10 +485,16 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
   describe "inline/2 with parameter name shadowing" do
     test "correctly substitutes when inlined function uses different param names" do
       # helper uses :n, caller uses :p0
-      helper = make_function(:helper, 1, [:n],
-        {:binop, :add, {:var, :n}, {:literal, 10}})
-      caller = make_function(:caller, 1, [:p0],
-        {:binop, :mul, {:call, :helper, [{:var, :p0}]}, {:literal, 2}})
+      helper = make_function(:helper, 1, [:n], {:binop, :add, {:var, :n}, {:literal, 10}})
+
+      caller =
+        make_function(
+          :caller,
+          1,
+          [:p0],
+          {:binop, :mul, {:call, :helper, [{:var, :p0}]}, {:literal, 2}}
+        )
+
       module = make_module([helper, caller])
 
       {:ok, result} = Inliner.inline(module)
@@ -450,10 +507,8 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
 
     test "inlined body vars not in param list remain unchanged" do
       # helper has a body that references a var not in its params (free variable)
-      helper = make_function(:helper, 1, [:n],
-        {:binop, :add, {:var, :n}, {:var, :free_var}})
-      caller = make_function(:caller, 1, [:p0],
-        {:call, :helper, [{:literal, 5}]})
+      helper = make_function(:helper, 1, [:n], {:binop, :add, {:var, :n}, {:var, :free_var}})
+      caller = make_function(:caller, 1, [:p0], {:call, :helper, [{:literal, 5}]})
       module = make_module([helper, caller])
 
       {:ok, result} = Inliner.inline(module)
@@ -468,18 +523,24 @@ defmodule Firebird.Compiler.InlinerEdgeCasesTest do
   describe "inline/2 with multiple call sites" do
     test "inlines at all call sites in same function" do
       inc = make_function(:inc, 1, [:n], {:binop, :add, {:var, :n}, {:literal, 1}})
-      multi = make_function(:multi, 1, [:p0],
-        {:binop, :add,
-          {:call, :inc, [{:var, :p0}]},
-          {:call, :inc, [{:literal, 10}]}})
+
+      multi =
+        make_function(
+          :multi,
+          1,
+          [:p0],
+          {:binop, :add, {:call, :inc, [{:var, :p0}]}, {:call, :inc, [{:literal, 10}]}}
+        )
+
       module = make_module([inc, multi])
 
       {:ok, result} = Inliner.inline(module)
       m = Enum.find(result.functions, &(&1.name == :multi))
 
-      expected = {:binop, :add,
-        {:binop, :add, {:var, :p0}, {:literal, 1}},
-        {:binop, :add, {:literal, 10}, {:literal, 1}}}
+      expected =
+        {:binop, :add, {:binop, :add, {:var, :p0}, {:literal, 1}},
+         {:binop, :add, {:literal, 10}, {:literal, 1}}}
+
       assert m.body == expected
     end
   end
diff --git a/test/compiler/inliner_test.exs b/test/compiler/inliner_test.exs
index 297d340..287b581 100644
--- a/test/compiler/inliner_test.exs
+++ b/test/compiler/inliner_test.exs
@@ -84,10 +84,13 @@ defmodule Firebird.Compiler.InlinerTest do
     end
 
     test "case expression counts subject + all clauses" do
-      expr = {:case, {:var, :x}, [
-        {{:literal_pat, 0}, nil, {:literal, 1}},
-        {:wildcard, nil, {:var, :x}}
-      ]}
+      expr =
+        {:case, {:var, :x},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 1}},
+           {:wildcard, nil, {:var, :x}}
+         ]}
+
       # 1 (case) + 1 (subject) + 1 (body1) + 1 (body2) = 4
       assert Inliner.ir_size(expr) == 4
     end
@@ -107,7 +110,10 @@ defmodule Firebird.Compiler.InlinerTest do
 
     test "recursive function is not inlinable" do
       # factorial(n) = n * factorial(n-1)
-      body = {:binop, :mul, {:var, :n}, {:call, :factorial, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}
+      body =
+        {:binop, :mul, {:var, :n},
+         {:call, :factorial, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}
+
       func = make_func(:factorial, [:n], body)
       refute Inliner.inlinable?(func, 100)
     end
@@ -138,9 +144,12 @@ defmodule Firebird.Compiler.InlinerTest do
 
     test "excludes large functions" do
       small = make_func(:small, [:n], {:literal, 1})
-      big_body = {:if, {:binop, :gt_s, {:var, :n}, {:literal, 0}},
-                   {:binop, :add, {:var, :n}, {:binop, :mul, {:var, :n}, {:literal, 2}}},
-                   {:binop, :sub, {:literal, 0}, {:var, :n}}}
+
+      big_body =
+        {:if, {:binop, :gt_s, {:var, :n}, {:literal, 0}},
+         {:binop, :add, {:var, :n}, {:binop, :mul, {:var, :n}, {:literal, 2}}},
+         {:binop, :sub, {:literal, 0}, {:var, :n}}}
+
       big = make_func(:big, [:n], big_body)
 
       map = Inliner.build_inline_map([small, big], 5)
@@ -162,22 +171,26 @@ defmodule Firebird.Compiler.InlinerTest do
       # double(n) = n * 2
       double = make_func(:double, [:n], {:binop, :mul, {:var, :n}, {:literal, 2}})
       # quadruple(n) = double(double(n))
-      quad = make_func(:quadruple, [:n],
-        {:call, :double, [{:call, :double, [{:var, :n}]}]})
+      quad = make_func(:quadruple, [:n], {:call, :double, [{:call, :double, [{:var, :n}]}]})
 
       module = make_module(:Math, [double, quad])
       {:ok, result} = Inliner.inline(module)
 
       quad_fn = Enum.find(result.functions, &(&1.name == :quadruple))
       # After inlining: ((n * 2) * 2)
-      assert {:binop, :mul, {:binop, :mul, {:var, :n}, {:literal, 2}}, {:literal, 2}} = quad_fn.body
+      assert {:binop, :mul, {:binop, :mul, {:var, :n}, {:literal, 2}}, {:literal, 2}} =
+               quad_fn.body
     end
 
     test "does not inline recursive calls" do
-      factorial = make_func(:factorial, [:n],
-        {:if, {:binop, :le_s, {:var, :n}, {:literal, 1}},
-         {:literal, 1},
-         {:binop, :mul, {:var, :n}, {:call, :factorial, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}})
+      factorial =
+        make_func(
+          :factorial,
+          [:n],
+          {:if, {:binop, :le_s, {:var, :n}, {:literal, 1}}, {:literal, 1},
+           {:binop, :mul, {:var, :n},
+            {:call, :factorial, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}}
+        )
 
       module = make_module(:Math, [factorial])
       {:ok, result} = Inliner.inline(module)
@@ -229,10 +242,15 @@ defmodule Firebird.Compiler.InlinerTest do
 
     test "inlines through if expressions" do
       inc = make_func(:inc, [:n], {:binop, :add, {:var, :n}, {:literal, 1}})
-      main = make_func(:main, [:x],
-        {:if, {:binop, :gt_s, {:var, :x}, {:literal, 0}},
-         {:call, :inc, [{:var, :x}]},
-         {:literal, 0}})
+
+      main =
+        make_func(
+          :main,
+          [:x],
+          {:if, {:binop, :gt_s, {:var, :x}, {:literal, 0}}, {:call, :inc, [{:var, :x}]},
+           {:literal, 0}}
+        )
+
       module = make_module(:Test, [inc, main])
 
       {:ok, result} = Inliner.inline(module)
@@ -242,8 +260,7 @@ defmodule Firebird.Compiler.InlinerTest do
 
     test "inlines through let expressions" do
       inc = make_func(:inc, [:n], {:binop, :add, {:var, :n}, {:literal, 1}})
-      main = make_func(:main, [:x],
-        {:let, :y, {:call, :inc, [{:var, :x}]}})
+      main = make_func(:main, [:x], {:let, :y, {:call, :inc, [{:var, :x}]}})
       module = make_module(:Test, [inc, main])
 
       {:ok, result} = Inliner.inline(module)
@@ -253,39 +270,55 @@ defmodule Firebird.Compiler.InlinerTest do
 
     test "inlines through block expressions" do
       inc = make_func(:inc, [:n], {:binop, :add, {:var, :n}, {:literal, 1}})
-      main = make_func(:main, [:x],
-        {:block, [{:call, :inc, [{:var, :x}]}, {:call, :inc, [{:literal, 5}]}]})
+
+      main =
+        make_func(
+          :main,
+          [:x],
+          {:block, [{:call, :inc, [{:var, :x}]}, {:call, :inc, [{:literal, 5}]}]}
+        )
+
       module = make_module(:Test, [inc, main])
 
       {:ok, result} = Inliner.inline(module)
       main_fn = Enum.find(result.functions, &(&1.name == :main))
-      assert {:block, [
-        {:binop, :add, {:var, :x}, {:literal, 1}},
-        {:binop, :add, {:literal, 5}, {:literal, 1}}
-      ]} = main_fn.body
+
+      assert {:block,
+              [
+                {:binop, :add, {:var, :x}, {:literal, 1}},
+                {:binop, :add, {:literal, 5}, {:literal, 1}}
+              ]} = main_fn.body
     end
 
     test "inlines through case expressions" do
       inc = make_func(:inc, [:n], {:binop, :add, {:var, :n}, {:literal, 1}})
-      main = make_func(:main, [:x],
-        {:case, {:var, :x}, [
-          {{:literal_pat, 0}, nil, {:call, :inc, [{:literal, 0}]}},
-          {:wildcard, nil, {:call, :inc, [{:var, :x}]}}
-        ]})
+
+      main =
+        make_func(
+          :main,
+          [:x],
+          {:case, {:var, :x},
+           [
+             {{:literal_pat, 0}, nil, {:call, :inc, [{:literal, 0}]}},
+             {:wildcard, nil, {:call, :inc, [{:var, :x}]}}
+           ]}
+        )
+
       module = make_module(:Test, [inc, main])
 
       {:ok, result} = Inliner.inline(module)
       main_fn = Enum.find(result.functions, &(&1.name == :main))
-      assert {:case, {:var, :x}, [
-        {{:literal_pat, 0}, nil, {:binop, :add, {:literal, 0}, {:literal, 1}}},
-        {:wildcard, nil, {:binop, :add, {:var, :x}, {:literal, 1}}}
-      ]} = main_fn.body
+
+      assert {:case, {:var, :x},
+              [
+                {{:literal_pat, 0}, nil, {:binop, :add, {:literal, 0}, {:literal, 1}}},
+                {:wildcard, nil, {:binop, :add, {:var, :x}, {:literal, 1}}}
+              ]} = main_fn.body
     end
 
     test "inlines through unaryop expressions" do
       inc = make_func(:inc, [:n], {:binop, :add, {:var, :n}, {:literal, 1}})
-      main = make_func(:main, [:x],
-        {:unaryop, :not, {:call, :inc, [{:var, :x}]}})
+      main = make_func(:main, [:x], {:unaryop, :not, {:call, :inc, [{:var, :x}]}})
       module = make_module(:Test, [inc, main])
 
       {:ok, result} = Inliner.inline(module)
@@ -296,8 +329,7 @@ defmodule Firebird.Compiler.InlinerTest do
     test "handles multi-param function inlining with correct substitution" do
       # add(a, b) = a + b
       add = make_func(:add, [:a, :b], {:binop, :add, {:var, :a}, {:var, :b}})
-      main = make_func(:main, [:x],
-        {:call, :add, [{:var, :x}, {:literal, 10}]})
+      main = make_func(:main, [:x], {:call, :add, [{:var, :x}, {:literal, 10}]})
       module = make_module(:Test, [add, main])
 
       {:ok, result} = Inliner.inline(module)
@@ -308,8 +340,7 @@ defmodule Firebird.Compiler.InlinerTest do
     test "does not inline when arg count doesn't match param count" do
       add = make_func(:add, [:a, :b], {:binop, :add, {:var, :a}, {:var, :b}})
       # Calling add with wrong number of args
-      main = make_func(:main, [:x],
-        {:call, :add, [{:var, :x}]})
+      main = make_func(:main, [:x], {:call, :add, [{:var, :x}]})
       module = make_module(:Test, [add, main])
 
       {:ok, result} = Inliner.inline(module)
diff --git a/test/compiler/ir_gen_edge_cases_test.exs b/test/compiler/ir_gen_edge_cases_test.exs
index 6829b02..6da4b4f 100644
--- a/test/compiler/ir_gen_edge_cases_test.exs
+++ b/test/compiler/ir_gen_edge_cases_test.exs
@@ -107,10 +107,12 @@ defmodule Firebird.Compiler.IRGenEdgeCasesTest do
 
       assert {:ok, %IR.Module{} = mod} = parse_and_generate(source)
       func = hd(mod.functions)
-      assert {:block, [
-        {:let, :x, {:binop, :add, {:var, _}, {:literal, 1}}},
-        {:binop, :mul, {:var, :x}, {:literal, 2}}
-      ]} = func.body
+
+      assert {:block,
+              [
+                {:let, :x, {:binop, :add, {:var, _}, {:literal, 1}}},
+                {:binop, :mul, {:var, :x}, {:literal, 2}}
+              ]} = func.body
     end
   end
 
@@ -300,14 +302,18 @@ defmodule Firebird.Compiler.IRGenEdgeCasesTest do
 
   describe "case expression in expr_to_ir" do
     test "case with multiple clauses" do
-      ast = {:case, [line: 1], [
-        {:x, [line: 1], nil},
-        [do: [
-          {:->, [line: 2], [[0], 100]},
-          {:->, [line: 3], [[1], 200]},
-          {:->, [line: 4], [[{:_, [line: 4], nil}], 300]}
-        ]]
-      ]}
+      ast =
+        {:case, [line: 1],
+         [
+           {:x, [line: 1], nil},
+           [
+             do: [
+               {:->, [line: 2], [[0], 100]},
+               {:->, [line: 3], [[1], 200]},
+               {:->, [line: 4], [[{:_, [line: 4], nil}], 300]}
+             ]
+           ]
+         ]}
 
       result = IRGen.expr_to_ir(ast)
       assert {:case, {:var, :x}, clauses} = result
diff --git a/test/compiler/ir_gen_test.exs b/test/compiler/ir_gen_test.exs
index bd2fcf1..04d7eca 100644
--- a/test/compiler/ir_gen_test.exs
+++ b/test/compiler/ir_gen_test.exs
@@ -218,7 +218,14 @@ defmodule Firebird.Compiler.IRGenTest do
     end
 
     test "converts all comparison operators" do
-      for {ast_op, ir_op} <- [{:==, :eq}, {:!=, :ne}, {:<, :lt_s}, {:>, :gt_s}, {:<=, :le_s}, {:>=, :ge_s}] do
+      for {ast_op, ir_op} <- [
+            {:==, :eq},
+            {:!=, :ne},
+            {:<, :lt_s},
+            {:>, :gt_s},
+            {:<=, :le_s},
+            {:>=, :ge_s}
+          ] do
         ast = {ast_op, [line: 1], [1, 2]}
         assert {:binop, ^ir_op, _, _} = IRGen.expr_to_ir(ast)
       end
diff --git a/test/compiler/ir_structs_edge_cases_test.exs b/test/compiler/ir_structs_edge_cases_test.exs
index 1ba8577..63afa49 100644
--- a/test/compiler/ir_structs_edge_cases_test.exs
+++ b/test/compiler/ir_structs_edge_cases_test.exs
@@ -54,6 +54,7 @@ defmodule Firebird.Compiler.IR.StructsEdgeCasesTest do
 
     test "function with typed signature" do
       func_type = %IR.FunctionType{params: [:i32, :i32], return: :i32}
+
       func = %IR.Function{
         name: :add,
         arity: 2,
@@ -99,14 +100,10 @@ defmodule Firebird.Compiler.IR.StructsEdgeCasesTest do
     end
 
     test "function with complex body expression" do
-      body = {:if,
-        {:binop, :le_s, {:var, :n}, {:literal, 1}},
-        {:var, :n},
-        {:binop, :add,
-          {:call, :fib, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
-          {:call, :fib, [{:binop, :sub, {:var, :n}, {:literal, 2}}]}
-        }
-      }
+      body =
+        {:if, {:binop, :le_s, {:var, :n}, {:literal, 1}}, {:var, :n},
+         {:binop, :add, {:call, :fib, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
+          {:call, :fib, [{:binop, :sub, {:var, :n}, {:literal, 2}}]}}}
 
       func = %IR.Function{
         name: :fib,
@@ -121,13 +118,11 @@ defmodule Firebird.Compiler.IR.StructsEdgeCasesTest do
     end
 
     test "function with tail_loop body" do
-      body = {:tail_loop, [:n, :acc],
-        {:if,
-          {:binop, :le_s, {:var, :n}, {:literal, 0}},
-          {:var, :acc},
-          {:tail_call, :loop, [{:binop, :sub, {:var, :n}, {:literal, 1}}, {:binop, :add, {:var, :acc}, {:var, :n}}]}
-        }
-      }
+      body =
+        {:tail_loop, [:n, :acc],
+         {:if, {:binop, :le_s, {:var, :n}, {:literal, 0}}, {:var, :acc},
+          {:tail_call, :loop,
+           [{:binop, :sub, {:var, :n}, {:literal, 1}}, {:binop, :add, {:var, :acc}, {:var, :n}}]}}}
 
       func = %IR.Function{
         name: :sum,
@@ -249,7 +244,10 @@ defmodule Firebird.Compiler.IR.StructsEdgeCasesTest do
 
     test "binary operation expressions" do
       assert {:binop, :add, {:var, :a}, {:var, :b}} = {:binop, :add, {:var, :a}, {:var, :b}}
-      assert {:binop, :sub, {:literal, 10}, {:literal, 3}} = {:binop, :sub, {:literal, 10}, {:literal, 3}}
+
+      assert {:binop, :sub, {:literal, 10}, {:literal, 3}} =
+               {:binop, :sub, {:literal, 10}, {:literal, 3}}
+
       assert {:binop, :mul, {:var, :x}, {:literal, 2}} = {:binop, :mul, {:var, :x}, {:literal, 2}}
     end
 
@@ -273,10 +271,12 @@ defmodule Firebird.Compiler.IR.StructsEdgeCasesTest do
     end
 
     test "nested call expressions" do
-      expr = {:call, :add, [
-        {:call, :mul, [{:var, :a}, {:literal, 2}]},
-        {:call, :mul, [{:var, :b}, {:literal, 3}]}
-      ]}
+      expr =
+        {:call, :add,
+         [
+           {:call, :mul, [{:var, :a}, {:literal, 2}]},
+           {:call, :mul, [{:var, :b}, {:literal, 3}]}
+         ]}
 
       assert {:call, :add, [left, right]} = expr
       assert {:call, :mul, _} = left
@@ -284,11 +284,7 @@ defmodule Firebird.Compiler.IR.StructsEdgeCasesTest do
     end
 
     test "if expression" do
-      expr = {:if,
-        {:binop, :eq, {:var, :x}, {:literal, 0}},
-        {:literal, 1},
-        {:literal, 0}
-      }
+      expr = {:if, {:binop, :eq, {:var, :x}, {:literal, 0}}, {:literal, 1}, {:literal, 0}}
 
       assert {:if, condition, then_branch, else_branch} = expr
       assert {:binop, :eq, _, _} = condition
@@ -297,22 +293,26 @@ defmodule Firebird.Compiler.IR.StructsEdgeCasesTest do
     end
 
     test "case expression" do
-      expr = {:case, {:var, :x}, [
-        {{:literal_pat, 0}, nil, {:literal, 1}},
-        {{:literal_pat, 1}, nil, {:literal, 1}},
-        {{:var_pat, :n}, nil, {:binop, :add, {:var, :n}, {:literal, 1}}}
-      ]}
+      expr =
+        {:case, {:var, :x},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 1}},
+           {{:literal_pat, 1}, nil, {:literal, 1}},
+           {{:var_pat, :n}, nil, {:binop, :add, {:var, :n}, {:literal, 1}}}
+         ]}
 
       assert {:case, {:var, :x}, clauses} = expr
       assert length(clauses) == 3
     end
 
     test "block expression" do
-      expr = {:block, [
-        {:let, :x, {:literal, 5}},
-        {:let, :y, {:literal, 10}},
-        {:binop, :add, {:var, :x}, {:var, :y}}
-      ]}
+      expr =
+        {:block,
+         [
+           {:let, :x, {:literal, 5}},
+           {:let, :y, {:literal, 10}},
+           {:binop, :add, {:var, :x}, {:var, :y}}
+         ]}
 
       assert {:block, statements} = expr
       assert length(statements) == 3
@@ -326,10 +326,9 @@ defmodule Firebird.Compiler.IR.StructsEdgeCasesTest do
 
     test "deeply nested expression tree" do
       # (a + b) * (c - d)
-      expr = {:binop, :mul,
-        {:binop, :add, {:var, :a}, {:var, :b}},
-        {:binop, :sub, {:var, :c}, {:var, :d}}
-      }
+      expr =
+        {:binop, :mul, {:binop, :add, {:var, :a}, {:var, :b}},
+         {:binop, :sub, {:var, :c}, {:var, :d}}}
 
       assert {:binop, :mul, left, right} = expr
       assert {:binop, :add, {:var, :a}, {:var, :b}} = left
@@ -368,12 +367,17 @@ defmodule Firebird.Compiler.IR.StructsEdgeCasesTest do
     end
 
     test "function clauses can be filtered by guard presence" do
-      c1 = %IR.Clause{patterns: [{:var_pat, :n}], guard: {:binop, :gt_s, {:var, :n}, {:literal, 0}}, body: {:var, :n}}
+      c1 = %IR.Clause{
+        patterns: [{:var_pat, :n}],
+        guard: {:binop, :gt_s, {:var, :n}, {:literal, 0}},
+        body: {:var, :n}
+      }
+
       c2 = %IR.Clause{patterns: [:wildcard], guard: nil, body: {:literal, 0}}
 
       clauses = [c1, c2]
-      guarded = Enum.filter(clauses, & &1.guard != nil)
-      unguarded = Enum.filter(clauses, & &1.guard == nil)
+      guarded = Enum.filter(clauses, &(&1.guard != nil))
+      unguarded = Enum.filter(clauses, &(&1.guard == nil))
 
       assert length(guarded) == 1
       assert length(unguarded) == 1
@@ -386,7 +390,8 @@ defmodule Firebird.Compiler.IR.StructsEdgeCasesTest do
       assert updated.name == :new
       assert updated.arity == 1
       assert updated.params == [:x]
-      assert updated.body == {:literal, 0}  # unchanged
+      # unchanged
+      assert updated.body == {:literal, 0}
     end
 
     test "structs are maps with __struct__ key" do
diff --git a/test/compiler/ir_structs_test.exs b/test/compiler/ir_structs_test.exs
index 5ba6aec..c0e8a61 100644
--- a/test/compiler/ir_structs_test.exs
+++ b/test/compiler/ir_structs_test.exs
@@ -31,7 +31,15 @@ defmodule Firebird.Compiler.IR.StructsTest do
     end
 
     test "module with functions" do
-      func = %IR.Function{name: :add, arity: 2, params: [:a, :b], body: {:literal, 0}, clauses: [], type: nil}
+      func = %IR.Function{
+        name: :add,
+        arity: 2,
+        params: [:a, :b],
+        body: {:literal, 0},
+        clauses: [],
+        type: nil
+      }
+
       mod = %IR.Module{name: :Math, functions: [func], exports: [:add]}
       assert length(mod.functions) == 1
       assert hd(mod.functions).name == :add
@@ -68,6 +76,7 @@ defmodule Firebird.Compiler.IR.StructsTest do
 
     test "function with type annotation" do
       func_type = %IR.FunctionType{params: [:i32, :i32], return: :i32}
+
       func = %IR.Function{
         name: :add,
         arity: 2,
@@ -248,6 +257,7 @@ defmodule Firebird.Compiler.IR.StructsTest do
         {{:literal_pat, 0}, nil, {:literal, 0}},
         {{:var_pat, :n}, nil, {:var, :n}}
       ]
+
       expr = {:case, {:var, :x}, clauses}
       assert elem(expr, 0) == :case
       assert length(elem(expr, 2)) == 2
@@ -267,9 +277,9 @@ defmodule Firebird.Compiler.IR.StructsTest do
 
     test "nested expressions" do
       # (a + b) * (c - d)
-      expr = {:binop, :mul,
-        {:binop, :add, {:var, :a}, {:var, :b}},
-        {:binop, :sub, {:var, :c}, {:var, :d}}}
+      expr =
+        {:binop, :mul, {:binop, :add, {:var, :a}, {:var, :b}},
+         {:binop, :sub, {:var, :c}, {:var, :d}}}
 
       assert elem(expr, 0) == :binop
       assert elem(expr, 1) == :mul
@@ -278,10 +288,9 @@ defmodule Firebird.Compiler.IR.StructsTest do
     end
 
     test "deeply nested if-else" do
-      expr = {:if, {:binop, :eq, {:var, :x}, {:literal, 0}},
-        {:literal, 1},
-        {:if, {:binop, :eq, {:var, :x}, {:literal, 1}},
-          {:literal, 1},
+      expr =
+        {:if, {:binop, :eq, {:var, :x}, {:literal, 0}}, {:literal, 1},
+         {:if, {:binop, :eq, {:var, :x}, {:literal, 1}}, {:literal, 1},
           {:call, :fibonacci, [{:binop, :sub, {:var, :x}, {:literal, 1}}]}}}
 
       assert elem(expr, 0) == :if
@@ -365,10 +374,9 @@ defmodule Firebird.Compiler.IR.StructsTest do
         name: :abs,
         arity: 1,
         params: [:x],
-        body: {:if,
-          {:binop, :lt_s, {:var, :x}, {:literal, 0}},
-          {:binop, :sub, {:literal, 0}, {:var, :x}},
-          {:var, :x}},
+        body:
+          {:if, {:binop, :lt_s, {:var, :x}, {:literal, 0}},
+           {:binop, :sub, {:literal, 0}, {:var, :x}}, {:var, :x}},
         clauses: [],
         type: %IR.FunctionType{params: [:i32], return: :i32}
       }
@@ -397,9 +405,9 @@ defmodule Firebird.Compiler.IR.StructsTest do
         %IR.Clause{
           patterns: [{:var_pat, :n}],
           guard: nil,
-          body: {:binop, :add,
-            {:call, :fibonacci, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
-            {:call, :fibonacci, [{:binop, :sub, {:var, :n}, {:literal, 2}}]}}
+          body:
+            {:binop, :add, {:call, :fibonacci, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
+             {:call, :fibonacci, [{:binop, :sub, {:var, :n}, {:literal, 2}}]}}
         }
       ]
 
@@ -407,13 +415,15 @@ defmodule Firebird.Compiler.IR.StructsTest do
         name: :fibonacci,
         arity: 1,
         params: [:n],
-        body: {:case, {:var, :n}, [
-          {{:literal_pat, 0}, nil, {:literal, 0}},
-          {{:literal_pat, 1}, nil, {:literal, 1}},
-          {{:var_pat, :n}, nil, {:binop, :add,
-            {:call, :fibonacci, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
-            {:call, :fibonacci, [{:binop, :sub, {:var, :n}, {:literal, 2}}]}}}
-        ]},
+        body:
+          {:case, {:var, :n},
+           [
+             {{:literal_pat, 0}, nil, {:literal, 0}},
+             {{:literal_pat, 1}, nil, {:literal, 1}},
+             {{:var_pat, :n}, nil,
+              {:binop, :add, {:call, :fibonacci, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
+               {:call, :fibonacci, [{:binop, :sub, {:var, :n}, {:literal, 2}}]}}}
+           ]},
         clauses: clauses,
         type: nil
       }
@@ -434,13 +444,14 @@ defmodule Firebird.Compiler.IR.StructsTest do
         name: :sum,
         arity: 2,
         params: [:n, :acc],
-        body: {:tail_loop, [:n, :acc],
-          {:if, {:binop, :le_s, {:var, :n}, {:literal, 0}},
-            {:var, :acc},
-            {:tail_call, :sum, [
-              {:binop, :sub, {:var, :n}, {:literal, 1}},
-              {:binop, :add, {:var, :acc}, {:var, :n}}
-            ]}}},
+        body:
+          {:tail_loop, [:n, :acc],
+           {:if, {:binop, :le_s, {:var, :n}, {:literal, 0}}, {:var, :acc},
+            {:tail_call, :sum,
+             [
+               {:binop, :sub, {:var, :n}, {:literal, 1}},
+               {:binop, :add, {:var, :acc}, {:var, :n}}
+             ]}}},
         clauses: [],
         type: nil
       }
@@ -471,7 +482,15 @@ defmodule Firebird.Compiler.IR.StructsTest do
     end
 
     test "can pattern match on function struct" do
-      func = %IR.Function{name: :add, arity: 2, params: [:a, :b], body: nil, clauses: [], type: nil}
+      func = %IR.Function{
+        name: :add,
+        arity: 2,
+        params: [:a, :b],
+        body: nil,
+        clauses: [],
+        type: nil
+      }
+
       assert %IR.Function{name: :add, arity: 2} = func
     end
   end
diff --git a/test/compiler/let_binding_test.exs b/test/compiler/let_binding_test.exs
index 527068d..8e693f4 100644
--- a/test/compiler/let_binding_test.exs
+++ b/test/compiler/let_binding_test.exs
@@ -163,11 +163,9 @@ defmodule Firebird.Compiler.LetBindingTest do
 
   describe "type inference for let" do
     test "infers type of let binding" do
-      assert :i64 = Firebird.Compiler.TypeInference.infer_expr_type(
-        {:let, :x, {:literal, 42}})
+      assert :i64 = Firebird.Compiler.TypeInference.infer_expr_type({:let, :x, {:literal, 42}})
 
-      assert :f64 = Firebird.Compiler.TypeInference.infer_expr_type(
-        {:let, :x, {:literal, 3.14}})
+      assert :f64 = Firebird.Compiler.TypeInference.infer_expr_type({:let, :x, {:literal, 3.14}})
     end
   end
 end
diff --git a/test/compiler/licm_test.exs b/test/compiler/licm_test.exs
index 6444301..aad1a27 100644
--- a/test/compiler/licm_test.exs
+++ b/test/compiler/licm_test.exs
@@ -24,30 +24,38 @@ defmodule Firebird.Compiler.LICMTest do
 
     test "binop of invariant operands is invariant" do
       ni = MapSet.new([:n])
+
       assert LICM.is_loop_invariant?(
-        {:binop, :mul, {:var, :base}, {:literal, 2}}, ni
-      )
+               {:binop, :mul, {:var, :base}, {:literal, 2}},
+               ni
+             )
     end
 
     test "binop with loop variable operand is not invariant" do
       ni = MapSet.new([:n])
+
       refute LICM.is_loop_invariant?(
-        {:binop, :add, {:var, :n}, {:literal, 1}}, ni
-      )
+               {:binop, :add, {:var, :n}, {:literal, 1}},
+               ni
+             )
     end
 
     test "call with invariant args is invariant" do
       ni = MapSet.new([:n])
+
       assert LICM.is_loop_invariant?(
-        {:call, :compute, [{:var, :base}, {:literal, 10}]}, ni
-      )
+               {:call, :compute, [{:var, :base}, {:literal, 10}]},
+               ni
+             )
     end
 
     test "call with non-invariant arg is not invariant" do
       ni = MapSet.new([:n])
+
       refute LICM.is_loop_invariant?(
-        {:call, :compute, [{:var, :n}, {:literal, 10}]}, ni
-      )
+               {:call, :compute, [{:var, :n}, {:literal, 10}]},
+               ni
+             )
     end
 
     test "unaryop of invariant expr is invariant" do
@@ -57,9 +65,7 @@ defmodule Firebird.Compiler.LICMTest do
 
     test "nested expression invariance" do
       ni = MapSet.new([:i, :acc])
-      expr = {:binop, :mul,
-        {:binop, :add, {:var, :x}, {:var, :y}},
-        {:literal, 3}}
+      expr = {:binop, :mul, {:binop, :add, {:var, :x}, {:var, :y}}, {:literal, 3}}
       assert LICM.is_loop_invariant?(expr, ni)
     end
   end
@@ -73,10 +79,9 @@ defmodule Firebird.Compiler.LICMTest do
       invariant = {:binop, :mul, {:var, :base}, {:var, :factor}}
 
       body =
-        {:if,
-          {:binop, :eq, {:var, :n}, {:literal, 0}},
-          {:var, :acc},
-          {:tail_call, :f, [
+        {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:var, :acc},
+         {:tail_call, :f,
+          [
             {:binop, :sub, {:var, :n}, {:literal, 1}},
             {:binop, :add, {:var, :acc}, invariant}
           ]}}
@@ -86,7 +91,8 @@ defmodule Firebird.Compiler.LICMTest do
       result = LICM.licm_expr(input, func_params, [])
 
       # Should be wrapped in a block with a let binding
-      assert {:block, [{:let, :__licm_0, ^invariant}, {:tail_loop, [:n, :acc], hoisted_body}]} = result
+      assert {:block, [{:let, :__licm_0, ^invariant}, {:tail_loop, [:n, :acc], hoisted_body}]} =
+               result
 
       # The invariant expression should be replaced with a variable ref
       assert not contains_subexpr?(hoisted_body, invariant)
@@ -96,10 +102,9 @@ defmodule Firebird.Compiler.LICMTest do
     test "does not hoist expressions depending on loop variables" do
       # n - 1 depends on loop var :n, should stay
       body =
-        {:if,
-          {:binop, :eq, {:var, :n}, {:literal, 0}},
-          {:var, :acc},
-          {:tail_call, :f, [
+        {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:var, :acc},
+         {:tail_call, :f,
+          [
             {:binop, :sub, {:var, :n}, {:literal, 1}},
             {:var, :acc}
           ]}}
@@ -114,10 +119,8 @@ defmodule Firebird.Compiler.LICMTest do
     test "does not hoist expressions smaller than min_size" do
       # {:var, :base} has size 1, below default min_size of 2
       body =
-        {:if,
-          {:binop, :eq, {:var, :n}, {:literal, 0}},
-          {:var, :base},
-          {:tail_call, :f, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}
+        {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:var, :base},
+         {:tail_call, :f, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}
 
       input = {:tail_loop, [:n], body}
       result = LICM.licm_expr(input, MapSet.new([:n, :base]), [])
@@ -130,10 +133,9 @@ defmodule Firebird.Compiler.LICMTest do
       inv2 = {:binop, :mul, {:var, :c}, {:literal, 3}}
 
       body =
-        {:if,
-          {:binop, :eq, {:var, :n}, {:literal, 0}},
-          inv1,
-          {:tail_call, :f, [
+        {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, inv1,
+         {:tail_call, :f,
+          [
             {:binop, :sub, {:var, :n}, {:literal, 1}},
             {:binop, :add, inv1, inv2}
           ]}}
@@ -143,26 +145,29 @@ defmodule Firebird.Compiler.LICMTest do
 
       # Both invariants should be hoisted
       assert {:block, lets_and_loop} = result
-      lets = Enum.filter(lets_and_loop, fn
-        {:let, _, _} -> true
-        _ -> false
-      end)
+
+      lets =
+        Enum.filter(lets_and_loop, fn
+          {:let, _, _} -> true
+          _ -> false
+        end)
+
       assert length(lets) >= 1
     end
 
     test "does not hoist let-bound inner variables" do
       # Expression referencing a let-bound name inside the loop
       body =
-        {:block, [
-          {:let, :tmp, {:binop, :add, {:var, :n}, {:literal, 1}}},
-          {:if,
-            {:binop, :eq, {:var, :n}, {:literal, 0}},
-            {:var, :acc},
-            {:tail_call, :f, [
-              {:var, :tmp},
-              {:binop, :add, {:var, :acc}, {:var, :tmp}}
-            ]}}
-        ]}
+        {:block,
+         [
+           {:let, :tmp, {:binop, :add, {:var, :n}, {:literal, 1}}},
+           {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:var, :acc},
+            {:tail_call, :f,
+             [
+               {:var, :tmp},
+               {:binop, :add, {:var, :acc}, {:var, :tmp}}
+             ]}}
+         ]}
 
       input = {:tail_loop, [:n, :acc], body}
       result = LICM.licm_expr(input, MapSet.new([:n, :acc]), [])
@@ -181,18 +186,15 @@ defmodule Firebird.Compiler.LICMTest do
       inner_invariant = {:binop, :mul, {:var, :x}, {:literal, 2}}
 
       inner_body =
-        {:if,
-          {:binop, :eq, {:var, :i}, {:literal, 0}},
-          {:var, :acc},
-          {:tail_call, :inner, [
+        {:if, {:binop, :eq, {:var, :i}, {:literal, 0}}, {:var, :acc},
+         {:tail_call, :inner,
+          [
             {:binop, :sub, {:var, :i}, {:literal, 1}},
             {:binop, :add, {:var, :acc}, inner_invariant}
           ]}}
 
       # A tail_loop inside an if
-      expr = {:if, {:literal, 1},
-        {:tail_loop, [:i, :acc], inner_body},
-        {:literal, 0}}
+      expr = {:if, {:literal, 1}, {:tail_loop, [:i, :acc], inner_body}, {:literal, 0}}
 
       result = LICM.licm_expr(expr, MapSet.new([:i, :acc, :x]), [])
 
@@ -211,14 +213,14 @@ defmodule Firebird.Compiler.LICMTest do
         name: :scale_sum,
         arity: 4,
         params: [:n, :acc, :base, :factor],
-        body: {:tail_loop, [:n, :acc],
-          {:if,
-            {:binop, :eq, {:var, :n}, {:literal, 0}},
-            {:var, :acc},
-            {:tail_call, :scale_sum, [
-              {:binop, :sub, {:var, :n}, {:literal, 1}},
-              {:binop, :add, {:var, :acc}, invariant}
-            ]}}},
+        body:
+          {:tail_loop, [:n, :acc],
+           {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:var, :acc},
+            {:tail_call, :scale_sum,
+             [
+               {:binop, :sub, {:var, :n}, {:literal, 1}},
+               {:binop, :add, {:var, :acc}, invariant}
+             ]}}},
         clauses: nil,
         type: nil
       }
@@ -241,13 +243,13 @@ defmodule Firebird.Compiler.LICMTest do
         name: :count_down,
         arity: 1,
         params: [:n],
-        body: {:tail_loop, [:n],
-          {:if,
-            {:binop, :eq, {:var, :n}, {:literal, 0}},
-            {:literal, 0},
-            {:tail_call, :count_down, [
-              {:binop, :sub, {:var, :n}, {:literal, 1}}
-            ]}}},
+        body:
+          {:tail_loop, [:n],
+           {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:literal, 0},
+            {:tail_call, :count_down,
+             [
+               {:binop, :sub, {:var, :n}, {:literal, 1}}
+             ]}}},
         clauses: nil,
         type: nil
       }
@@ -306,8 +308,8 @@ defmodule Firebird.Compiler.LICMTest do
       """
 
       # Compile with optimize + tco to trigger LICM
-      assert {:ok, result} = Firebird.Compiler.compile_source(source,
-        optimize: true, tco: true, wat_only: true)
+      assert {:ok, result} =
+               Firebird.Compiler.compile_source(source, optimize: true, tco: true, wat_only: true)
 
       assert result.wat != nil
       assert String.contains?(result.wat, "loop")
diff --git a/test/compiler/optimizer_algebraic_test.exs b/test/compiler/optimizer_algebraic_test.exs
index 3475e5d..6eb697e 100644
--- a/test/compiler/optimizer_algebraic_test.exs
+++ b/test/compiler/optimizer_algebraic_test.exs
@@ -155,6 +155,7 @@ defmodule Firebird.Compiler.OptimizerAlgebraicTest do
 
     test "not(not(not(x))) → not(x)" do
       inner = {:unaryop, :not, {:var, :x}}
+
       assert Optimizer.algebraic_simplify({:unaryop, :not, {:unaryop, :not, inner}}) ==
                inner
     end
@@ -166,8 +167,7 @@ defmodule Firebird.Compiler.OptimizerAlgebraicTest do
     test "simplifies inside if branches" do
       result =
         Optimizer.algebraic_simplify(
-          {:if, {:var, :c},
-           {:binop, :sub, {:var, :x}, {:var, :x}},
+          {:if, {:var, :c}, {:binop, :sub, {:var, :x}, {:var, :x}},
            {:binop, :bxor, {:var, :y}, {:var, :y}}}
         )
 
@@ -177,10 +177,11 @@ defmodule Firebird.Compiler.OptimizerAlgebraicTest do
     test "simplifies inside blocks" do
       result =
         Optimizer.algebraic_simplify(
-          {:block, [
-            {:let, :a, {:binop, :band, {:var, :x}, {:var, :x}}},
-            {:var, :a}
-          ]}
+          {:block,
+           [
+             {:let, :a, {:binop, :band, {:var, :x}, {:var, :x}}},
+             {:var, :a}
+           ]}
         )
 
       assert result == {:block, [{:let, :a, {:var, :x}}, {:var, :a}]}
@@ -188,9 +189,7 @@ defmodule Firebird.Compiler.OptimizerAlgebraicTest do
 
     test "simplifies inside call arguments" do
       result =
-        Optimizer.algebraic_simplify(
-          {:call, :foo, [{:binop, :sub, {:var, :x}, {:var, :x}}]}
-        )
+        Optimizer.algebraic_simplify({:call, :foo, [{:binop, :sub, {:var, :x}, {:var, :x}}]})
 
       assert result == {:call, :foo, [{:literal, 0}]}
     end
@@ -198,16 +197,19 @@ defmodule Firebird.Compiler.OptimizerAlgebraicTest do
     test "simplifies inside case bodies" do
       result =
         Optimizer.algebraic_simplify(
-          {:case, {:var, :n}, [
-            {{:literal_pat, 0}, nil, {:binop, :eq, {:var, :a}, {:var, :a}}},
-            {:wildcard, nil, {:var, :n}}
-          ]}
+          {:case, {:var, :n},
+           [
+             {{:literal_pat, 0}, nil, {:binop, :eq, {:var, :a}, {:var, :a}}},
+             {:wildcard, nil, {:var, :n}}
+           ]}
         )
 
-      assert result == {:case, {:var, :n}, [
-        {{:literal_pat, 0}, nil, {:literal, 1}},
-        {:wildcard, nil, {:var, :n}}
-      ]}
+      assert result ==
+               {:case, {:var, :n},
+                [
+                  {{:literal_pat, 0}, nil, {:literal, 1}},
+                  {:wildcard, nil, {:var, :n}}
+                ]}
     end
 
     test "simplifies inside tail_loop body" do
@@ -283,8 +285,8 @@ defmodule Firebird.Compiler.OptimizerAlgebraicTest do
             name: :short_circuit,
             arity: 1,
             params: [:p0],
-            body: {:if, {:binop, :and_, {:literal, 0}, {:var, :p0}},
-                   {:literal, 42}, {:literal, 99}},
+            body:
+              {:if, {:binop, :and_, {:literal, 0}, {:var, :p0}}, {:literal, 42}, {:literal, 99}},
             clauses: [],
             type: nil
           }
@@ -306,8 +308,7 @@ defmodule Firebird.Compiler.OptimizerAlgebraicTest do
             name: :always_true,
             arity: 1,
             params: [:p0],
-            body: {:if, {:binop, :eq, {:var, :p0}, {:var, :p0}},
-                   {:literal, 1}, {:literal, 0}},
+            body: {:if, {:binop, :eq, {:var, :p0}, {:var, :p0}}, {:literal, 1}, {:literal, 0}},
             clauses: [],
             type: nil
           }
diff --git a/test/compiler/optimizer_comprehensive_test.exs b/test/compiler/optimizer_comprehensive_test.exs
index d7dc32f..f3c00fe 100644
--- a/test/compiler/optimizer_comprehensive_test.exs
+++ b/test/compiler/optimizer_comprehensive_test.exs
@@ -43,19 +43,23 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
     end
 
     test "folds subtraction of two literals" do
-      assert {:literal, 7} = Optimizer.constant_fold({:binop, :sub, {:literal, 10}, {:literal, 3}})
+      assert {:literal, 7} =
+               Optimizer.constant_fold({:binop, :sub, {:literal, 10}, {:literal, 3}})
     end
 
     test "folds multiplication of two literals" do
-      assert {:literal, 42} = Optimizer.constant_fold({:binop, :mul, {:literal, 6}, {:literal, 7}})
+      assert {:literal, 42} =
+               Optimizer.constant_fold({:binop, :mul, {:literal, 6}, {:literal, 7}})
     end
 
     test "folds division of two literals" do
-      assert {:literal, 5} = Optimizer.constant_fold({:binop, :div_s, {:literal, 10}, {:literal, 2}})
+      assert {:literal, 5} =
+               Optimizer.constant_fold({:binop, :div_s, {:literal, 10}, {:literal, 2}})
     end
 
     test "folds remainder of two literals" do
-      assert {:literal, 1} = Optimizer.constant_fold({:binop, :rem_s, {:literal, 7}, {:literal, 3}})
+      assert {:literal, 1} =
+               Optimizer.constant_fold({:binop, :rem_s, {:literal, 7}, {:literal, 3}})
     end
 
     test "does NOT fold division by zero" do
@@ -69,20 +73,26 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
     end
 
     test "folds negative arithmetic" do
-      assert {:literal, -5} = Optimizer.constant_fold({:binop, :add, {:literal, -2}, {:literal, -3}})
-      assert {:literal, 6} = Optimizer.constant_fold({:binop, :mul, {:literal, -2}, {:literal, -3}})
+      assert {:literal, -5} =
+               Optimizer.constant_fold({:binop, :add, {:literal, -2}, {:literal, -3}})
+
+      assert {:literal, 6} =
+               Optimizer.constant_fold({:binop, :mul, {:literal, -2}, {:literal, -3}})
     end
 
     test "folds zero arithmetic" do
       assert {:literal, 0} = Optimizer.constant_fold({:binop, :add, {:literal, 0}, {:literal, 0}})
-      assert {:literal, 0} = Optimizer.constant_fold({:binop, :mul, {:literal, 0}, {:literal, 999}})
+
+      assert {:literal, 0} =
+               Optimizer.constant_fold({:binop, :mul, {:literal, 0}, {:literal, 999}})
     end
 
     test "folds nested constant expressions" do
       # (2 + 3) * (4 + 1) = 5 * 5 = 25
-      expr = {:binop, :mul,
-        {:binop, :add, {:literal, 2}, {:literal, 3}},
-        {:binop, :add, {:literal, 4}, {:literal, 1}}}
+      expr =
+        {:binop, :mul, {:binop, :add, {:literal, 2}, {:literal, 3}},
+         {:binop, :add, {:literal, 4}, {:literal, 1}}}
+
       assert {:literal, 25} = Optimizer.constant_fold(expr)
     end
 
@@ -93,13 +103,13 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
 
     test "folds deeply nested constants" do
       # ((1 + 2) + (3 + 4)) + ((5 + 6) + (7 + 8))
-      expr = {:binop, :add,
+      expr =
         {:binop, :add,
-          {:binop, :add, {:literal, 1}, {:literal, 2}},
+         {:binop, :add, {:binop, :add, {:literal, 1}, {:literal, 2}},
           {:binop, :add, {:literal, 3}, {:literal, 4}}},
-        {:binop, :add,
-          {:binop, :add, {:literal, 5}, {:literal, 6}},
+         {:binop, :add, {:binop, :add, {:literal, 5}, {:literal, 6}},
           {:binop, :add, {:literal, 7}, {:literal, 8}}}}
+
       assert {:literal, 36} = Optimizer.constant_fold(expr)
     end
   end
@@ -116,36 +126,61 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
     end
 
     test "folds lt_s" do
-      assert {:literal, 1} = Optimizer.constant_fold({:binop, :lt_s, {:literal, 3}, {:literal, 5}})
-      assert {:literal, 0} = Optimizer.constant_fold({:binop, :lt_s, {:literal, 5}, {:literal, 3}})
-      assert {:literal, 0} = Optimizer.constant_fold({:binop, :lt_s, {:literal, 5}, {:literal, 5}})
+      assert {:literal, 1} =
+               Optimizer.constant_fold({:binop, :lt_s, {:literal, 3}, {:literal, 5}})
+
+      assert {:literal, 0} =
+               Optimizer.constant_fold({:binop, :lt_s, {:literal, 5}, {:literal, 3}})
+
+      assert {:literal, 0} =
+               Optimizer.constant_fold({:binop, :lt_s, {:literal, 5}, {:literal, 5}})
     end
 
     test "folds gt_s" do
-      assert {:literal, 1} = Optimizer.constant_fold({:binop, :gt_s, {:literal, 5}, {:literal, 3}})
-      assert {:literal, 0} = Optimizer.constant_fold({:binop, :gt_s, {:literal, 3}, {:literal, 5}})
+      assert {:literal, 1} =
+               Optimizer.constant_fold({:binop, :gt_s, {:literal, 5}, {:literal, 3}})
+
+      assert {:literal, 0} =
+               Optimizer.constant_fold({:binop, :gt_s, {:literal, 3}, {:literal, 5}})
     end
 
     test "folds le_s" do
-      assert {:literal, 1} = Optimizer.constant_fold({:binop, :le_s, {:literal, 3}, {:literal, 5}})
-      assert {:literal, 1} = Optimizer.constant_fold({:binop, :le_s, {:literal, 5}, {:literal, 5}})
-      assert {:literal, 0} = Optimizer.constant_fold({:binop, :le_s, {:literal, 6}, {:literal, 5}})
+      assert {:literal, 1} =
+               Optimizer.constant_fold({:binop, :le_s, {:literal, 3}, {:literal, 5}})
+
+      assert {:literal, 1} =
+               Optimizer.constant_fold({:binop, :le_s, {:literal, 5}, {:literal, 5}})
+
+      assert {:literal, 0} =
+               Optimizer.constant_fold({:binop, :le_s, {:literal, 6}, {:literal, 5}})
     end
 
     test "folds ge_s" do
-      assert {:literal, 1} = Optimizer.constant_fold({:binop, :ge_s, {:literal, 5}, {:literal, 3}})
-      assert {:literal, 1} = Optimizer.constant_fold({:binop, :ge_s, {:literal, 5}, {:literal, 5}})
-      assert {:literal, 0} = Optimizer.constant_fold({:binop, :ge_s, {:literal, 3}, {:literal, 5}})
+      assert {:literal, 1} =
+               Optimizer.constant_fold({:binop, :ge_s, {:literal, 5}, {:literal, 3}})
+
+      assert {:literal, 1} =
+               Optimizer.constant_fold({:binop, :ge_s, {:literal, 5}, {:literal, 5}})
+
+      assert {:literal, 0} =
+               Optimizer.constant_fold({:binop, :ge_s, {:literal, 3}, {:literal, 5}})
     end
   end
 
   describe "constant_fold/1 - logical operators" do
     test "folds and_" do
-      assert {:literal, 1} = Optimizer.constant_fold({:binop, :and_, {:literal, 1}, {:literal, 1}})
-      assert {:literal, 0} = Optimizer.constant_fold({:binop, :and_, {:literal, 1}, {:literal, 0}})
-      assert {:literal, 0} = Optimizer.constant_fold({:binop, :and_, {:literal, 0}, {:literal, 0}})
+      assert {:literal, 1} =
+               Optimizer.constant_fold({:binop, :and_, {:literal, 1}, {:literal, 1}})
+
+      assert {:literal, 0} =
+               Optimizer.constant_fold({:binop, :and_, {:literal, 1}, {:literal, 0}})
+
+      assert {:literal, 0} =
+               Optimizer.constant_fold({:binop, :and_, {:literal, 0}, {:literal, 0}})
+
       # Non-zero values are truthy
-      assert {:literal, 1} = Optimizer.constant_fold({:binop, :and_, {:literal, 42}, {:literal, 7}})
+      assert {:literal, 1} =
+               Optimizer.constant_fold({:binop, :and_, {:literal, 42}, {:literal, 7}})
     end
 
     test "folds or_" do
@@ -161,11 +196,13 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
     end
 
     test "folds shr_s" do
-      assert {:literal, 2} = Optimizer.constant_fold({:binop, :shr_s, {:literal, 8}, {:literal, 2}})
+      assert {:literal, 2} =
+               Optimizer.constant_fold({:binop, :shr_s, {:literal, 8}, {:literal, 2}})
     end
 
     test "folds band" do
-      assert {:literal, 3} = Optimizer.constant_fold({:binop, :band, {:literal, 7}, {:literal, 3}})
+      assert {:literal, 3} =
+               Optimizer.constant_fold({:binop, :band, {:literal, 7}, {:literal, 3}})
     end
   end
 
@@ -188,15 +225,19 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
 
   describe "constant_fold/1 - composite IR nodes" do
     test "folds constants inside if expression" do
-      expr = {:if, {:binop, :eq, {:literal, 1}, {:literal, 1}},
-        {:binop, :add, {:literal, 2}, {:literal, 3}},
-        {:binop, :mul, {:literal, 4}, {:literal, 5}}}
+      expr =
+        {:if, {:binop, :eq, {:literal, 1}, {:literal, 1}},
+         {:binop, :add, {:literal, 2}, {:literal, 3}},
+         {:binop, :mul, {:literal, 4}, {:literal, 5}}}
+
       result = Optimizer.constant_fold(expr)
       assert {:if, {:literal, 1}, {:literal, 5}, {:literal, 20}} = result
     end
 
     test "folds constants inside call args" do
-      result = Optimizer.constant_fold({:call, :foo, [{:binop, :add, {:literal, 1}, {:literal, 2}}]})
+      result =
+        Optimizer.constant_fold({:call, :foo, [{:binop, :add, {:literal, 1}, {:literal, 2}}]})
+
       assert {:call, :foo, [{:literal, 3}]} = result
     end
 
@@ -206,33 +247,45 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
     end
 
     test "folds constants inside block" do
-      result = Optimizer.constant_fold({:block, [
-        {:binop, :add, {:literal, 1}, {:literal, 2}},
-        {:binop, :mul, {:literal, 3}, {:literal, 4}}
-      ]})
+      result =
+        Optimizer.constant_fold(
+          {:block,
+           [
+             {:binop, :add, {:literal, 1}, {:literal, 2}},
+             {:binop, :mul, {:literal, 3}, {:literal, 4}}
+           ]}
+        )
+
       assert {:block, [{:literal, 3}, {:literal, 12}]} = result
     end
 
     test "folds constants inside tail_loop body" do
-      result = Optimizer.constant_fold(
-        {:tail_loop, [:n, :acc], {:binop, :add, {:literal, 1}, {:literal, 2}}}
-      )
+      result =
+        Optimizer.constant_fold(
+          {:tail_loop, [:n, :acc], {:binop, :add, {:literal, 1}, {:literal, 2}}}
+        )
+
       assert {:tail_loop, [:n, :acc], {:literal, 3}} = result
     end
 
     test "folds constants inside tail_call args" do
-      result = Optimizer.constant_fold(
-        {:tail_call, :loop, [{:binop, :add, {:literal, 1}, {:literal, 2}}, {:var, :acc}]}
-      )
+      result =
+        Optimizer.constant_fold(
+          {:tail_call, :loop, [{:binop, :add, {:literal, 1}, {:literal, 2}}, {:var, :acc}]}
+        )
+
       assert {:tail_call, :loop, [{:literal, 3}, {:var, :acc}]} = result
     end
 
     test "folds constants inside case clauses" do
-      result = Optimizer.constant_fold(
-        {:case, {:binop, :add, {:literal, 0}, {:literal, 0}}, [
-          {{:literal, 0}, nil, {:binop, :add, {:literal, 10}, {:literal, 20}}}
-        ]}
-      )
+      result =
+        Optimizer.constant_fold(
+          {:case, {:binop, :add, {:literal, 0}, {:literal, 0}},
+           [
+             {{:literal, 0}, nil, {:binop, :add, {:literal, 10}, {:literal, 20}}}
+           ]}
+        )
+
       assert {:case, {:literal, 0}, [{{:literal, 0}, nil, {:literal, 30}}]} = result
     end
 
@@ -255,106 +308,109 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
 
   describe "dead_code_elim/1" do
     test "eliminates false branch when condition is 0" do
-      result = Optimizer.dead_code_elim(
-        {:if, {:literal, 0}, {:literal, 10}, {:literal, 20}}
-      )
+      result = Optimizer.dead_code_elim({:if, {:literal, 0}, {:literal, 10}, {:literal, 20}})
       assert {:literal, 20} = result
     end
 
     test "eliminates else branch when condition is non-zero" do
-      result = Optimizer.dead_code_elim(
-        {:if, {:literal, 1}, {:literal, 10}, {:literal, 20}}
-      )
+      result = Optimizer.dead_code_elim({:if, {:literal, 1}, {:literal, 10}, {:literal, 20}})
       assert {:literal, 10} = result
     end
 
     test "eliminates else branch for any non-zero truthy literal" do
-      result = Optimizer.dead_code_elim(
-        {:if, {:literal, 42}, {:literal, 10}, {:literal, 20}}
-      )
+      result = Optimizer.dead_code_elim({:if, {:literal, 42}, {:literal, 10}, {:literal, 20}})
       assert {:literal, 10} = result
 
-      result = Optimizer.dead_code_elim(
-        {:if, {:literal, -1}, {:literal, 10}, {:literal, 20}}
-      )
+      result = Optimizer.dead_code_elim({:if, {:literal, -1}, {:literal, 10}, {:literal, 20}})
       assert {:literal, 10} = result
     end
 
     test "does not eliminate when condition is a variable" do
-      result = Optimizer.dead_code_elim(
-        {:if, {:var, :x}, {:literal, 10}, {:literal, 20}}
-      )
+      result = Optimizer.dead_code_elim({:if, {:var, :x}, {:literal, 10}, {:literal, 20}})
       assert {:if, {:var, :x}, {:literal, 10}, {:literal, 20}} = result
     end
 
     test "recursively eliminates in nested if" do
       # if(1) { if(0) { 10 } { 20 } } { 30 }
       # => if(0) { 10 } { 20 }  => 20
-      result = Optimizer.dead_code_elim(
-        {:if, {:literal, 1},
-          {:if, {:literal, 0}, {:literal, 10}, {:literal, 20}},
-          {:literal, 30}}
-      )
+      result =
+        Optimizer.dead_code_elim(
+          {:if, {:literal, 1}, {:if, {:literal, 0}, {:literal, 10}, {:literal, 20}},
+           {:literal, 30}}
+        )
+
       assert {:literal, 20} = result
     end
 
     test "propagates through binop" do
-      result = Optimizer.dead_code_elim(
-        {:binop, :add,
-          {:if, {:literal, 0}, {:literal, 1}, {:literal, 2}},
-          {:if, {:literal, 1}, {:literal, 3}, {:literal, 4}}}
-      )
+      result =
+        Optimizer.dead_code_elim(
+          {:binop, :add, {:if, {:literal, 0}, {:literal, 1}, {:literal, 2}},
+           {:if, {:literal, 1}, {:literal, 3}, {:literal, 4}}}
+        )
+
       assert {:binop, :add, {:literal, 2}, {:literal, 3}} = result
     end
 
     test "propagates through unaryop" do
-      result = Optimizer.dead_code_elim(
-        {:unaryop, :not, {:if, {:literal, 1}, {:literal, 5}, {:literal, 10}}}
-      )
+      result =
+        Optimizer.dead_code_elim(
+          {:unaryop, :not, {:if, {:literal, 1}, {:literal, 5}, {:literal, 10}}}
+        )
+
       assert {:unaryop, :not, {:literal, 5}} = result
     end
 
     test "propagates through call args" do
-      result = Optimizer.dead_code_elim(
-        {:call, :foo, [{:if, {:literal, 0}, {:literal, 1}, {:literal, 2}}]}
-      )
+      result =
+        Optimizer.dead_code_elim(
+          {:call, :foo, [{:if, {:literal, 0}, {:literal, 1}, {:literal, 2}}]}
+        )
+
       assert {:call, :foo, [{:literal, 2}]} = result
     end
 
     test "propagates through let binding" do
-      result = Optimizer.dead_code_elim(
-        {:let, :x, {:if, {:literal, 1}, {:literal, 42}, {:literal, 0}}}
-      )
+      result =
+        Optimizer.dead_code_elim({:let, :x, {:if, {:literal, 1}, {:literal, 42}, {:literal, 0}}})
+
       assert {:let, :x, {:literal, 42}} = result
     end
 
     test "propagates through block" do
-      result = Optimizer.dead_code_elim(
-        {:block, [{:if, {:literal, 0}, {:literal, 1}, {:literal, 2}}]}
-      )
+      result =
+        Optimizer.dead_code_elim({:block, [{:if, {:literal, 0}, {:literal, 1}, {:literal, 2}}]})
+
       assert {:block, [{:literal, 2}]} = result
     end
 
     test "propagates through tail_loop body" do
-      result = Optimizer.dead_code_elim(
-        {:tail_loop, [:n], {:if, {:literal, 1}, {:literal, 99}, {:literal, 0}}}
-      )
+      result =
+        Optimizer.dead_code_elim(
+          {:tail_loop, [:n], {:if, {:literal, 1}, {:literal, 99}, {:literal, 0}}}
+        )
+
       assert {:tail_loop, [:n], {:literal, 99}} = result
     end
 
     test "propagates through tail_call args" do
-      result = Optimizer.dead_code_elim(
-        {:tail_call, :loop, [{:if, {:literal, 0}, {:literal, 1}, {:literal, 2}}]}
-      )
+      result =
+        Optimizer.dead_code_elim(
+          {:tail_call, :loop, [{:if, {:literal, 0}, {:literal, 1}, {:literal, 2}}]}
+        )
+
       assert {:tail_call, :loop, [{:literal, 2}]} = result
     end
 
     test "propagates through case clauses" do
-      result = Optimizer.dead_code_elim(
-        {:case, {:var, :x}, [
-          {{:literal, 0}, nil, {:if, {:literal, 1}, {:literal, 42}, {:literal, 0}}}
-        ]}
-      )
+      result =
+        Optimizer.dead_code_elim(
+          {:case, {:var, :x},
+           [
+             {{:literal, 0}, nil, {:if, {:literal, 1}, {:literal, 42}, {:literal, 0}}}
+           ]}
+        )
+
       assert {:case, {:var, :x}, [{{:literal, 0}, nil, {:literal, 42}}]} = result
     end
 
@@ -471,69 +527,83 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
 
   describe "strength_reduce/1 - recursive propagation" do
     test "propagates through if branches" do
-      expr = {:if, {:var, :cond},
-        {:binop, :mul, {:var, :x}, {:literal, 4}},
-        {:binop, :div_s, {:var, :x}, {:literal, 2}}}
+      expr =
+        {:if, {:var, :cond}, {:binop, :mul, {:var, :x}, {:literal, 4}},
+         {:binop, :div_s, {:var, :x}, {:literal, 2}}}
+
       result = Optimizer.strength_reduce(expr)
-      assert {:if, {:var, :cond},
-        {:binop, :shl, {:var, :x}, {:literal, 2}},
-        {:binop, :shr_s, {:var, :x}, {:literal, 1}}} = result
+
+      assert {:if, {:var, :cond}, {:binop, :shl, {:var, :x}, {:literal, 2}},
+              {:binop, :shr_s, {:var, :x}, {:literal, 1}}} = result
     end
 
     test "propagates through call args" do
-      result = Optimizer.strength_reduce(
-        {:call, :foo, [{:binop, :mul, {:var, :x}, {:literal, 8}}]}
-      )
+      result =
+        Optimizer.strength_reduce({:call, :foo, [{:binop, :mul, {:var, :x}, {:literal, 8}}]})
+
       assert {:call, :foo, [{:binop, :shl, {:var, :x}, {:literal, 3}}]} = result
     end
 
     test "propagates through unaryop" do
-      result = Optimizer.strength_reduce(
-        {:unaryop, :not, {:binop, :rem_s, {:var, :n}, {:literal, 2}}}
-      )
+      result =
+        Optimizer.strength_reduce({:unaryop, :not, {:binop, :rem_s, {:var, :n}, {:literal, 2}}})
+
       assert {:unaryop, :not, {:binop, :band, {:var, :n}, {:literal, 1}}} = result
     end
 
     test "propagates through let" do
-      result = Optimizer.strength_reduce(
-        {:let, :doubled, {:binop, :mul, {:var, :x}, {:literal, 2}}}
-      )
+      result =
+        Optimizer.strength_reduce({:let, :doubled, {:binop, :mul, {:var, :x}, {:literal, 2}}})
+
       assert {:let, :doubled, {:binop, :shl, {:var, :x}, {:literal, 1}}} = result
     end
 
     test "propagates through block" do
-      result = Optimizer.strength_reduce(
-        {:block, [{:binop, :mul, {:var, :a}, {:literal, 4}}, {:binop, :div_s, {:var, :b}, {:literal, 8}}]}
-      )
-      assert {:block, [
-        {:binop, :shl, {:var, :a}, {:literal, 2}},
-        {:binop, :shr_s, {:var, :b}, {:literal, 3}}
-      ]} = result
+      result =
+        Optimizer.strength_reduce(
+          {:block,
+           [
+             {:binop, :mul, {:var, :a}, {:literal, 4}},
+             {:binop, :div_s, {:var, :b}, {:literal, 8}}
+           ]}
+        )
+
+      assert {:block,
+              [
+                {:binop, :shl, {:var, :a}, {:literal, 2}},
+                {:binop, :shr_s, {:var, :b}, {:literal, 3}}
+              ]} = result
     end
 
     test "propagates through tail_loop" do
-      result = Optimizer.strength_reduce(
-        {:tail_loop, [:n], {:binop, :mul, {:var, :n}, {:literal, 2}}}
-      )
+      result =
+        Optimizer.strength_reduce({:tail_loop, [:n], {:binop, :mul, {:var, :n}, {:literal, 2}}})
+
       assert {:tail_loop, [:n], {:binop, :shl, {:var, :n}, {:literal, 1}}} = result
     end
 
     test "propagates through tail_call args" do
-      result = Optimizer.strength_reduce(
-        {:tail_call, :loop, [{:binop, :div_s, {:var, :n}, {:literal, 2}}]}
-      )
+      result =
+        Optimizer.strength_reduce(
+          {:tail_call, :loop, [{:binop, :div_s, {:var, :n}, {:literal, 2}}]}
+        )
+
       assert {:tail_call, :loop, [{:binop, :shr_s, {:var, :n}, {:literal, 1}}]} = result
     end
 
     test "propagates through case clauses" do
-      result = Optimizer.strength_reduce(
-        {:case, {:var, :x}, [
-          {{:literal, 0}, nil, {:binop, :mul, {:var, :y}, {:literal, 4}}}
-        ]}
-      )
-      assert {:case, {:var, :x}, [
-        {{:literal, 0}, nil, {:binop, :shl, {:var, :y}, {:literal, 2}}}
-      ]} = result
+      result =
+        Optimizer.strength_reduce(
+          {:case, {:var, :x},
+           [
+             {{:literal, 0}, nil, {:binop, :mul, {:var, :y}, {:literal, 4}}}
+           ]}
+        )
+
+      assert {:case, {:var, :x},
+              [
+                {{:literal, 0}, nil, {:binop, :shl, {:var, :y}, {:literal, 2}}}
+              ]} = result
     end
 
     test "non-reducible binops pass through unchanged" do
@@ -607,17 +677,13 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
 
   describe "identity_elim/1 - nested identities" do
     test "recursive elimination: (x + 0) * 1 → x" do
-      expr = {:binop, :mul,
-        {:binop, :add, {:var, :x}, {:literal, 0}},
-        {:literal, 1}}
+      expr = {:binop, :mul, {:binop, :add, {:var, :x}, {:literal, 0}}, {:literal, 1}}
       result = Optimizer.identity_elim(expr)
       assert {:var, :x} = result
     end
 
     test "recursive elimination: 0 * (x + 0) → 0" do
-      expr = {:binop, :mul,
-        {:literal, 0},
-        {:binop, :add, {:var, :x}, {:literal, 0}}}
+      expr = {:binop, :mul, {:literal, 0}, {:binop, :add, {:var, :x}, {:literal, 0}}}
       result = Optimizer.identity_elim(expr)
       assert {:literal, 0} = result
     end
@@ -625,65 +691,70 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
 
   describe "identity_elim/1 - propagation through IR nodes" do
     test "propagates through if" do
-      result = Optimizer.identity_elim(
-        {:if, {:binop, :add, {:var, :c}, {:literal, 0}},
-          {:binop, :mul, {:var, :x}, {:literal, 1}},
-          {:binop, :mul, {:literal, 0}, {:var, :y}}}
-      )
+      result =
+        Optimizer.identity_elim(
+          {:if, {:binop, :add, {:var, :c}, {:literal, 0}},
+           {:binop, :mul, {:var, :x}, {:literal, 1}}, {:binop, :mul, {:literal, 0}, {:var, :y}}}
+        )
+
       assert {:if, {:var, :c}, {:var, :x}, {:literal, 0}} = result
     end
 
     test "propagates through call" do
-      result = Optimizer.identity_elim(
-        {:call, :foo, [{:binop, :add, {:var, :a}, {:literal, 0}}]}
-      )
+      result = Optimizer.identity_elim({:call, :foo, [{:binop, :add, {:var, :a}, {:literal, 0}}]})
       assert {:call, :foo, [{:var, :a}]} = result
     end
 
     test "propagates through let" do
-      result = Optimizer.identity_elim(
-        {:let, :y, {:binop, :mul, {:var, :x}, {:literal, 1}}}
-      )
+      result = Optimizer.identity_elim({:let, :y, {:binop, :mul, {:var, :x}, {:literal, 1}}})
       assert {:let, :y, {:var, :x}} = result
     end
 
     test "propagates through block" do
-      result = Optimizer.identity_elim(
-        {:block, [
-          {:binop, :add, {:literal, 0}, {:var, :a}},
-          {:binop, :sub, {:var, :b}, {:literal, 0}}
-        ]}
-      )
+      result =
+        Optimizer.identity_elim(
+          {:block,
+           [
+             {:binop, :add, {:literal, 0}, {:var, :a}},
+             {:binop, :sub, {:var, :b}, {:literal, 0}}
+           ]}
+        )
+
       assert {:block, [{:var, :a}, {:var, :b}]} = result
     end
 
     test "propagates through unaryop" do
-      result = Optimizer.identity_elim(
-        {:unaryop, :not, {:binop, :add, {:var, :x}, {:literal, 0}}}
-      )
+      result =
+        Optimizer.identity_elim({:unaryop, :not, {:binop, :add, {:var, :x}, {:literal, 0}}})
+
       assert {:unaryop, :not, {:var, :x}} = result
     end
 
     test "propagates through case" do
-      result = Optimizer.identity_elim(
-        {:case, {:binop, :mul, {:var, :s}, {:literal, 1}}, [
-          {{:literal, 0}, nil, {:binop, :add, {:literal, 0}, {:var, :v}}}
-        ]}
-      )
+      result =
+        Optimizer.identity_elim(
+          {:case, {:binop, :mul, {:var, :s}, {:literal, 1}},
+           [
+             {{:literal, 0}, nil, {:binop, :add, {:literal, 0}, {:var, :v}}}
+           ]}
+        )
+
       assert {:case, {:var, :s}, [{{:literal, 0}, nil, {:var, :v}}]} = result
     end
 
     test "propagates through tail_loop" do
-      result = Optimizer.identity_elim(
-        {:tail_loop, [:n], {:binop, :add, {:var, :n}, {:literal, 0}}}
-      )
+      result =
+        Optimizer.identity_elim({:tail_loop, [:n], {:binop, :add, {:var, :n}, {:literal, 0}}})
+
       assert {:tail_loop, [:n], {:var, :n}} = result
     end
 
     test "propagates through tail_call" do
-      result = Optimizer.identity_elim(
-        {:tail_call, :loop, [{:binop, :mul, {:literal, 1}, {:var, :acc}}]}
-      )
+      result =
+        Optimizer.identity_elim(
+          {:tail_call, :loop, [{:binop, :mul, {:literal, 1}, {:var, :acc}}]}
+        )
+
       assert {:tail_call, :loop, [{:var, :acc}]} = result
     end
 
@@ -724,14 +795,19 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
 
       {:ok, optimized} = Optimizer.optimize(module)
       [f1, f2] = optimized.functions
-      assert f1.body == {:var, :x}    # identity elimination
-      assert f2.body == {:literal, 6}  # constant folding
+      # identity elimination
+      assert f1.body == {:var, :x}
+      # constant folding
+      assert f2.body == {:literal, 6}
     end
 
     test "with specific passes" do
-      module = make_module(:f, [:x],
-        {:binop, :add, {:binop, :mul, {:literal, 2}, {:literal, 3}}, {:literal, 0}}
-      )
+      module =
+        make_module(
+          :f,
+          [:x],
+          {:binop, :add, {:binop, :mul, {:literal, 2}, {:literal, 3}}, {:literal, 0}}
+        )
 
       # Only constant fold - should fold 2*3=6 but not remove +0
       {:ok, cf_only} = Optimizer.optimize(module, passes: [:constant_fold])
@@ -785,19 +861,17 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
   describe "cross-pass interactions" do
     test "constant fold enables dead code elimination" do
       # if(1 == 1, then: 42, else: 0) → if(1, then: 42, else: 0) → 42
-      expr = {:if,
-        {:binop, :eq, {:literal, 1}, {:literal, 1}},
-        {:literal, 42},
-        {:literal, 0}}
+      expr = {:if, {:binop, :eq, {:literal, 1}, {:literal, 1}}, {:literal, 42}, {:literal, 0}}
       result = Optimizer.optimize_expr(expr)
       assert {:literal, 42} = result
     end
 
     test "identity elimination + constant folding" do
       # (x * 1) + (2 + 3)  → x + 5
-      expr = {:binop, :add,
-        {:binop, :mul, {:var, :x}, {:literal, 1}},
-        {:binop, :add, {:literal, 2}, {:literal, 3}}}
+      expr =
+        {:binop, :add, {:binop, :mul, {:var, :x}, {:literal, 1}},
+         {:binop, :add, {:literal, 2}, {:literal, 3}}}
+
       result = Optimizer.optimize_expr(expr)
       assert {:binop, :add, {:var, :x}, {:literal, 5}} = result
     end
@@ -817,10 +891,11 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
       # → if(1, then: x * 2, else: garbage)  (constant fold)
       # → x * 2  (dead code)
       # → x << 1  (strength reduce)
-      expr = {:if,
-        {:binop, :eq, {:literal, 0}, {:literal, 0}},
-        {:binop, :mul, {:binop, :add, {:var, :x}, {:literal, 0}}, {:literal, 2}},
-        {:binop, :add, {:literal, 999}, {:literal, 888}}}
+      expr =
+        {:if, {:binop, :eq, {:literal, 0}, {:literal, 0}},
+         {:binop, :mul, {:binop, :add, {:var, :x}, {:literal, 0}}, {:literal, 2}},
+         {:binop, :add, {:literal, 999}, {:literal, 888}}}
+
       result = Optimizer.optimize_expr(expr)
       assert {:binop, :shl, {:var, :x}, {:literal, 1}} = result
     end
@@ -828,9 +903,7 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
     test "fixpoint iteration converges" do
       # x + 0 → x, but also x * 1 + 0 → x * 1 → x
       # Requires multiple iterations
-      expr = {:binop, :add,
-        {:binop, :mul, {:var, :x}, {:literal, 1}},
-        {:literal, 0}}
+      expr = {:binop, :add, {:binop, :mul, {:var, :x}, {:literal, 1}}, {:literal, 0}}
       result = Optimizer.optimize_expr(expr)
       assert {:var, :x} = result
     end
@@ -848,6 +921,7 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
         def add(a, b), do: a + b + 0
       end
       """
+
       {:ok, result} = Firebird.Compiler.compile_source(source, optimize: true)
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [8]} = Firebird.call(inst, "add", [5, 3])
@@ -863,6 +937,7 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
         def double(n), do: n * 2
       end
       """
+
       {:ok, result} = Firebird.Compiler.compile_source(source, optimize: true)
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [10]} = Firebird.call(inst, "double", [5])
@@ -903,12 +978,13 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
         def factorial(n), do: n * factorial(n - 1)
       end
       """
+
       {:ok, result} = Firebird.Compiler.compile_source(source, optimize: true)
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [1]} = Firebird.call(inst, "factorial", [0])
       assert {:ok, [1]} = Firebird.call(inst, "factorial", [1])
       assert {:ok, [120]} = Firebird.call(inst, "factorial", [5])
-      assert {:ok, [3628800]} = Firebird.call(inst, "factorial", [10])
+      assert {:ok, [3_628_800]} = Firebird.call(inst, "factorial", [10])
       Firebird.stop(inst)
     end
 
@@ -920,6 +996,7 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
         def abs_val(n), do: n
       end
       """
+
       {:ok, result} = Firebird.Compiler.compile_source(source, optimize: true)
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [5]} = Firebird.call(inst, "abs_val", [5])
@@ -935,6 +1012,7 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
         def offset(x), do: x + 10 * 2
       end
       """
+
       {:ok, result} = Firebird.Compiler.compile_source(source, optimize: true)
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [25]} = Firebird.call(inst, "offset", [5])
@@ -955,11 +1033,13 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
     end
 
     test "negative literal division" do
-      assert {:literal, -3} = Optimizer.constant_fold({:binop, :div_s, {:literal, -10}, {:literal, 3}})
+      assert {:literal, -3} =
+               Optimizer.constant_fold({:binop, :div_s, {:literal, -10}, {:literal, 3}})
     end
 
     test "negative literal remainder" do
-      assert {:literal, -1} = Optimizer.constant_fold({:binop, :rem_s, {:literal, -10}, {:literal, 3}})
+      assert {:literal, -1} =
+               Optimizer.constant_fold({:binop, :rem_s, {:literal, -10}, {:literal, 3}})
     end
 
     test "strength reduce with large power of 2" do
@@ -970,13 +1050,9 @@ defmodule Firebird.Compiler.OptimizerComprehensiveTest do
 
     test "rem(x, 2) pattern for parity check" do
       # Common pattern: if rem(n, 2) == 0 → if (n & 1) == 0
-      expr = {:binop, :eq,
-        {:binop, :rem_s, {:var, :n}, {:literal, 2}},
-        {:literal, 0}}
+      expr = {:binop, :eq, {:binop, :rem_s, {:var, :n}, {:literal, 2}}, {:literal, 0}}
       result = Optimizer.optimize_expr(expr)
-      assert {:binop, :eq,
-        {:binop, :band, {:var, :n}, {:literal, 1}},
-        {:literal, 0}} = result
+      assert {:binop, :eq, {:binop, :band, {:var, :n}, {:literal, 1}}, {:literal, 0}} = result
     end
 
     test "identity elimination on already-minimal expression" do
diff --git a/test/compiler/optimizer_coverage_test.exs b/test/compiler/optimizer_coverage_test.exs
index 92e8e1a..6288247 100644
--- a/test/compiler/optimizer_coverage_test.exs
+++ b/test/compiler/optimizer_coverage_test.exs
@@ -64,9 +64,10 @@ defmodule Firebird.Compiler.OptimizerCoverageTest do
 
     test "folds nested bitwise operations" do
       # (3 << 2) | (1 << 0) = 12 | 1 = 13
-      expr = {:binop, :bor,
-        {:binop, :shl, {:literal, 3}, {:literal, 2}},
-        {:binop, :shl, {:literal, 1}, {:literal, 0}}}
+      expr =
+        {:binop, :bor, {:binop, :shl, {:literal, 3}, {:literal, 2}},
+         {:binop, :shl, {:literal, 1}, {:literal, 0}}}
+
       assert Optimizer.constant_fold(expr) == {:literal, 13}
     end
 
@@ -141,9 +142,7 @@ defmodule Firebird.Compiler.OptimizerCoverageTest do
 
     test "nested bitwise identities" do
       # (x &&& -1) ||| 0 = x
-      expr = {:binop, :bor,
-        {:binop, :band, {:var, :x}, {:literal, -1}},
-        {:literal, 0}}
+      expr = {:binop, :bor, {:binop, :band, {:var, :x}, {:literal, -1}}, {:literal, 0}}
       assert Optimizer.identity_elim(expr) == {:var, :x}
     end
   end
@@ -221,13 +220,15 @@ defmodule Firebird.Compiler.OptimizerCoverageTest do
 
   describe "strength_reduce/1 - recursion into sub-expressions" do
     test "recurses into if branches" do
-      expr = {:if, {:var, :c},
-        {:binop, :mul, {:var, :x}, {:literal, 4}},
-        {:binop, :div_s, {:var, :y}, {:literal, 2}}}
+      expr =
+        {:if, {:var, :c}, {:binop, :mul, {:var, :x}, {:literal, 4}},
+         {:binop, :div_s, {:var, :y}, {:literal, 2}}}
+
       result = Optimizer.strength_reduce(expr)
-      assert result == {:if, {:var, :c},
-        {:binop, :shl, {:var, :x}, {:literal, 2}},
-        {:binop, :shr_s, {:var, :y}, {:literal, 1}}}
+
+      assert result ==
+               {:if, {:var, :c}, {:binop, :shl, {:var, :x}, {:literal, 2}},
+                {:binop, :shr_s, {:var, :y}, {:literal, 1}}}
     end
 
     test "recurses into let bindings" do
@@ -237,13 +238,19 @@ defmodule Firebird.Compiler.OptimizerCoverageTest do
     end
 
     test "recurses into case clauses" do
-      expr = {:case, {:var, :n}, [
-        {{:literal_pat, 0}, nil, {:binop, :rem_s, {:var, :x}, {:literal, 4}}}
-      ]}
+      expr =
+        {:case, {:var, :n},
+         [
+           {{:literal_pat, 0}, nil, {:binop, :rem_s, {:var, :x}, {:literal, 4}}}
+         ]}
+
       result = Optimizer.strength_reduce(expr)
-      assert result == {:case, {:var, :n}, [
-        {{:literal_pat, 0}, nil, {:binop, :band, {:var, :x}, {:literal, 3}}}
-      ]}
+
+      assert result ==
+               {:case, {:var, :n},
+                [
+                  {{:literal_pat, 0}, nil, {:binop, :band, {:var, :x}, {:literal, 3}}}
+                ]}
     end
 
     test "recurses into call arguments" do
@@ -263,8 +270,7 @@ defmodule Firebird.Compiler.OptimizerCoverageTest do
 
   describe "constant_fold/1 - tail_loop and tail_call" do
     test "folds constants inside tail_loop body" do
-      expr = {:tail_loop, [{:n, {:literal, 10}}],
-        {:binop, :add, {:literal, 1}, {:literal, 2}}}
+      expr = {:tail_loop, [{:n, {:literal, 10}}], {:binop, :add, {:literal, 1}, {:literal, 2}}}
       result = Optimizer.constant_fold(expr)
       assert result == {:tail_loop, [{:n, {:literal, 10}}], {:literal, 3}}
     end
@@ -278,16 +284,18 @@ defmodule Firebird.Compiler.OptimizerCoverageTest do
 
   describe "dead_code_elim/1 - tail_loop and tail_call" do
     test "eliminates dead code inside tail_loop body" do
-      expr = {:tail_loop, [:n],
-        {:if, {:literal, 1}, {:literal, 42}, {:literal, 0}}}
+      expr = {:tail_loop, [:n], {:if, {:literal, 1}, {:literal, 42}, {:literal, 0}}}
       result = Optimizer.dead_code_elim(expr)
       assert result == {:tail_loop, [:n], {:literal, 42}}
     end
 
     test "recurses into tail_call args" do
-      expr = {:tail_call, :loop, [
-        {:if, {:literal, 0}, {:literal, 99}, {:var, :n}}
-      ]}
+      expr =
+        {:tail_call, :loop,
+         [
+           {:if, {:literal, 0}, {:literal, 99}, {:var, :n}}
+         ]}
+
       result = Optimizer.dead_code_elim(expr)
       assert result == {:tail_call, :loop, [{:var, :n}]}
     end
@@ -295,11 +303,9 @@ defmodule Firebird.Compiler.OptimizerCoverageTest do
 
   describe "strength_reduce/1 - tail_loop and tail_call" do
     test "reduces strength inside tail_loop body" do
-      expr = {:tail_loop, [:n],
-        {:binop, :mul, {:var, :x}, {:literal, 4}}}
+      expr = {:tail_loop, [:n], {:binop, :mul, {:var, :x}, {:literal, 4}}}
       result = Optimizer.strength_reduce(expr)
-      assert result == {:tail_loop, [:n],
-        {:binop, :shl, {:var, :x}, {:literal, 2}}}
+      assert result == {:tail_loop, [:n], {:binop, :shl, {:var, :x}, {:literal, 2}}}
     end
 
     test "reduces strength inside tail_call args" do
@@ -311,16 +317,18 @@ defmodule Firebird.Compiler.OptimizerCoverageTest do
 
   describe "identity_elim/1 - tail_loop and tail_call" do
     test "eliminates identities inside tail_loop body" do
-      expr = {:tail_loop, [:n],
-        {:binop, :add, {:var, :x}, {:literal, 0}}}
+      expr = {:tail_loop, [:n], {:binop, :add, {:var, :x}, {:literal, 0}}}
       result = Optimizer.identity_elim(expr)
       assert result == {:tail_loop, [:n], {:var, :x}}
     end
 
     test "eliminates identities inside tail_call args" do
-      expr = {:tail_call, :loop, [
-        {:binop, :mul, {:var, :n}, {:literal, 1}}
-      ]}
+      expr =
+        {:tail_call, :loop,
+         [
+           {:binop, :mul, {:var, :n}, {:literal, 1}}
+         ]}
+
       result = Optimizer.identity_elim(expr)
       assert result == {:tail_call, :loop, [{:var, :n}]}
     end
@@ -338,9 +346,7 @@ defmodule Firebird.Compiler.OptimizerCoverageTest do
             name: :f,
             arity: 0,
             params: [],
-            body: {:binop, :add,
-              {:binop, :add, {:literal, 2}, {:literal, 3}},
-              {:literal, 0}},
+            body: {:binop, :add, {:binop, :add, {:literal, 2}, {:literal, 3}}, {:literal, 0}},
             clauses: [],
             type: nil
           }
@@ -363,10 +369,9 @@ defmodule Firebird.Compiler.OptimizerCoverageTest do
             name: :f,
             arity: 1,
             params: [:x],
-            body: {:if,
-              {:binop, :eq, {:literal, 1}, {:literal, 1}},
-              {:binop, :mul, {:var, :x}, {:literal, 8}},
-              {:literal, 0}},
+            body:
+              {:if, {:binop, :eq, {:literal, 1}, {:literal, 1}},
+               {:binop, :mul, {:var, :x}, {:literal, 8}}, {:literal, 0}},
             clauses: [],
             type: nil
           }
@@ -389,11 +394,10 @@ defmodule Firebird.Compiler.OptimizerCoverageTest do
             name: :id,
             arity: 1,
             params: [:x],
-            body: {:binop, :sub,
-              {:binop, :mul,
-                {:binop, :add, {:var, :x}, {:literal, 0}},
-                {:literal, 1}},
-              {:literal, 0}},
+            body:
+              {:binop, :sub,
+               {:binop, :mul, {:binop, :add, {:var, :x}, {:literal, 0}}, {:literal, 1}},
+               {:literal, 0}},
             clauses: [],
             type: nil
           }
@@ -480,10 +484,13 @@ defmodule Firebird.Compiler.OptimizerCoverageTest do
     end
 
     test "recurses into block expressions" do
-      expr = {:block, [
-        {:if, {:literal, 0}, {:literal, :dead}, {:literal, 1}},
-        {:var, :x}
-      ]}
+      expr =
+        {:block,
+         [
+           {:if, {:literal, 0}, {:literal, :dead}, {:literal, 1}},
+           {:var, :x}
+         ]}
+
       result = Optimizer.dead_code_elim(expr)
       assert result == {:block, [{:literal, 1}, {:var, :x}]}
     end
@@ -517,22 +524,31 @@ defmodule Firebird.Compiler.OptimizerCoverageTest do
     end
 
     test "recurses into block" do
-      expr = {:block, [
-        {:binop, :add, {:var, :a}, {:literal, 0}},
-        {:binop, :mul, {:literal, 0}, {:var, :b}}
-      ]}
+      expr =
+        {:block,
+         [
+           {:binop, :add, {:var, :a}, {:literal, 0}},
+           {:binop, :mul, {:literal, 0}, {:var, :b}}
+         ]}
+
       result = Optimizer.identity_elim(expr)
       assert result == {:block, [{:var, :a}, {:literal, 0}]}
     end
 
     test "recurses into case" do
-      expr = {:case, {:var, :n}, [
-        {{:literal_pat, 0}, nil, {:binop, :sub, {:var, :x}, {:literal, 0}}}
-      ]}
+      expr =
+        {:case, {:var, :n},
+         [
+           {{:literal_pat, 0}, nil, {:binop, :sub, {:var, :x}, {:literal, 0}}}
+         ]}
+
       result = Optimizer.identity_elim(expr)
-      assert result == {:case, {:var, :n}, [
-        {{:literal_pat, 0}, nil, {:var, :x}}
-      ]}
+
+      assert result ==
+               {:case, {:var, :n},
+                [
+                  {{:literal_pat, 0}, nil, {:var, :x}}
+                ]}
     end
 
     test "recurses into unary" do
@@ -546,43 +562,55 @@ defmodule Firebird.Compiler.OptimizerCoverageTest do
 
   describe "constant_fold/1 - recursion into complex IR nodes" do
     test "folds inside tail_loop with init values" do
-      expr = {:tail_loop, [{:n, {:binop, :add, {:literal, 1}, {:literal, 2}}}],
-        {:var, :n}}
+      expr = {:tail_loop, [{:n, {:binop, :add, {:literal, 1}, {:literal, 2}}}], {:var, :n}}
       # constant_fold only folds body, not init expressions in the params
       result = Optimizer.constant_fold(expr)
-      assert result == {:tail_loop, [{:n, {:binop, :add, {:literal, 1}, {:literal, 2}}}],
-        {:var, :n}}
+
+      assert result ==
+               {:tail_loop, [{:n, {:binop, :add, {:literal, 1}, {:literal, 2}}}], {:var, :n}}
     end
 
     test "folds multiple args in tail_call" do
-      expr = {:tail_call, :loop, [
-        {:binop, :add, {:literal, 1}, {:literal, 2}},
-        {:binop, :mul, {:literal, 3}, {:literal, 4}}
-      ]}
+      expr =
+        {:tail_call, :loop,
+         [
+           {:binop, :add, {:literal, 1}, {:literal, 2}},
+           {:binop, :mul, {:literal, 3}, {:literal, 4}}
+         ]}
+
       result = Optimizer.constant_fold(expr)
       assert result == {:tail_call, :loop, [{:literal, 3}, {:literal, 12}]}
     end
 
     test "folds inside multiple call arguments" do
-      expr = {:call, :f, [
-        {:binop, :add, {:literal, 1}, {:literal, 2}},
-        {:binop, :sub, {:literal, 10}, {:literal, 3}},
-        {:var, :x}
-      ]}
+      expr =
+        {:call, :f,
+         [
+           {:binop, :add, {:literal, 1}, {:literal, 2}},
+           {:binop, :sub, {:literal, 10}, {:literal, 3}},
+           {:var, :x}
+         ]}
+
       result = Optimizer.constant_fold(expr)
       assert result == {:call, :f, [{:literal, 3}, {:literal, 7}, {:var, :x}]}
     end
 
     test "folds inside case with multiple clauses" do
-      expr = {:case, {:binop, :add, {:literal, 1}, {:literal, 2}}, [
-        {{:literal_pat, 3}, nil, {:binop, :mul, {:literal, 2}, {:literal, 3}}},
-        {:wildcard, nil, {:binop, :add, {:literal, 4}, {:literal, 5}}}
-      ]}
+      expr =
+        {:case, {:binop, :add, {:literal, 1}, {:literal, 2}},
+         [
+           {{:literal_pat, 3}, nil, {:binop, :mul, {:literal, 2}, {:literal, 3}}},
+           {:wildcard, nil, {:binop, :add, {:literal, 4}, {:literal, 5}}}
+         ]}
+
       result = Optimizer.constant_fold(expr)
-      assert result == {:case, {:literal, 3}, [
-        {{:literal_pat, 3}, nil, {:literal, 6}},
-        {:wildcard, nil, {:literal, 9}}
-      ]}
+
+      assert result ==
+               {:case, {:literal, 3},
+                [
+                  {{:literal_pat, 3}, nil, {:literal, 6}},
+                  {:wildcard, nil, {:literal, 9}}
+                ]}
     end
   end
 
@@ -596,6 +624,7 @@ defmodule Firebird.Compiler.OptimizerCoverageTest do
 
     test "only strength_reduce pass" do
       expr = {:binop, :mul, {:var, :x}, {:literal, 16}}
+
       assert Optimizer.optimize_expr(expr, [:strength_reduce]) ==
                {:binop, :shl, {:var, :x}, {:literal, 4}}
     end
@@ -616,10 +645,10 @@ defmodule Firebird.Compiler.OptimizerCoverageTest do
       # → dead_code: x * 2 + 0
       # → strength: (x << 1) + 0
       # → identity: x << 1
-      expr = {:if,
-        {:binop, :eq, {:literal, 1}, {:literal, 1}},
-        {:binop, :add, {:binop, :mul, {:var, :x}, {:literal, 2}}, {:literal, 0}},
-        {:binop, :mul, {:var, :x}, {:literal, 0}}}
+      expr =
+        {:if, {:binop, :eq, {:literal, 1}, {:literal, 1}},
+         {:binop, :add, {:binop, :mul, {:var, :x}, {:literal, 2}}, {:literal, 0}},
+         {:binop, :mul, {:var, :x}, {:literal, 0}}}
 
       result = Optimizer.optimize_expr(expr)
       assert result == {:binop, :shl, {:var, :x}, {:literal, 1}}
diff --git a/test/compiler/optimizer_edge_cases_test.exs b/test/compiler/optimizer_edge_cases_test.exs
index 423f833..43b5ac3 100644
--- a/test/compiler/optimizer_edge_cases_test.exs
+++ b/test/compiler/optimizer_edge_cases_test.exs
@@ -24,8 +24,12 @@ defmodule Firebird.Compiler.OptimizerEdgeCasesTest do
 
   describe "optimize/2 with selective passes" do
     test "runs only constant folding" do
-      func = make_function(:f,
-        {:binop, :add, {:binop, :mul, {:literal, 2}, {:literal, 3}}, {:literal, 0}})
+      func =
+        make_function(
+          :f,
+          {:binop, :add, {:binop, :mul, {:literal, 2}, {:literal, 3}}, {:literal, 0}}
+        )
+
       module = make_module([func])
 
       {:ok, result} = Optimizer.optimize(module, passes: [:constant_fold])
@@ -36,8 +40,12 @@ defmodule Firebird.Compiler.OptimizerEdgeCasesTest do
     end
 
     test "runs only identity elimination" do
-      func = make_function(:f,
-        {:binop, :add, {:var, :p0}, {:literal, 0}})
+      func =
+        make_function(
+          :f,
+          {:binop, :add, {:var, :p0}, {:literal, 0}}
+        )
+
       module = make_module([func])
 
       {:ok, result} = Optimizer.optimize(module, passes: [:identity_elim])
@@ -46,8 +54,12 @@ defmodule Firebird.Compiler.OptimizerEdgeCasesTest do
     end
 
     test "runs only dead code elimination" do
-      func = make_function(:f,
-        {:if, {:literal, 1}, {:var, :p0}, {:literal, 999}})
+      func =
+        make_function(
+          :f,
+          {:if, {:literal, 1}, {:var, :p0}, {:literal, 999}}
+        )
+
       module = make_module([func])
 
       {:ok, result} = Optimizer.optimize(module, passes: [:dead_code])
@@ -56,8 +68,12 @@ defmodule Firebird.Compiler.OptimizerEdgeCasesTest do
     end
 
     test "runs only strength reduction" do
-      func = make_function(:f,
-        {:binop, :mul, {:var, :p0}, {:literal, 8}})
+      func =
+        make_function(
+          :f,
+          {:binop, :mul, {:var, :p0}, {:literal, 8}}
+        )
+
       module = make_module([func])
 
       {:ok, result} = Optimizer.optimize(module, passes: [:strength_reduce])
@@ -85,45 +101,46 @@ defmodule Firebird.Compiler.OptimizerEdgeCasesTest do
 
   describe "constant folding edge cases" do
     test "folds negative number arithmetic" do
-      assert {:literal, -5} = Optimizer.constant_fold(
-        {:binop, :sub, {:literal, 5}, {:literal, 10}})
+      assert {:literal, -5} =
+               Optimizer.constant_fold({:binop, :sub, {:literal, 5}, {:literal, 10}})
     end
 
     test "folds zero times zero" do
-      assert {:literal, 0} = Optimizer.constant_fold(
-        {:binop, :mul, {:literal, 0}, {:literal, 0}})
+      assert {:literal, 0} = Optimizer.constant_fold({:binop, :mul, {:literal, 0}, {:literal, 0}})
     end
 
     test "folds deeply nested constants" do
       # ((2 + 3) * (4 - 1)) + ((10 / 2) - 1) = 5 * 3 + 5 - 1 = 15 + 4 = 19
-      expr = {:binop, :add,
-        {:binop, :mul,
-          {:binop, :add, {:literal, 2}, {:literal, 3}},
+      expr =
+        {:binop, :add,
+         {:binop, :mul, {:binop, :add, {:literal, 2}, {:literal, 3}},
           {:binop, :sub, {:literal, 4}, {:literal, 1}}},
-        {:binop, :sub,
-          {:binop, :div_s, {:literal, 10}, {:literal, 2}},
-          {:literal, 1}}}
+         {:binop, :sub, {:binop, :div_s, {:literal, 10}, {:literal, 2}}, {:literal, 1}}}
+
       assert {:literal, 19} = Optimizer.constant_fold(expr)
     end
 
     test "preserves mixed constant/variable expressions" do
-      expr = {:binop, :add,
-        {:binop, :add, {:literal, 1}, {:literal, 2}},
-        {:var, :x}}
+      expr = {:binop, :add, {:binop, :add, {:literal, 1}, {:literal, 2}}, {:var, :x}}
       result = Optimizer.constant_fold(expr)
       assert {:binop, :add, {:literal, 3}, {:var, :x}} = result
     end
 
     test "folds constants inside case clauses" do
-      expr = {:case, {:var, :x}, [
-        {{:literal_pat, 0}, nil, {:binop, :add, {:literal, 1}, {:literal, 2}}},
-        {:wildcard, nil, {:binop, :mul, {:literal, 3}, {:literal, 4}}}
-      ]}
+      expr =
+        {:case, {:var, :x},
+         [
+           {{:literal_pat, 0}, nil, {:binop, :add, {:literal, 1}, {:literal, 2}}},
+           {:wildcard, nil, {:binop, :mul, {:literal, 3}, {:literal, 4}}}
+         ]}
+
       result = Optimizer.constant_fold(expr)
-      assert {:case, {:var, :x}, [
-        {{:literal_pat, 0}, nil, {:literal, 3}},
-        {:wildcard, nil, {:literal, 12}}
-      ]} = result
+
+      assert {:case, {:var, :x},
+              [
+                {{:literal_pat, 0}, nil, {:literal, 3}},
+                {:wildcard, nil, {:literal, 12}}
+              ]} = result
     end
 
     test "folds not of non-zero integers to 0" do
@@ -137,22 +154,18 @@ defmodule Firebird.Compiler.OptimizerEdgeCasesTest do
     end
 
     test "folds boolean and_ with truthy values" do
-      assert {:literal, 1} = Optimizer.constant_fold(
-        {:binop, :and_, {:literal, 5}, {:literal, 3}})
+      assert {:literal, 1} =
+               Optimizer.constant_fold({:binop, :and_, {:literal, 5}, {:literal, 3}})
     end
 
     test "folds boolean or_ with zero" do
-      assert {:literal, 0} = Optimizer.constant_fold(
-        {:binop, :or_, {:literal, 0}, {:literal, 0}})
-      assert {:literal, 1} = Optimizer.constant_fold(
-        {:binop, :or_, {:literal, 0}, {:literal, 5}})
+      assert {:literal, 0} = Optimizer.constant_fold({:binop, :or_, {:literal, 0}, {:literal, 0}})
+      assert {:literal, 1} = Optimizer.constant_fold({:binop, :or_, {:literal, 0}, {:literal, 5}})
     end
 
     test "folds ne comparison" do
-      assert {:literal, 0} = Optimizer.constant_fold(
-        {:binop, :ne, {:literal, 5}, {:literal, 5}})
-      assert {:literal, 1} = Optimizer.constant_fold(
-        {:binop, :ne, {:literal, 5}, {:literal, 3}})
+      assert {:literal, 0} = Optimizer.constant_fold({:binop, :ne, {:literal, 5}, {:literal, 5}})
+      assert {:literal, 1} = Optimizer.constant_fold({:binop, :ne, {:literal, 5}, {:literal, 3}})
     end
 
     test "preserves unaryop on non-constant" do
@@ -164,9 +177,10 @@ defmodule Firebird.Compiler.OptimizerEdgeCasesTest do
   describe "dead code elimination edge cases" do
     test "eliminates nested dead branches" do
       # if 1 then (if 0 then dead else alive) else unreachable
-      expr = {:if, {:literal, 1},
-        {:if, {:literal, 0}, {:literal, :dead}, {:literal, :alive}},
-        {:literal, :unreachable}}
+      expr =
+        {:if, {:literal, 1}, {:if, {:literal, 0}, {:literal, :dead}, {:literal, :alive}},
+         {:literal, :unreachable}}
+
       assert {:literal, :alive} = Optimizer.dead_code_elim(expr)
     end
 
@@ -179,9 +193,10 @@ defmodule Firebird.Compiler.OptimizerEdgeCasesTest do
     end
 
     test "recurses into binop operands" do
-      expr = {:binop, :add,
-        {:if, {:literal, 1}, {:literal, 5}, {:literal, 99}},
-        {:if, {:literal, 0}, {:literal, 99}, {:literal, 3}}}
+      expr =
+        {:binop, :add, {:if, {:literal, 1}, {:literal, 5}, {:literal, 99}},
+         {:if, {:literal, 0}, {:literal, 99}, {:literal, 3}}}
+
       result = Optimizer.dead_code_elim(expr)
       assert {:binop, :add, {:literal, 5}, {:literal, 3}} = result
     end
@@ -211,13 +226,18 @@ defmodule Firebird.Compiler.OptimizerEdgeCasesTest do
     end
 
     test "recurses into case clauses" do
-      expr = {:case, {:var, :x}, [
-        {{:literal_pat, 0}, nil, {:if, {:literal, 1}, {:literal, 10}, {:literal, 99}}}
-      ]}
+      expr =
+        {:case, {:var, :x},
+         [
+           {{:literal_pat, 0}, nil, {:if, {:literal, 1}, {:literal, 10}, {:literal, 99}}}
+         ]}
+
       result = Optimizer.dead_code_elim(expr)
-      assert {:case, {:var, :x}, [
-        {{:literal_pat, 0}, nil, {:literal, 10}}
-      ]} = result
+
+      assert {:case, {:var, :x},
+              [
+                {{:literal_pat, 0}, nil, {:literal, 10}}
+              ]} = result
     end
 
     test "passthrough for non-matchable nodes" do
@@ -251,13 +271,14 @@ defmodule Firebird.Compiler.OptimizerEdgeCasesTest do
     end
 
     test "recurses into nested expressions" do
-      expr = {:if, {:var, :cond},
-        {:binop, :mul, {:var, :x}, {:literal, 4}},
-        {:binop, :mul, {:literal, 8}, {:var, :y}}}
+      expr =
+        {:if, {:var, :cond}, {:binop, :mul, {:var, :x}, {:literal, 4}},
+         {:binop, :mul, {:literal, 8}, {:var, :y}}}
+
       result = Optimizer.strength_reduce(expr)
-      assert {:if, {:var, :cond},
-        {:binop, :shl, {:var, :x}, {:literal, 2}},
-        {:binop, :shl, {:var, :y}, {:literal, 3}}} = result
+
+      assert {:if, {:var, :cond}, {:binop, :shl, {:var, :x}, {:literal, 2}},
+              {:binop, :shl, {:var, :y}, {:literal, 3}}} = result
     end
 
     test "recurses into call, let, block, case" do
@@ -286,11 +307,10 @@ defmodule Firebird.Compiler.OptimizerEdgeCasesTest do
   describe "identity elimination edge cases" do
     test "nested identity eliminations" do
       # (x + 0) * 1 + 0 → x
-      expr = {:binop, :add,
-        {:binop, :mul,
-          {:binop, :add, {:var, :x}, {:literal, 0}},
-          {:literal, 1}},
-        {:literal, 0}}
+      expr =
+        {:binop, :add, {:binop, :mul, {:binop, :add, {:var, :x}, {:literal, 0}}, {:literal, 1}},
+         {:literal, 0}}
+
       result = Optimizer.identity_elim(expr)
       assert {:var, :x} = result
     end
@@ -302,29 +322,37 @@ defmodule Firebird.Compiler.OptimizerEdgeCasesTest do
     end
 
     test "0 * complex_expr eliminates to 0" do
-      expr = {:binop, :mul, {:literal, 0},
-        {:binop, :add, {:var, :a}, {:call, :expensive, [{:var, :b}]}}}
+      expr =
+        {:binop, :mul, {:literal, 0},
+         {:binop, :add, {:var, :a}, {:call, :expensive, [{:var, :b}]}}}
+
       assert {:literal, 0} = Optimizer.identity_elim(expr)
     end
 
     test "recurses into if branches" do
-      expr = {:if, {:var, :c},
-        {:binop, :add, {:var, :x}, {:literal, 0}},
-        {:binop, :mul, {:var, :y}, {:literal, 1}}}
+      expr =
+        {:if, {:var, :c}, {:binop, :add, {:var, :x}, {:literal, 0}},
+         {:binop, :mul, {:var, :y}, {:literal, 1}}}
+
       result = Optimizer.identity_elim(expr)
       assert {:if, {:var, :c}, {:var, :x}, {:var, :y}} = result
     end
 
     test "recurses into case clauses" do
-      expr = {:case, {:var, :n}, [
-        {{:literal_pat, 0}, nil, {:binop, :add, {:literal, 0}, {:var, :x}}},
-        {:wildcard, nil, {:binop, :mul, {:literal, 1}, {:var, :y}}}
-      ]}
+      expr =
+        {:case, {:var, :n},
+         [
+           {{:literal_pat, 0}, nil, {:binop, :add, {:literal, 0}, {:var, :x}}},
+           {:wildcard, nil, {:binop, :mul, {:literal, 1}, {:var, :y}}}
+         ]}
+
       result = Optimizer.identity_elim(expr)
-      assert {:case, {:var, :n}, [
-        {{:literal_pat, 0}, nil, {:var, :x}},
-        {:wildcard, nil, {:var, :y}}
-      ]} = result
+
+      assert {:case, {:var, :n},
+              [
+                {{:literal_pat, 0}, nil, {:var, :x}},
+                {:wildcard, nil, {:var, :y}}
+              ]} = result
     end
 
     test "recurses into let and block" do
@@ -349,11 +377,13 @@ defmodule Firebird.Compiler.OptimizerEdgeCasesTest do
   describe "fixpoint iteration" do
     test "multiple passes reach fixpoint" do
       # After constant fold: (2+3) = 5, then 5*1 identity_elim -> 5, then if(5, ...) dead_code -> result
-      func = make_function(:f,
-        {:if,
-          {:binop, :add, {:literal, 2}, {:literal, 3}},
-          {:binop, :mul, {:var, :p0}, {:literal, 1}},
-          {:literal, 999}})
+      func =
+        make_function(
+          :f,
+          {:if, {:binop, :add, {:literal, 2}, {:literal, 3}},
+           {:binop, :mul, {:var, :p0}, {:literal, 1}}, {:literal, 999}}
+        )
+
       module = make_module([func])
 
       {:ok, result} = Optimizer.optimize(module)
diff --git a/test/compiler/optimizer_tco_test.exs b/test/compiler/optimizer_tco_test.exs
index e1112ef..e227370 100644
--- a/test/compiler/optimizer_tco_test.exs
+++ b/test/compiler/optimizer_tco_test.exs
@@ -16,49 +16,45 @@ defmodule Firebird.Compiler.OptimizerTCOTest do
   describe "constant_fold with tail_loop/tail_call" do
     test "folds constants inside tail_loop body" do
       # tail_loop wrapping an if with a constant binop in the base case
-      expr = {:tail_loop, [:p0, :p1],
-        {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}},
+      expr =
+        {:tail_loop, [:p0, :p1],
+         {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}},
           {:binop, :add, {:literal, 2}, {:literal, 3}},
-          {:tail_call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}, {:var, :p1}]}
-        }
-      }
+          {:tail_call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}, {:var, :p1}]}}}
 
       result = Optimizer.constant_fold(expr)
 
       assert {:tail_loop, [:p0, :p1],
-        {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}},
-          {:literal, 5},
-          {:tail_call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}, {:var, :p1}]}
-        }
-      } = result
+              {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:literal, 5},
+               {:tail_call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}, {:var, :p1}]}}} =
+               result
     end
 
     test "folds constants in tail_call arguments" do
-      expr = {:tail_call, :f, [
-        {:binop, :add, {:literal, 1}, {:literal, 2}},
-        {:binop, :mul, {:literal, 3}, {:literal, 4}}
-      ]}
+      expr =
+        {:tail_call, :f,
+         [
+           {:binop, :add, {:literal, 1}, {:literal, 2}},
+           {:binop, :mul, {:literal, 3}, {:literal, 4}}
+         ]}
 
       result = Optimizer.constant_fold(expr)
       assert {:tail_call, :f, [{:literal, 3}, {:literal, 12}]} = result
     end
 
     test "folds nested constants deep inside tail_loop" do
-      expr = {:tail_loop, [:p0],
-        {:if, {:binop, :eq, {:var, :p0}, {:binop, :add, {:literal, 0}, {:literal, 0}}},
+      expr =
+        {:tail_loop, [:p0],
+         {:if, {:binop, :eq, {:var, :p0}, {:binop, :add, {:literal, 0}, {:literal, 0}}},
           {:literal, 1},
-          {:tail_call, :f, [{:binop, :sub, {:var, :p0}, {:binop, :mul, {:literal, 1}, {:literal, 1}}}]}
-        }
-      }
+          {:tail_call, :f,
+           [{:binop, :sub, {:var, :p0}, {:binop, :mul, {:literal, 1}, {:literal, 1}}}]}}}
 
       result = Optimizer.constant_fold(expr)
 
       assert {:tail_loop, [:p0],
-        {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}},
-          {:literal, 1},
-          {:tail_call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]}
-        }
-      } = result
+              {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:literal, 1},
+               {:tail_call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]}}} = result
     end
   end
 
@@ -67,27 +63,20 @@ defmodule Firebird.Compiler.OptimizerTCOTest do
   describe "dead_code_elim with tail_loop/tail_call" do
     test "eliminates dead branches inside tail_loop" do
       # if(1) always takes the then branch
-      expr = {:tail_loop, [:p0],
-        {:if, {:literal, 1},
-          {:tail_call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]},
-          {:literal, 999}
-        }
-      }
+      expr =
+        {:tail_loop, [:p0],
+         {:if, {:literal, 1}, {:tail_call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]},
+          {:literal, 999}}}
 
       result = Optimizer.dead_code_elim(expr)
 
-      assert {:tail_loop, [:p0],
-        {:tail_call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]}
-      } = result
+      assert {:tail_loop, [:p0], {:tail_call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]}} =
+               result
     end
 
     test "eliminates dead false branch inside tail_loop" do
-      expr = {:tail_loop, [:p0],
-        {:if, {:literal, 0},
-          {:tail_call, :f, [{:literal, 42}]},
-          {:var, :p0}
-        }
-      }
+      expr =
+        {:tail_loop, [:p0], {:if, {:literal, 0}, {:tail_call, :f, [{:literal, 42}]}, {:var, :p0}}}
 
       result = Optimizer.dead_code_elim(expr)
       assert {:tail_loop, [:p0], {:var, :p0}} = result
@@ -98,33 +87,31 @@ defmodule Firebird.Compiler.OptimizerTCOTest do
 
   describe "strength_reduce with tail_loop/tail_call" do
     test "reduces multiplication by power of 2 in tail_call args" do
-      expr = {:tail_call, :f, [
-        {:binop, :mul, {:var, :n}, {:literal, 8}}
-      ]}
+      expr =
+        {:tail_call, :f,
+         [
+           {:binop, :mul, {:var, :n}, {:literal, 8}}
+         ]}
 
       result = Optimizer.strength_reduce(expr)
 
-      assert {:tail_call, :f, [
-        {:binop, :shl, {:var, :n}, {:literal, 3}}
-      ]} = result
+      assert {:tail_call, :f,
+              [
+                {:binop, :shl, {:var, :n}, {:literal, 3}}
+              ]} = result
     end
 
     test "reduces inside tail_loop body" do
-      expr = {:tail_loop, [:p0],
-        {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}},
-          {:literal, 0},
-          {:tail_call, :f, [{:binop, :mul, {:var, :p0}, {:literal, 4}}]}
-        }
-      }
+      expr =
+        {:tail_loop, [:p0],
+         {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:literal, 0},
+          {:tail_call, :f, [{:binop, :mul, {:var, :p0}, {:literal, 4}}]}}}
 
       result = Optimizer.strength_reduce(expr)
 
       assert {:tail_loop, [:p0],
-        {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}},
-          {:literal, 0},
-          {:tail_call, :f, [{:binop, :shl, {:var, :p0}, {:literal, 2}}]}
-        }
-      } = result
+              {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:literal, 0},
+               {:tail_call, :f, [{:binop, :shl, {:var, :p0}, {:literal, 2}}]}}} = result
     end
   end
 
@@ -132,31 +119,29 @@ defmodule Firebird.Compiler.OptimizerTCOTest do
 
   describe "identity_elim with tail_loop/tail_call" do
     test "eliminates x + 0 in tail_call args" do
-      expr = {:tail_call, :f, [
-        {:binop, :add, {:var, :n}, {:literal, 0}},
-        {:binop, :mul, {:var, :acc}, {:literal, 1}}
-      ]}
+      expr =
+        {:tail_call, :f,
+         [
+           {:binop, :add, {:var, :n}, {:literal, 0}},
+           {:binop, :mul, {:var, :acc}, {:literal, 1}}
+         ]}
 
       result = Optimizer.identity_elim(expr)
       assert {:tail_call, :f, [{:var, :n}, {:var, :acc}]} = result
     end
 
     test "eliminates x * 0 inside tail_loop body" do
-      expr = {:tail_loop, [:p0],
-        {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}},
+      expr =
+        {:tail_loop, [:p0],
+         {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}},
           {:binop, :mul, {:var, :p0}, {:literal, 0}},
-          {:tail_call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 0}}]}
-        }
-      }
+          {:tail_call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 0}}]}}}
 
       result = Optimizer.identity_elim(expr)
 
       assert {:tail_loop, [:p0],
-        {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}},
-          {:literal, 0},
-          {:tail_call, :f, [{:var, :p0}]}
-        }
-      } = result
+              {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:literal, 0},
+               {:tail_call, :f, [{:var, :p0}]}}} = result
     end
   end
 
@@ -174,17 +159,20 @@ defmodule Firebird.Compiler.OptimizerTCOTest do
             params: [:p0, :p1],
             clauses: [],
             type: nil,
-            body: {:tail_loop, [:p0, :p1],
-              {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}},
-                # p1 + 0 should be eliminated to just p1
-                {:binop, :add, {:var, :p1}, {:literal, 0}},
-                {:tail_call, :sum_acc, [
-                  {:binop, :sub, {:var, :p0}, {:literal, 1}},
-                  # p1 + (2 + 3) should fold to p1 + 5
-                  {:binop, :add, {:var, :p1}, {:binop, :add, {:literal, 2}, {:literal, 3}}}
-                ]}
-              }
-            }
+            body:
+              {:tail_loop, [:p0, :p1],
+               {
+                 :if,
+                 {:binop, :eq, {:var, :p0}, {:literal, 0}},
+                 # p1 + 0 should be eliminated to just p1
+                 {:binop, :add, {:var, :p1}, {:literal, 0}},
+                 {:tail_call, :sum_acc,
+                  [
+                    {:binop, :sub, {:var, :p0}, {:literal, 1}},
+                    # p1 + (2 + 3) should fold to p1 + 5
+                    {:binop, :add, {:var, :p1}, {:binop, :add, {:literal, 2}, {:literal, 3}}}
+                  ]}
+               }}
           }
         ]
       }
@@ -196,14 +184,12 @@ defmodule Firebird.Compiler.OptimizerTCOTest do
       # - {:binop, :add, {:var, :p1}, {:literal, 0}} → {:var, :p1}
       # - {:binop, :add, {:literal, 2}, {:literal, 3}} → {:literal, 5}
       assert {:tail_loop, [:p0, :p1],
-        {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}},
-          {:var, :p1},
-          {:tail_call, :sum_acc, [
-            {:binop, :sub, {:var, :p0}, {:literal, 1}},
-            {:binop, :add, {:var, :p1}, {:literal, 5}}
-          ]}
-        }
-      } = func.body
+              {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:var, :p1},
+               {:tail_call, :sum_acc,
+                [
+                  {:binop, :sub, {:var, :p0}, {:literal, 1}},
+                  {:binop, :add, {:var, :p1}, {:literal, 5}}
+                ]}}} = func.body
     end
   end
 
@@ -220,7 +206,9 @@ defmodule Firebird.Compiler.OptimizerTCOTest do
       """
 
       # Compile with both optimize and tco enabled
-      assert {:ok, result} = Firebird.Compiler.compile_source(source, optimize: true, tco: true, wat_only: true)
+      assert {:ok, result} =
+               Firebird.Compiler.compile_source(source, optimize: true, tco: true, wat_only: true)
+
       assert result.wat != nil
 
       # The WAT should contain loop/br patterns from TCO
@@ -244,7 +232,14 @@ defmodule Firebird.Compiler.OptimizerTCOTest do
       """
 
       # Should compile successfully with all opts
-      assert {:ok, result} = Firebird.Compiler.compile_source(source, optimize: true, tco: true, inline: true, wat_only: true)
+      assert {:ok, result} =
+               Firebird.Compiler.compile_source(source,
+                 optimize: true,
+                 tco: true,
+                 inline: true,
+                 wat_only: true
+               )
+
       assert result.wat != nil
       assert String.contains?(result.wat, "loop")
     end
diff --git a/test/compiler/optimizer_test.exs b/test/compiler/optimizer_test.exs
index 6787790..c1bd0cb 100644
--- a/test/compiler/optimizer_test.exs
+++ b/test/compiler/optimizer_test.exs
@@ -46,24 +46,40 @@ defmodule Firebird.Compiler.OptimizerTest do
       assert Optimizer.constant_fold({:binop, :eq, {:literal, 5}, {:literal, 5}}) == {:literal, 1}
       assert Optimizer.constant_fold({:binop, :eq, {:literal, 5}, {:literal, 3}}) == {:literal, 0}
       assert Optimizer.constant_fold({:binop, :ne, {:literal, 5}, {:literal, 3}}) == {:literal, 1}
-      assert Optimizer.constant_fold({:binop, :lt_s, {:literal, 3}, {:literal, 5}}) == {:literal, 1}
-      assert Optimizer.constant_fold({:binop, :gt_s, {:literal, 5}, {:literal, 3}}) == {:literal, 1}
-      assert Optimizer.constant_fold({:binop, :le_s, {:literal, 5}, {:literal, 5}}) == {:literal, 1}
-      assert Optimizer.constant_fold({:binop, :ge_s, {:literal, 5}, {:literal, 5}}) == {:literal, 1}
+
+      assert Optimizer.constant_fold({:binop, :lt_s, {:literal, 3}, {:literal, 5}}) ==
+               {:literal, 1}
+
+      assert Optimizer.constant_fold({:binop, :gt_s, {:literal, 5}, {:literal, 3}}) ==
+               {:literal, 1}
+
+      assert Optimizer.constant_fold({:binop, :le_s, {:literal, 5}, {:literal, 5}}) ==
+               {:literal, 1}
+
+      assert Optimizer.constant_fold({:binop, :ge_s, {:literal, 5}, {:literal, 5}}) ==
+               {:literal, 1}
     end
 
     test "folds logical operators" do
-      assert Optimizer.constant_fold({:binop, :and_, {:literal, 1}, {:literal, 1}}) == {:literal, 1}
-      assert Optimizer.constant_fold({:binop, :and_, {:literal, 0}, {:literal, 1}}) == {:literal, 0}
-      assert Optimizer.constant_fold({:binop, :or_, {:literal, 0}, {:literal, 0}}) == {:literal, 0}
-      assert Optimizer.constant_fold({:binop, :or_, {:literal, 0}, {:literal, 1}}) == {:literal, 1}
+      assert Optimizer.constant_fold({:binop, :and_, {:literal, 1}, {:literal, 1}}) ==
+               {:literal, 1}
+
+      assert Optimizer.constant_fold({:binop, :and_, {:literal, 0}, {:literal, 1}}) ==
+               {:literal, 0}
+
+      assert Optimizer.constant_fold({:binop, :or_, {:literal, 0}, {:literal, 0}}) ==
+               {:literal, 0}
+
+      assert Optimizer.constant_fold({:binop, :or_, {:literal, 0}, {:literal, 1}}) ==
+               {:literal, 1}
     end
 
     test "folds nested constant expressions" do
       # (2 + 3) * (4 + 1) = 5 * 5 = 25
-      expr = {:binop, :mul,
-        {:binop, :add, {:literal, 2}, {:literal, 3}},
-        {:binop, :add, {:literal, 4}, {:literal, 1}}}
+      expr =
+        {:binop, :mul, {:binop, :add, {:literal, 2}, {:literal, 3}},
+         {:binop, :add, {:literal, 4}, {:literal, 1}}}
+
       assert Optimizer.constant_fold(expr) == {:literal, 25}
     end
 
@@ -86,9 +102,10 @@ defmodule Firebird.Compiler.OptimizerTest do
     end
 
     test "folds inside if branches" do
-      expr = {:if, {:literal, 1},
-        {:binop, :add, {:literal, 1}, {:literal, 2}},
-        {:binop, :mul, {:literal, 3}, {:literal, 4}}}
+      expr =
+        {:if, {:literal, 1}, {:binop, :add, {:literal, 1}, {:literal, 2}},
+         {:binop, :mul, {:literal, 3}, {:literal, 4}}}
+
       assert Optimizer.constant_fold(expr) == {:if, {:literal, 1}, {:literal, 3}, {:literal, 12}}
     end
 
@@ -108,9 +125,12 @@ defmodule Firebird.Compiler.OptimizerTest do
     end
 
     test "folds inside case clauses" do
-      expr = {:case, {:var, :x}, [
-        {{:literal_pat, 0}, nil, {:binop, :add, {:literal, 1}, {:literal, 2}}}
-      ]}
+      expr =
+        {:case, {:var, :x},
+         [
+           {{:literal_pat, 0}, nil, {:binop, :add, {:literal, 1}, {:literal, 2}}}
+         ]}
+
       result = Optimizer.constant_fold(expr)
       assert result == {:case, {:var, :x}, [{{:literal_pat, 0}, nil, {:literal, 3}}]}
     end
@@ -151,23 +171,25 @@ defmodule Firebird.Compiler.OptimizerTest do
     end
 
     test "recursively eliminates nested dead code" do
-      expr = {:if, {:literal, 1},
-        {:if, {:literal, 0}, {:literal, :unreachable}, {:literal, 99}},
-        {:literal, :dead}}
+      expr =
+        {:if, {:literal, 1}, {:if, {:literal, 0}, {:literal, :unreachable}, {:literal, 99}},
+         {:literal, :dead}}
+
       assert Optimizer.dead_code_elim(expr) == {:literal, 99}
     end
 
     test "recurses into binop" do
-      expr = {:binop, :add,
-        {:if, {:literal, 1}, {:literal, 5}, {:literal, :dead}},
-        {:literal, 3}}
+      expr = {:binop, :add, {:if, {:literal, 1}, {:literal, 5}, {:literal, :dead}}, {:literal, 3}}
       assert Optimizer.dead_code_elim(expr) == {:binop, :add, {:literal, 5}, {:literal, 3}}
     end
 
     test "recurses into case clauses" do
-      expr = {:case, {:var, :x}, [
-        {{:literal_pat, 0}, nil, {:if, {:literal, 0}, {:literal, :dead}, {:literal, 42}}}
-      ]}
+      expr =
+        {:case, {:var, :x},
+         [
+           {{:literal_pat, 0}, nil, {:if, {:literal, 0}, {:literal, :dead}, {:literal, 42}}}
+         ]}
+
       result = Optimizer.dead_code_elim(expr)
       assert result == {:case, {:var, :x}, [{{:literal_pat, 0}, nil, {:literal, 42}}]}
     end
@@ -202,9 +224,7 @@ defmodule Firebird.Compiler.OptimizerTest do
     end
 
     test "recurses into nested expressions" do
-      expr = {:binop, :add,
-        {:binop, :mul, {:var, :x}, {:literal, 4}},
-        {:literal, 1}}
+      expr = {:binop, :add, {:binop, :mul, {:var, :x}, {:literal, 4}}, {:literal, 1}}
       result = Optimizer.strength_reduce(expr)
       assert result == {:binop, :add, {:binop, :shl, {:var, :x}, {:literal, 2}}, {:literal, 1}}
     end
@@ -263,9 +283,10 @@ defmodule Firebird.Compiler.OptimizerTest do
 
     test "recurses into if, call, let, block, case" do
       # identity inside if branches
-      expr = {:if, {:var, :c},
-        {:binop, :add, {:var, :x}, {:literal, 0}},
-        {:binop, :mul, {:var, :y}, {:literal, 1}}}
+      expr =
+        {:if, {:var, :c}, {:binop, :add, {:var, :x}, {:literal, 0}},
+         {:binop, :mul, {:var, :y}, {:literal, 1}}}
+
       assert Optimizer.identity_elim(expr) == {:if, {:var, :c}, {:var, :x}, {:var, :y}}
     end
   end
@@ -327,7 +348,8 @@ defmodule Firebird.Compiler.OptimizerTest do
             name: :test,
             arity: 0,
             params: [],
-            body: {:if, {:binop, :eq, {:literal, 1}, {:literal, 1}}, {:literal, 10}, {:literal, 20}},
+            body:
+              {:if, {:binop, :eq, {:literal, 1}, {:literal, 1}}, {:literal, 10}, {:literal, 20}},
             clauses: [],
             type: nil
           }
@@ -395,13 +417,13 @@ defmodule Firebird.Compiler.OptimizerTest do
 
     test "deeply nested expressions" do
       # ((1 + 2) + (3 + 4)) + ((5 + 6) + (7 + 8))
-      expr = {:binop, :add,
+      expr =
         {:binop, :add,
-          {:binop, :add, {:literal, 1}, {:literal, 2}},
+         {:binop, :add, {:binop, :add, {:literal, 1}, {:literal, 2}},
           {:binop, :add, {:literal, 3}, {:literal, 4}}},
-        {:binop, :add,
-          {:binop, :add, {:literal, 5}, {:literal, 6}},
+         {:binop, :add, {:binop, :add, {:literal, 5}, {:literal, 6}},
           {:binop, :add, {:literal, 7}, {:literal, 8}}}}
+
       assert Optimizer.constant_fold(expr) == {:literal, 36}
     end
 
@@ -413,8 +435,11 @@ defmodule Firebird.Compiler.OptimizerTest do
     end
 
     test "negative numbers in comparisons" do
-      assert Optimizer.constant_fold({:binop, :lt_s, {:literal, -1}, {:literal, 0}}) == {:literal, 1}
-      assert Optimizer.constant_fold({:binop, :gt_s, {:literal, -1}, {:literal, 0}}) == {:literal, 0}
+      assert Optimizer.constant_fold({:binop, :lt_s, {:literal, -1}, {:literal, 0}}) ==
+               {:literal, 1}
+
+      assert Optimizer.constant_fold({:binop, :gt_s, {:literal, -1}, {:literal, 0}}) ==
+               {:literal, 0}
     end
   end
 end
diff --git a/test/compiler/pipeline_integration_test.exs b/test/compiler/pipeline_integration_test.exs
index 15bd05f..ffeb431 100644
--- a/test/compiler/pipeline_integration_test.exs
+++ b/test/compiler/pipeline_integration_test.exs
@@ -40,7 +40,9 @@ defmodule Firebird.Compiler.PipelineIntegrationTest do
       end
       """
 
-      {:ok, result} = Firebird.Compiler.compile_source(source, optimize: true, tco: true, inline: true)
+      {:ok, result} =
+        Firebird.Compiler.compile_source(source, optimize: true, tco: true, inline: true)
+
       {:ok, inst} = Firebird.load(result.wasm)
       # sum of 2*i for i=1..5 = 2+4+6+8+10 = 30
       assert {:ok, [30]} = Firebird.call(inst, "sum_acc", [5, 0])
@@ -360,7 +362,7 @@ defmodule Firebird.Compiler.PipelineIntegrationTest do
 
   describe "compile/2 with .ex file" do
     test "compiles from .ex file" do
-      tmp_path = Path.join(System.tmp_dir!(), "test_compile_#{:rand.uniform(100000)}.ex")
+      tmp_path = Path.join(System.tmp_dir!(), "test_compile_#{:rand.uniform(100_000)}.ex")
 
       File.write!(tmp_path, """
       defmodule FromFile do
@@ -381,7 +383,7 @@ defmodule Firebird.Compiler.PipelineIntegrationTest do
 
     test "returns error for non-existent .ex file" do
       assert {:error, {:file_error, :enoent, _}} =
-               Firebird.Compiler.compile("/tmp/nonexistent_#{:rand.uniform(999999)}.ex")
+               Firebird.Compiler.compile("/tmp/nonexistent_#{:rand.uniform(999_999)}.ex")
     end
   end
 
@@ -411,7 +413,7 @@ defmodule Firebird.Compiler.PipelineIntegrationTest do
 
   describe "output_dir option" do
     test "writes .wat and .wasm files to output dir" do
-      dir = Path.join(System.tmp_dir!(), "firebird_test_out_#{:rand.uniform(100000)}")
+      dir = Path.join(System.tmp_dir!(), "firebird_test_out_#{:rand.uniform(100_000)}")
 
       source = """
       defmodule OutputDir do
@@ -441,13 +443,11 @@ defmodule Firebird.Compiler.PipelineIntegrationTest do
     end
 
     test "parse error for invalid Elixir" do
-      assert {:error, {:parse_error, _, _, _}} =
-               Firebird.Compiler.parse("def (( broken")
+      assert {:error, {:parse_error, _, _, _}} = Firebird.Compiler.parse("def (( broken")
     end
 
     test "source with no module returns error" do
-      assert {:error, :no_module_found} =
-               Firebird.Compiler.compile_source("x = 1 + 2")
+      assert {:error, :no_module_found} = Firebird.Compiler.compile_source("x = 1 + 2")
     end
   end
 
@@ -463,8 +463,12 @@ defmodule Firebird.Compiler.PipelineIntegrationTest do
         name: :test,
         arity: 1,
         params: [:p0],
-        body: {:block, [{:let, :x, {:binop, :add, {:var, :p0}, {:literal, 1}}},
-                         {:binop, :mul, {:var, :x}, {:literal, 2}}]},
+        body:
+          {:block,
+           [
+             {:let, :x, {:binop, :add, {:var, :p0}, {:literal, 1}}},
+             {:binop, :mul, {:var, :x}, {:literal, 2}}
+           ]},
         clauses: [],
         type: %IR.FunctionType{params: [:i64], return: :i64}
       }
@@ -480,10 +484,12 @@ defmodule Firebird.Compiler.PipelineIntegrationTest do
         name: :test,
         arity: 1,
         params: [:p0],
-        body: {:case, {:var, :p0}, [
-          {{:literal_pat, 0}, nil, {:literal, 100}},
-          {:wildcard, nil, {:literal, 200}}
-        ]},
+        body:
+          {:case, {:var, :p0},
+           [
+             {{:literal_pat, 0}, nil, {:literal, 100}},
+             {:wildcard, nil, {:literal, 200}}
+           ]},
         clauses: [],
         type: %IR.FunctionType{params: [:i64], return: :i64}
       }
diff --git a/test/compiler/pipeline_test.exs b/test/compiler/pipeline_test.exs
index 7170852..d5c5c2e 100644
--- a/test/compiler/pipeline_test.exs
+++ b/test/compiler/pipeline_test.exs
@@ -34,7 +34,9 @@ defmodule Firebird.Compiler.PipelineTest do
     test "complex expression" do
       assert_compiles_and_runs(
         "def compute(a, b), do: a * b + div(a, b) - rem(a, b)",
-        "compute", [17, 5], 17 * 5 + div(17, 5) - rem(17, 5)
+        "compute",
+        [17, 5],
+        17 * 5 + div(17, 5) - rem(17, 5)
       )
     end
   end
@@ -65,6 +67,7 @@ defmodule Firebird.Compiler.PipelineTest do
         if n > 0, do: 1, else: 0
       end
       """
+
       assert_compiles_and_runs(source, "classify", [5], 1)
     end
 
@@ -82,6 +85,7 @@ defmodule Firebird.Compiler.PipelineTest do
         end
       end
       """
+
       assert_compiles_and_runs(source, "sign", [5], 1)
       assert_compiles_and_runs_second("sign", [-5], -1)
       assert_compiles_and_runs_second("sign", [0], 0)
@@ -98,6 +102,7 @@ defmodule Firebird.Compiler.PipelineTest do
         end
       end
       """
+
       assert_compiles_and_runs(source, "cond_test", [200], 3)
       assert_compiles_and_runs_second("cond_test", [50], 2)
       assert_compiles_and_runs_second("cond_test", [5], 1)
@@ -114,6 +119,7 @@ defmodule Firebird.Compiler.PipelineTest do
         end
       end
       """
+
       assert_compiles_and_runs(source, "case_test", [0], 100)
       assert_compiles_and_runs_second("case_test", [1], 200)
       assert_compiles_and_runs_second("case_test", [99], 300)
@@ -127,6 +133,7 @@ defmodule Firebird.Compiler.PipelineTest do
       def fibonacci(1), do: 1
       def fibonacci(n), do: fibonacci(n - 1) + fibonacci(n - 2)
       """
+
       assert_compiles_and_runs(source, "fibonacci", [0], 0)
       assert_compiles_and_runs_second("fibonacci", [1], 1)
       assert_compiles_and_runs_second("fibonacci", [10], 55)
@@ -137,6 +144,7 @@ defmodule Firebird.Compiler.PipelineTest do
       def factorial(0), do: 1
       def factorial(n), do: n * factorial(n - 1)
       """
+
       assert_compiles_and_runs(source, "factorial", [0], 1)
       assert_compiles_and_runs_second("factorial", [5], 120)
     end
@@ -146,6 +154,7 @@ defmodule Firebird.Compiler.PipelineTest do
       def power(_, 0), do: 1
       def power(base, exp), do: base * power(base, exp - 1)
       """
+
       assert_compiles_and_runs(source, "power", [2, 10], 1024)
     end
 
@@ -154,6 +163,7 @@ defmodule Firebird.Compiler.PipelineTest do
       def gcd(a, 0), do: a
       def gcd(a, b), do: gcd(b, rem(a, b))
       """
+
       assert_compiles_and_runs(source, "gcd", [12, 18], 6)
     end
   end
@@ -167,6 +177,7 @@ defmodule Firebird.Compiler.PipelineTest do
         x + y
       end
       """
+
       assert_compiles_and_runs(source, "compute", [3, 4], 3 + 4 + 3 * 4)
     end
   end
@@ -197,17 +208,16 @@ defmodule Firebird.Compiler.PipelineTest do
   describe "full pipeline: error handling" do
     test "parse errors return error tuple" do
       assert {:error, {:parse_error, _, _, _}} =
-        Firebird.Compiler.compile_source("defmodule Bad do def x(")
+               Firebird.Compiler.compile_source("defmodule Bad do def x(")
     end
 
     test "no module returns error" do
-      assert {:error, :no_module_found} =
-        Firebird.Compiler.compile_source("1 + 2")
+      assert {:error, :no_module_found} = Firebird.Compiler.compile_source("1 + 2")
     end
 
     test "file not found returns error" do
       assert {:error, {:file_error, :enoent, _}} =
-        Firebird.Compiler.compile("/nonexistent/path.ex")
+               Firebird.Compiler.compile("/nonexistent/path.ex")
     end
   end
 
@@ -218,6 +228,7 @@ defmodule Firebird.Compiler.PipelineTest do
         a + 0 + 1 * a
       end
       """
+
       {:ok, result} = compile_module(source, optimize: true)
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [20]} = Firebird.call(inst, "compute", [10])
@@ -229,6 +240,7 @@ defmodule Firebird.Compiler.PipelineTest do
       def sum_acc(0, acc), do: acc
       def sum_acc(n, acc), do: sum_acc(n - 1, acc + n)
       """
+
       {:ok, result} = compile_module(source, tco: true)
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [5050]} = Firebird.call(inst, "sum_acc", [100, 0])
@@ -243,12 +255,14 @@ defmodule Firebird.Compiler.PipelineTest do
 
   defp compile_module(body_source, opts \\ []) do
     mod_name = "PipelineTest#{System.unique_integer([:positive])}"
+
     source = """
     defmodule #{mod_name} do
       @wasm true
       #{body_source}
     end
     """
+
     Firebird.Compiler.compile_source(source, opts)
   end
 
@@ -262,6 +276,7 @@ defmodule Firebird.Compiler.PipelineTest do
 
   defp assert_compiles_and_runs_second(func_name, args, expected) do
     instance = Process.get(:last_instance)
+
     if instance do
       assert {:ok, [^expected]} = Firebird.call(instance, func_name, args)
     end
diff --git a/test/compiler/source_map_test.exs b/test/compiler/source_map_test.exs
index 3272c68..98e9c76 100644
--- a/test/compiler/source_map_test.exs
+++ b/test/compiler/source_map_test.exs
@@ -36,12 +36,15 @@ defmodule Firebird.Compiler.SourceMapTest do
     end
 
     test "entries contain correct function info" do
-      func = make_func(:fibonacci, [:n],
-        {:if, {:binop, :le_s, {:var, :n}, {:literal, 1}},
-         {:var, :n},
-         {:binop, :add,
-           {:call, :fibonacci, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
-           {:call, :fibonacci, [{:binop, :sub, {:var, :n}, {:literal, 2}}]}}})
+      func =
+        make_func(
+          :fibonacci,
+          [:n],
+          {:if, {:binop, :le_s, {:var, :n}, {:literal, 1}}, {:var, :n},
+           {:binop, :add, {:call, :fibonacci, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
+            {:call, :fibonacci, [{:binop, :sub, {:var, :n}, {:literal, 2}}]}}}
+        )
+
       module = make_module(:Math, [func])
 
       {:ok, sm} = SourceMap.generate(module)
@@ -54,8 +57,13 @@ defmodule Firebird.Compiler.SourceMapTest do
     end
 
     test "detects tail recursive functions" do
-      func = make_func(:loop, [:n, :acc],
-        {:tail_loop, [:n, :acc], {:tail_call, :loop, [{:var, :n}, {:var, :acc}]}})
+      func =
+        make_func(
+          :loop,
+          [:n, :acc],
+          {:tail_loop, [:n, :acc], {:tail_call, :loop, [{:var, :n}, {:var, :acc}]}}
+        )
+
       module = make_module(:Loop, [func])
 
       {:ok, sm} = SourceMap.generate(module)
diff --git a/test/compiler/strength_reduce_div_rem_test.exs b/test/compiler/strength_reduce_div_rem_test.exs
index df1d2cc..e0c2b26 100644
--- a/test/compiler/strength_reduce_div_rem_test.exs
+++ b/test/compiler/strength_reduce_div_rem_test.exs
@@ -62,7 +62,9 @@ defmodule Firebird.Compiler.StrengthReduceDivRemTest do
     test "nested div: div(div(x, 4), 2)" do
       input = {:binop, :div_s, {:binop, :div_s, {:var, :n}, {:literal, 4}}, {:literal, 2}}
       result = Optimizer.strength_reduce(input)
-      assert result == {:binop, :shr_s, {:binop, :shr_s, {:var, :n}, {:literal, 2}}, {:literal, 1}}
+
+      assert result ==
+               {:binop, :shr_s, {:binop, :shr_s, {:var, :n}, {:literal, 2}}, {:literal, 1}}
     end
   end
 
@@ -135,20 +137,21 @@ defmodule Firebird.Compiler.StrengthReduceDivRemTest do
       # This is the hot path in collatz: `if rem(n, 2) == 0 do ...`
       input = {:binop, :eq, {:binop, :rem_s, {:var, :n}, {:literal, 2}}, {:literal, 0}}
 
-      {:ok, module} = Optimizer.optimize(%Firebird.Compiler.IR.Module{
-        name: :Test,
-        functions: [
-          %Firebird.Compiler.IR.Function{
-            name: :test,
-            arity: 1,
-            params: [:p0],
-            body: input,
-            clauses: [],
-            type: nil
-          }
-        ],
-        exports: [:test]
-      })
+      {:ok, module} =
+        Optimizer.optimize(%Firebird.Compiler.IR.Module{
+          name: :Test,
+          functions: [
+            %Firebird.Compiler.IR.Function{
+              name: :test,
+              arity: 1,
+              params: [:p0],
+              body: input,
+              clauses: [],
+              type: nil
+            }
+          ],
+          exports: [:test]
+        })
 
       [func] = module.functions
       # rem(n, 2) should become band(n, 1), and band(n, 1) == 0 stays as-is
@@ -158,20 +161,21 @@ defmodule Firebird.Compiler.StrengthReduceDivRemTest do
     test "collatz halving pattern: div(n, 2)" do
       input = {:binop, :div_s, {:var, :n}, {:literal, 2}}
 
-      {:ok, module} = Optimizer.optimize(%Firebird.Compiler.IR.Module{
-        name: :Test,
-        functions: [
-          %Firebird.Compiler.IR.Function{
-            name: :test,
-            arity: 1,
-            params: [:p0],
-            body: input,
-            clauses: [],
-            type: nil
-          }
-        ],
-        exports: [:test]
-      })
+      {:ok, module} =
+        Optimizer.optimize(%Firebird.Compiler.IR.Module{
+          name: :Test,
+          functions: [
+            %Firebird.Compiler.IR.Function{
+              name: :test,
+              arity: 1,
+              params: [:p0],
+              body: input,
+              clauses: [],
+              type: nil
+            }
+          ],
+          exports: [:test]
+        })
 
       [func] = module.functions
       assert func.body == {:binop, :shr_s, {:var, :n}, {:literal, 1}}
@@ -181,20 +185,21 @@ defmodule Firebird.Compiler.StrengthReduceDivRemTest do
       # div(16, 4) should strength-reduce to shr_s(16, 2), then constant-fold to 4
       input = {:binop, :div_s, {:literal, 16}, {:literal, 4}}
 
-      {:ok, module} = Optimizer.optimize(%Firebird.Compiler.IR.Module{
-        name: :Test,
-        functions: [
-          %Firebird.Compiler.IR.Function{
-            name: :test,
-            arity: 0,
-            params: [],
-            body: input,
-            clauses: [],
-            type: nil
-          }
-        ],
-        exports: [:test]
-      })
+      {:ok, module} =
+        Optimizer.optimize(%Firebird.Compiler.IR.Module{
+          name: :Test,
+          functions: [
+            %Firebird.Compiler.IR.Function{
+              name: :test,
+              arity: 0,
+              params: [],
+              body: input,
+              clauses: [],
+              type: nil
+            }
+          ],
+          exports: [:test]
+        })
 
       [func] = module.functions
       assert func.body == {:literal, 4}
@@ -204,20 +209,21 @@ defmodule Firebird.Compiler.StrengthReduceDivRemTest do
       # rem(7, 4) should strength-reduce to band(7, 3), then constant-fold to 3
       input = {:binop, :rem_s, {:literal, 7}, {:literal, 4}}
 
-      {:ok, module} = Optimizer.optimize(%Firebird.Compiler.IR.Module{
-        name: :Test,
-        functions: [
-          %Firebird.Compiler.IR.Function{
-            name: :test,
-            arity: 0,
-            params: [],
-            body: input,
-            clauses: [],
-            type: nil
-          }
-        ],
-        exports: [:test]
-      })
+      {:ok, module} =
+        Optimizer.optimize(%Firebird.Compiler.IR.Module{
+          name: :Test,
+          functions: [
+            %Firebird.Compiler.IR.Function{
+              name: :test,
+              arity: 0,
+              params: [],
+              body: input,
+              clauses: [],
+              type: nil
+            }
+          ],
+          exports: [:test]
+        })
 
       [func] = module.functions
       assert func.body == {:literal, 3}
diff --git a/test/compiler/summary_edge_cases_test.exs b/test/compiler/summary_edge_cases_test.exs
index 1d6cfb4..b60b799 100644
--- a/test/compiler/summary_edge_cases_test.exs
+++ b/test/compiler/summary_edge_cases_test.exs
@@ -136,7 +136,9 @@ defmodule Firebird.Compiler.Summary.EdgeCasesTest do
     end
 
     test "format includes Ratio line when compression_ratio is present" do
-      summary = Summary.generate([ok_result(:R, String.duplicate("x", 100), String.duplicate("y", 50))])
+      summary =
+        Summary.generate([ok_result(:R, String.duplicate("x", 100), String.duplicate("y", 50))])
+
       output = Summary.format(summary)
       assert output =~ "Ratio:"
       assert output =~ "50.0%"
@@ -158,8 +160,10 @@ defmodule Firebird.Compiler.Summary.EdgeCasesTest do
     end
 
     test "format_bytes for KB values" do
-      wat = String.duplicate("x", 2048)  # 2KB
-      wasm = String.duplicate("y", 1024)  # 1KB
+      # 2KB
+      wat = String.duplicate("x", 2048)
+      # 1KB
+      wasm = String.duplicate("y", 1024)
       summary = Summary.generate([ok_result(:KB, wat, wasm)])
       output = Summary.format(summary)
       assert output =~ "KB"
@@ -230,7 +234,9 @@ defmodule Firebird.Compiler.Summary.EdgeCasesTest do
     end
 
     test "compression_ratio is a number in JSON when present" do
-      summary = Summary.generate([ok_result(:A, String.duplicate("x", 100), String.duplicate("y", 50))])
+      summary =
+        Summary.generate([ok_result(:A, String.duplicate("x", 100), String.duplicate("y", 50))])
+
       json = Summary.to_json(summary)
       {:ok, parsed} = Jason.decode(json)
       assert is_number(parsed["compression_ratio"])
diff --git a/test/compiler/summary_test.exs b/test/compiler/summary_test.exs
index a31b46f..73a045a 100644
--- a/test/compiler/summary_test.exs
+++ b/test/compiler/summary_test.exs
@@ -63,9 +63,10 @@ defmodule Firebird.Compiler.SummaryTest do
 
   describe "format/1" do
     test "produces readable output" do
-      summary = Summary.generate([
-        {:ok, %{module: :Test, wat: "(module)", wasm: <<0, 0, 0>>}}
-      ])
+      summary =
+        Summary.generate([
+          {:ok, %{module: :Test, wat: "(module)", wasm: <<0, 0, 0>>}}
+        ])
 
       output = Summary.format(summary)
       assert output =~ "Compilation Summary"
@@ -76,9 +77,10 @@ defmodule Firebird.Compiler.SummaryTest do
 
   describe "to_json/1" do
     test "produces valid JSON" do
-      summary = Summary.generate([
-        {:ok, %{module: :JsonTest, wat: "(module)", wasm: <<0>>}}
-      ])
+      summary =
+        Summary.generate([
+          {:ok, %{module: :JsonTest, wat: "(module)", wasm: <<0>>}}
+        ])
 
       json = Summary.to_json(summary)
       assert {:ok, parsed} = Jason.decode(json)
@@ -86,4 +88,3 @@ defmodule Firebird.Compiler.SummaryTest do
     end
   end
 end
-
diff --git a/test/compiler/tco_block_codegen_test.exs b/test/compiler/tco_block_codegen_test.exs
index 64a1296..3a49aff 100644
--- a/test/compiler/tco_block_codegen_test.exs
+++ b/test/compiler/tco_block_codegen_test.exs
@@ -26,7 +26,9 @@ defmodule Firebird.Compiler.TCOBlockCodegenTest do
       end
       """
 
-      {:ok, result} = Firebird.Compiler.compile_source(source, optimize: true, tco: true, inline: true)
+      {:ok, result} =
+        Firebird.Compiler.compile_source(source, optimize: true, tco: true, inline: true)
+
       assert result.wasm != nil
 
       # WAT should NOT contain error markers
@@ -58,7 +60,9 @@ defmodule Firebird.Compiler.TCOBlockCodegenTest do
       end
       """
 
-      {:ok, result} = Firebird.Compiler.compile_source(source, optimize: true, tco: true, inline: true)
+      {:ok, result} =
+        Firebird.Compiler.compile_source(source, optimize: true, tco: true, inline: true)
+
       refute String.contains?(result.wat, "error: unknown expression")
 
       {:ok, instance} = Firebird.load(result.wasm)
@@ -81,7 +85,9 @@ defmodule Firebird.Compiler.TCOBlockCodegenTest do
       end
       """
 
-      {:ok, result} = Firebird.Compiler.compile_source(source, optimize: true, tco: true, inline: true)
+      {:ok, result} =
+        Firebird.Compiler.compile_source(source, optimize: true, tco: true, inline: true)
+
       refute String.contains?(result.wat, "error: unknown expression")
 
       {:ok, instance} = Firebird.load(result.wasm)
@@ -109,7 +115,9 @@ defmodule Firebird.Compiler.TCOBlockCodegenTest do
       end
       """
 
-      {:ok, result} = Firebird.Compiler.compile_source(source, optimize: true, tco: true, inline: true)
+      {:ok, result} =
+        Firebird.Compiler.compile_source(source, optimize: true, tco: true, inline: true)
+
       refute String.contains?(result.wat, "error: unknown expression")
 
       {:ok, instance} = Firebird.load(result.wasm)
@@ -138,7 +146,9 @@ defmodule Firebird.Compiler.TCOBlockCodegenTest do
       end
       """
 
-      {:ok, result} = Firebird.Compiler.compile_source(source, optimize: true, tco: true, inline: true)
+      {:ok, result} =
+        Firebird.Compiler.compile_source(source, optimize: true, tco: true, inline: true)
+
       refute String.contains?(result.wat, "error: unknown expression")
 
       {:ok, instance} = Firebird.load(result.wasm)
@@ -164,7 +174,9 @@ defmodule Firebird.Compiler.TCOBlockCodegenTest do
       end
       """
 
-      {:ok, result} = Firebird.Compiler.compile_source(source, optimize: true, tco: true, inline: true)
+      {:ok, result} =
+        Firebird.Compiler.compile_source(source, optimize: true, tco: true, inline: true)
+
       refute String.contains?(result.wat, "error: unknown expression")
 
       {:ok, instance} = Firebird.load(result.wasm)
diff --git a/test/compiler/tco_edge_cases_test.exs b/test/compiler/tco_edge_cases_test.exs
index 2969b9f..e56cd42 100644
--- a/test/compiler/tco_edge_cases_test.exs
+++ b/test/compiler/tco_edge_cases_test.exs
@@ -75,25 +75,34 @@ defmodule Firebird.Compiler.TCOEdgeCasesTest do
 
   describe "has_self_calls?/2 with case" do
     test "finds self call in case subject" do
-      expr = {:case, {:call, :foo, [{:literal, 1}]}, [
-        {{:literal_pat, 0}, nil, {:literal, 1}}
-      ]}
+      expr =
+        {:case, {:call, :foo, [{:literal, 1}]},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 1}}
+         ]}
+
       assert TCO.has_self_calls?(expr, :foo)
     end
 
     test "finds self call in case clause body" do
-      expr = {:case, {:var, :n}, [
-        {{:literal_pat, 0}, nil, {:literal, 1}},
-        {:wildcard, nil, {:call, :foo, [{:literal, 2}]}}
-      ]}
+      expr =
+        {:case, {:var, :n},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 1}},
+           {:wildcard, nil, {:call, :foo, [{:literal, 2}]}}
+         ]}
+
       assert TCO.has_self_calls?(expr, :foo)
     end
 
     test "returns false for case with no self calls" do
-      expr = {:case, {:var, :n}, [
-        {{:literal_pat, 0}, nil, {:literal, 1}},
-        {:wildcard, nil, {:literal, 2}}
-      ]}
+      expr =
+        {:case, {:var, :n},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 1}},
+           {:wildcard, nil, {:literal, 2}}
+         ]}
+
       refute TCO.has_self_calls?(expr, :foo)
     end
   end
@@ -151,17 +160,23 @@ defmodule Firebird.Compiler.TCOEdgeCasesTest do
     end
 
     test "self call in case clause body IS in tail position" do
-      expr = {:case, {:var, :n}, [
-        {{:literal_pat, 0}, nil, {:literal, 1}},
-        {:wildcard, nil, {:call, :foo, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}
-      ]}
+      expr =
+        {:case, {:var, :n},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 1}},
+           {:wildcard, nil, {:call, :foo, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}
+         ]}
+
       assert TCO.all_self_calls_in_tail_position?(expr, :foo)
     end
 
     test "self call in case subject is NOT in tail position" do
-      expr = {:case, {:call, :foo, [{:literal, 1}]}, [
-        {{:literal_pat, 0}, nil, {:literal, 1}}
-      ]}
+      expr =
+        {:case, {:call, :foo, [{:literal, 1}]},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 1}}
+         ]}
+
       refute TCO.all_self_calls_in_tail_position?(expr, :foo)
     end
 
@@ -196,43 +211,71 @@ defmodule Firebird.Compiler.TCOEdgeCasesTest do
 
   describe "is_tail_recursive?/1 with case" do
     test "case with tail call in clause body is tail recursive" do
-      func = make_func(:countdown, 1, [:p0],
-        {:case, {:var, :p0}, [
-          {{:literal_pat, 0}, nil, {:literal, 0}},
-          {:wildcard, nil, {:call, :countdown, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]}}
-        ]})
+      func =
+        make_func(
+          :countdown,
+          1,
+          [:p0],
+          {:case, {:var, :p0},
+           [
+             {{:literal_pat, 0}, nil, {:literal, 0}},
+             {:wildcard, nil, {:call, :countdown, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]}}
+           ]}
+        )
+
       assert TCO.is_tail_recursive?(func)
     end
 
     test "case with non-tail call in clause body is not tail recursive" do
-      func = make_func(:f, 1, [:p0],
-        {:case, {:var, :p0}, [
-          {{:literal_pat, 0}, nil, {:literal, 0}},
-          {:wildcard, nil, {:binop, :add, {:literal, 1},
-            {:call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]}}}
-        ]})
+      func =
+        make_func(
+          :f,
+          1,
+          [:p0],
+          {:case, {:var, :p0},
+           [
+             {{:literal_pat, 0}, nil, {:literal, 0}},
+             {:wildcard, nil,
+              {:binop, :add, {:literal, 1},
+               {:call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]}}}
+           ]}
+        )
+
       refute TCO.is_tail_recursive?(func)
     end
   end
 
   describe "is_tail_recursive?/1 with blocks" do
     test "tail call as last expression in block is tail recursive" do
-      func = make_func(:f, 1, [:p0],
-        {:block, [
-          {:let, :x, {:binop, :sub, {:var, :p0}, {:literal, 1}}},
-          {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}},
-            {:literal, 0},
-            {:call, :f, [{:var, :x}]}}
-        ]})
+      func =
+        make_func(
+          :f,
+          1,
+          [:p0],
+          {:block,
+           [
+             {:let, :x, {:binop, :sub, {:var, :p0}, {:literal, 1}}},
+             {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:literal, 0},
+              {:call, :f, [{:var, :x}]}}
+           ]}
+        )
+
       assert TCO.is_tail_recursive?(func)
     end
 
     test "tail call in non-last block position is not tail recursive" do
-      func = make_func(:f, 1, [:p0],
-        {:block, [
-          {:call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]},
-          {:literal, 42}
-        ]})
+      func =
+        make_func(
+          :f,
+          1,
+          [:p0],
+          {:block,
+           [
+             {:call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]},
+             {:literal, 42}
+           ]}
+        )
+
       refute TCO.is_tail_recursive?(func)
     end
   end
@@ -255,6 +298,7 @@ defmodule Firebird.Compiler.TCOEdgeCasesTest do
         ],
         exports: [:add, :mul]
       }
+
       {:ok, result} = TCO.optimize(module)
       # No function should be transformed
       for func <- result.functions do
@@ -267,21 +311,25 @@ defmodule Firebird.Compiler.TCOEdgeCasesTest do
         name: :Mixed,
         functions: [
           make_func(:add, 2, [:p0, :p1], {:binop, :add, {:var, :p0}, {:var, :p1}}),
-          make_func(:countdown, 1, [:p0],
-            {:if,
-              {:binop, :le_s, {:var, :p0}, {:literal, 0}},
-              {:literal, 0},
-              {:call, :countdown, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]}}),
-          make_func(:fib, 1, [:p0],
-            {:if,
-              {:binop, :le_s, {:var, :p0}, {:literal, 1}},
-              {:var, :p0},
-              {:binop, :add,
-                {:call, :fib, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]},
-                {:call, :fib, [{:binop, :sub, {:var, :p0}, {:literal, 2}}]}}})
+          make_func(
+            :countdown,
+            1,
+            [:p0],
+            {:if, {:binop, :le_s, {:var, :p0}, {:literal, 0}}, {:literal, 0},
+             {:call, :countdown, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]}}
+          ),
+          make_func(
+            :fib,
+            1,
+            [:p0],
+            {:if, {:binop, :le_s, {:var, :p0}, {:literal, 1}}, {:var, :p0},
+             {:binop, :add, {:call, :fib, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]},
+              {:call, :fib, [{:binop, :sub, {:var, :p0}, {:literal, 2}}]}}}
+          )
         ],
         exports: [:add, :countdown, :fib]
       }
+
       {:ok, result} = TCO.optimize(module)
 
       [add_f, countdown_f, fib_f] = result.functions
@@ -294,11 +342,14 @@ defmodule Firebird.Compiler.TCOEdgeCasesTest do
     end
 
     test "transformed body contains :tail_call markers" do
-      func = make_func(:countdown, 1, [:p0],
-        {:if,
-          {:binop, :le_s, {:var, :p0}, {:literal, 0}},
-          {:literal, 0},
-          {:call, :countdown, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]}})
+      func =
+        make_func(
+          :countdown,
+          1,
+          [:p0],
+          {:if, {:binop, :le_s, {:var, :p0}, {:literal, 0}}, {:literal, 0},
+           {:call, :countdown, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]}}
+        )
 
       module = %IR.Module{name: :Test, functions: [func], exports: [:countdown]}
       {:ok, result} = TCO.optimize(module)
@@ -313,11 +364,17 @@ defmodule Firebird.Compiler.TCOEdgeCasesTest do
     end
 
     test "mark_tail_calls transforms case clause bodies" do
-      func = make_func(:f, 1, [:p0],
-        {:case, {:var, :p0}, [
-          {{:literal_pat, 0}, nil, {:literal, 0}},
-          {:wildcard, nil, {:call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]}}
-        ]})
+      func =
+        make_func(
+          :f,
+          1,
+          [:p0],
+          {:case, {:var, :p0},
+           [
+             {{:literal_pat, 0}, nil, {:literal, 0}},
+             {:wildcard, nil, {:call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]}}
+           ]}
+        )
 
       module = %IR.Module{name: :Test, functions: [func], exports: [:f]}
       {:ok, result} = TCO.optimize(module)
@@ -333,13 +390,18 @@ defmodule Firebird.Compiler.TCOEdgeCasesTest do
     end
 
     test "mark_tail_calls transforms last expr in block" do
-      func = make_func(:f, 1, [:p0],
-        {:block, [
-          {:let, :x, {:binop, :sub, {:var, :p0}, {:literal, 1}}},
-          {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}},
-            {:literal, 0},
-            {:call, :f, [{:var, :x}]}}
-        ]})
+      func =
+        make_func(
+          :f,
+          1,
+          [:p0],
+          {:block,
+           [
+             {:let, :x, {:binop, :sub, {:var, :p0}, {:literal, 1}}},
+             {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:literal, 0},
+              {:call, :f, [{:var, :x}]}}
+           ]}
+        )
 
       module = %IR.Module{name: :Test, functions: [func], exports: [:f]}
       {:ok, result} = TCO.optimize(module)
@@ -354,11 +416,14 @@ defmodule Firebird.Compiler.TCOEdgeCasesTest do
 
     test "mark_tail_calls does not transform non-tail calls" do
       # A function where the non-tail call is preserved
-      func = make_func(:f, 1, [:p0],
-        {:if,
-          {:binop, :eq, {:var, :p0}, {:literal, 0}},
-          {:literal, 0},
-          {:call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]}})
+      func =
+        make_func(
+          :f,
+          1,
+          [:p0],
+          {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:literal, 0},
+           {:call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]}}
+        )
 
       module = %IR.Module{name: :Test, functions: [func], exports: [:f]}
       {:ok, result} = TCO.optimize(module)
@@ -372,11 +437,14 @@ defmodule Firebird.Compiler.TCOEdgeCasesTest do
 
     test "mark_tail_calls passes through non-matching expressions" do
       # Function with tail call but also a literal in then branch
-      func = make_func(:f, 1, [:p0],
-        {:if,
-          {:binop, :eq, {:var, :p0}, {:literal, 0}},
-          {:var, :p0},
-          {:call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]}})
+      func =
+        make_func(
+          :f,
+          1,
+          [:p0],
+          {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:var, :p0},
+           {:call, :f, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]}}
+        )
 
       module = %IR.Module{name: :Test, functions: [func], exports: [:f]}
       {:ok, result} = TCO.optimize(module)
@@ -432,16 +500,18 @@ defmodule Firebird.Compiler.TCOEdgeCasesTest do
     end
 
     test "validates deeply nested valid expression" do
-      expr = {:block, [
-        {:let, :x, {:binop, :add, {:literal, 1}, {:literal, 2}}},
-        {:if,
-          {:binop, :gt_s, {:var, :x}, {:literal, 0}},
-          {:call, :foo, [{:var, :x}]},
-          {:case, {:var, :x}, [
-            {{:literal_pat, 0}, nil, {:literal, 0}},
-            {:wildcard, nil, {:unaryop, :negate, {:var, :x}}}
-          ]}}
-      ]}
+      expr =
+        {:block,
+         [
+           {:let, :x, {:binop, :add, {:literal, 1}, {:literal, 2}}},
+           {:if, {:binop, :gt_s, {:var, :x}, {:literal, 0}}, {:call, :foo, [{:var, :x}]},
+            {:case, {:var, :x},
+             [
+               {{:literal_pat, 0}, nil, {:literal, 0}},
+               {:wildcard, nil, {:unaryop, :negate, {:var, :x}}}
+             ]}}
+         ]}
+
       assert [] = Validator.validate_expr(expr, :test)
     end
   end
diff --git a/test/compiler/tco_test.exs b/test/compiler/tco_test.exs
index 936812e..3f550b3 100644
--- a/test/compiler/tco_test.exs
+++ b/test/compiler/tco_test.exs
@@ -45,9 +45,12 @@ defmodule Firebird.Compiler.TCOTest do
     end
 
     test "detects self call in case" do
-      expr = {:case, {:var, :x}, [
-        {{:literal_pat, 0}, nil, {:call, :foo, [{:literal, 1}]}}
-      ]}
+      expr =
+        {:case, {:var, :x},
+         [
+           {{:literal_pat, 0}, nil, {:call, :foo, [{:literal, 1}]}}
+         ]}
+
       assert TCO.has_self_calls?(expr, :foo)
     end
 
@@ -79,13 +82,13 @@ defmodule Firebird.Compiler.TCOTest do
         name: :sum_acc,
         arity: 2,
         params: [:n, :acc],
-        body: {:if,
-          {:binop, :eq, {:var, :n}, {:literal, 0}},
-          {:var, :acc},
-          {:call, :sum_acc, [
-            {:binop, :sub, {:var, :n}, {:literal, 1}},
-            {:binop, :add, {:var, :acc}, {:var, :n}}
-          ]}},
+        body:
+          {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:var, :acc},
+           {:call, :sum_acc,
+            [
+              {:binop, :sub, {:var, :n}, {:literal, 1}},
+              {:binop, :add, {:var, :acc}, {:var, :n}}
+            ]}},
         clauses: [],
         type: nil
       }
@@ -99,10 +102,9 @@ defmodule Firebird.Compiler.TCOTest do
         name: :factorial,
         arity: 1,
         params: [:n],
-        body: {:if,
-          {:binop, :eq, {:var, :n}, {:literal, 0}},
-          {:literal, 1},
-          {:binop, :mul, {:var, :n},
+        body:
+          {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:literal, 1},
+           {:binop, :mul, {:var, :n},
             {:call, :factorial, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}},
         clauses: [],
         type: nil
@@ -129,10 +131,7 @@ defmodule Firebird.Compiler.TCOTest do
         name: :weird,
         arity: 1,
         params: [:n],
-        body: {:if,
-          {:call, :weird, [{:literal, 0}]},
-          {:literal, 1},
-          {:literal, 2}},
+        body: {:if, {:call, :weird, [{:literal, 0}]}, {:literal, 1}, {:literal, 2}},
         clauses: [],
         type: nil
       }
@@ -145,10 +144,10 @@ defmodule Firebird.Compiler.TCOTest do
         name: :bounce,
         arity: 1,
         params: [:n],
-        body: {:if,
-          {:binop, :gt_s, {:var, :n}, {:literal, 100}},
-          {:call, :bounce, [{:binop, :sub, {:var, :n}, {:literal, 10}}]},
-          {:call, :bounce, [{:binop, :add, {:var, :n}, {:literal, 1}}]}},
+        body:
+          {:if, {:binop, :gt_s, {:var, :n}, {:literal, 100}},
+           {:call, :bounce, [{:binop, :sub, {:var, :n}, {:literal, 10}}]},
+           {:call, :bounce, [{:binop, :add, {:var, :n}, {:literal, 1}}]}},
         clauses: [],
         type: nil
       }
@@ -161,10 +160,12 @@ defmodule Firebird.Compiler.TCOTest do
         name: :count,
         arity: 1,
         params: [:n],
-        body: {:case, {:var, :n}, [
-          {{:literal_pat, 0}, nil, {:literal, 0}},
-          {{:var_pat, :_}, nil, {:call, :count, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}
-        ]},
+        body:
+          {:case, {:var, :n},
+           [
+             {{:literal_pat, 0}, nil, {:literal, 0}},
+             {{:var_pat, :_}, nil, {:call, :count, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}
+           ]},
         clauses: [],
         type: nil
       }
@@ -177,10 +178,12 @@ defmodule Firebird.Compiler.TCOTest do
         name: :bad,
         arity: 1,
         params: [:n],
-        body: {:block, [
-          {:let, :x, {:call, :bad, [{:literal, 0}]}},
-          {:var, :x}
-        ]},
+        body:
+          {:block,
+           [
+             {:let, :x, {:call, :bad, [{:literal, 0}]}},
+             {:var, :x}
+           ]},
         clauses: [],
         type: nil
       }
@@ -215,13 +218,13 @@ defmodule Firebird.Compiler.TCOTest do
         name: :sum_acc,
         arity: 2,
         params: [:n, :acc],
-        body: {:if,
-          {:binop, :eq, {:var, :n}, {:literal, 0}},
-          {:var, :acc},
-          {:call, :sum_acc, [
-            {:binop, :sub, {:var, :n}, {:literal, 1}},
-            {:binop, :add, {:var, :acc}, {:var, :n}}
-          ]}},
+        body:
+          {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:var, :acc},
+           {:call, :sum_acc,
+            [
+              {:binop, :sub, {:var, :n}, {:literal, 1}},
+              {:binop, :add, {:var, :acc}, {:var, :n}}
+            ]}},
         clauses: [],
         type: nil
       }
@@ -241,10 +244,9 @@ defmodule Firebird.Compiler.TCOTest do
         name: :factorial,
         arity: 1,
         params: [:n],
-        body: {:if,
-          {:binop, :eq, {:var, :n}, {:literal, 0}},
-          {:literal, 1},
-          {:binop, :mul, {:var, :n},
+        body:
+          {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:literal, 1},
+           {:binop, :mul, {:var, :n},
             {:call, :factorial, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}},
         clauses: [],
         type: nil
@@ -263,10 +265,9 @@ defmodule Firebird.Compiler.TCOTest do
         name: :loop,
         arity: 1,
         params: [:n],
-        body: {:if,
-          {:binop, :eq, {:var, :n}, {:literal, 0}},
-          {:literal, 0},
-          {:call, :loop, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}},
+        body:
+          {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:literal, 0},
+           {:call, :loop, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}},
         clauses: [],
         type: nil
       }
@@ -298,10 +299,12 @@ defmodule Firebird.Compiler.TCOTest do
         name: :count,
         arity: 1,
         params: [:n],
-        body: {:case, {:var, :n}, [
-          {{:literal_pat, 0}, nil, {:literal, 0}},
-          {{:var_pat, :_}, nil, {:call, :count, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}
-        ]},
+        body:
+          {:case, {:var, :n},
+           [
+             {{:literal_pat, 0}, nil, {:literal, 0}},
+             {{:var_pat, :_}, nil, {:call, :count, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}
+           ]},
         clauses: [],
         type: nil
       }
diff --git a/test/compiler/type_inference_edge_cases_test.exs b/test/compiler/type_inference_edge_cases_test.exs
index 23ae25e..0cb5b14 100644
--- a/test/compiler/type_inference_edge_cases_test.exs
+++ b/test/compiler/type_inference_edge_cases_test.exs
@@ -24,8 +24,7 @@ defmodule Firebird.Compiler.TypeInferenceEdgeCasesTest do
 
   describe "float detection and type widening" do
     test "function with float literal in body gets f64 params" do
-      func = make_function(:scale, 1, [:x],
-        {:binop, :mul, {:var, :x}, {:literal, 2.5}})
+      func = make_function(:scale, 1, [:x], {:binop, :mul, {:var, :x}, {:literal, 2.5}})
       module = make_module([func])
 
       assert {:ok, typed} = TypeInference.infer(module)
@@ -35,11 +34,15 @@ defmodule Firebird.Compiler.TypeInferenceEdgeCasesTest do
     end
 
     test "nested float in if branch triggers f64 params" do
-      func = make_function(:maybe_scale, 1, [:x],
-        {:if,
-          {:binop, :gt_s, {:var, :x}, {:literal, 0}},
-          {:binop, :mul, {:var, :x}, {:literal, 1.5}},
-          {:literal, 0}})
+      func =
+        make_function(
+          :maybe_scale,
+          1,
+          [:x],
+          {:if, {:binop, :gt_s, {:var, :x}, {:literal, 0}},
+           {:binop, :mul, {:var, :x}, {:literal, 1.5}}, {:literal, 0}}
+        )
+
       module = make_module([func])
 
       assert {:ok, typed} = TypeInference.infer(module)
@@ -48,8 +51,7 @@ defmodule Firebird.Compiler.TypeInferenceEdgeCasesTest do
     end
 
     test "float in call arguments triggers f64 params" do
-      func = make_function(:indirect_float, 1, [:x],
-        {:call, :helper, [{:literal, 3.14}]})
+      func = make_function(:indirect_float, 1, [:x], {:call, :helper, [{:literal, 3.14}]})
       module = make_module([func])
 
       assert {:ok, typed} = TypeInference.infer(module)
@@ -58,8 +60,7 @@ defmodule Firebird.Compiler.TypeInferenceEdgeCasesTest do
     end
 
     test "float in let binding triggers f64 params" do
-      func = make_function(:let_float, 1, [:x],
-        {:let, :y, {:literal, 2.718}})
+      func = make_function(:let_float, 1, [:x], {:let, :y, {:literal, 2.718}})
       module = make_module([func])
 
       assert {:ok, typed} = TypeInference.infer(module)
@@ -68,8 +69,7 @@ defmodule Firebird.Compiler.TypeInferenceEdgeCasesTest do
     end
 
     test "float in block triggers f64 params" do
-      func = make_function(:block_float, 1, [:x],
-        {:block, [{:literal, 1}, {:literal, 3.14}]})
+      func = make_function(:block_float, 1, [:x], {:block, [{:literal, 1}, {:literal, 3.14}]})
       module = make_module([func])
 
       assert {:ok, typed} = TypeInference.infer(module)
@@ -78,8 +78,7 @@ defmodule Firebird.Compiler.TypeInferenceEdgeCasesTest do
     end
 
     test "float in tail_loop body triggers f64 params" do
-      func = make_function(:loop_float, 1, [:x],
-        {:tail_loop, [:x], {:literal, 1.0}})
+      func = make_function(:loop_float, 1, [:x], {:tail_loop, [:x], {:literal, 1.0}})
       module = make_module([func])
 
       assert {:ok, typed} = TypeInference.infer(module)
@@ -88,8 +87,7 @@ defmodule Firebird.Compiler.TypeInferenceEdgeCasesTest do
     end
 
     test "float in tail_call args triggers f64 params" do
-      func = make_function(:tc_float, 1, [:x],
-        {:tail_call, :tc_float, [{:literal, 0.5}]})
+      func = make_function(:tc_float, 1, [:x], {:tail_call, :tc_float, [{:literal, 0.5}]})
       module = make_module([func])
 
       assert {:ok, typed} = TypeInference.infer(module)
@@ -98,8 +96,7 @@ defmodule Firebird.Compiler.TypeInferenceEdgeCasesTest do
     end
 
     test "no float keeps i64 params" do
-      func = make_function(:int_only, 2, [:a, :b],
-        {:binop, :add, {:var, :a}, {:var, :b}})
+      func = make_function(:int_only, 2, [:a, :b], {:binop, :add, {:var, :a}, {:var, :b}})
       module = make_module([func])
 
       assert {:ok, typed} = TypeInference.infer(module)
@@ -109,11 +106,16 @@ defmodule Firebird.Compiler.TypeInferenceEdgeCasesTest do
 
     test "check_for_floats returns false for non-float expressions" do
       # Exercised indirectly via integer-only functions
-      func = make_function(:pure_int, 1, [:n],
-        {:if,
-          {:binop, :eq, {:var, :n}, {:literal, 0}},
-          {:literal, 1},
-          {:binop, :mul, {:var, :n}, {:call, :pure_int, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}})
+      func =
+        make_function(
+          :pure_int,
+          1,
+          [:n],
+          {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:literal, 1},
+           {:binop, :mul, {:var, :n},
+            {:call, :pure_int, [{:binop, :sub, {:var, :n}, {:literal, 1}}]}}}
+        )
+
       module = make_module([func])
 
       assert {:ok, typed} = TypeInference.infer(module)
@@ -124,13 +126,11 @@ defmodule Firebird.Compiler.TypeInferenceEdgeCasesTest do
 
   describe "type widening rules" do
     test "f64 + i64 = f64" do
-      assert :f64 == TypeInference.infer_expr_type(
-        {:binop, :add, {:literal, 1.0}, {:literal, 1}})
+      assert :f64 == TypeInference.infer_expr_type({:binop, :add, {:literal, 1.0}, {:literal, 1}})
     end
 
     test "i64 + f64 = f64" do
-      assert :f64 == TypeInference.infer_expr_type(
-        {:binop, :add, {:literal, 1}, {:literal, 1.0}})
+      assert :f64 == TypeInference.infer_expr_type({:binop, :add, {:literal, 1}, {:literal, 1.0}})
     end
 
     test "i32 + i32 = i32 (via comparison results)" do
@@ -141,61 +141,59 @@ defmodule Firebird.Compiler.TypeInferenceEdgeCasesTest do
     end
 
     test "i64 + i64 = i64" do
-      assert :i64 == TypeInference.infer_expr_type(
-        {:binop, :add, {:literal, 1}, {:literal, 2}})
+      assert :i64 == TypeInference.infer_expr_type({:binop, :add, {:literal, 1}, {:literal, 2}})
     end
 
     test "all arithmetic ops widen correctly" do
       for op <- [:add, :sub, :mul, :div_s, :rem_s] do
         # i64 op i64 => i64
-        assert :i64 == TypeInference.infer_expr_type(
-          {:binop, op, {:literal, 1}, {:literal, 2}}),
-          "#{op} with i64,i64 should be i64"
+        assert :i64 == TypeInference.infer_expr_type({:binop, op, {:literal, 1}, {:literal, 2}}),
+               "#{op} with i64,i64 should be i64"
 
         # f64 op i64 => f64
-        assert :f64 == TypeInference.infer_expr_type(
-          {:binop, op, {:literal, 1.0}, {:literal, 2}}),
-          "#{op} with f64,i64 should be f64"
+        assert :f64 ==
+                 TypeInference.infer_expr_type({:binop, op, {:literal, 1.0}, {:literal, 2}}),
+               "#{op} with f64,i64 should be f64"
 
         # i64 op f64 => f64
-        assert :f64 == TypeInference.infer_expr_type(
-          {:binop, op, {:literal, 1}, {:literal, 2.0}}),
-          "#{op} with i64,f64 should be f64"
+        assert :f64 ==
+                 TypeInference.infer_expr_type({:binop, op, {:literal, 1}, {:literal, 2.0}}),
+               "#{op} with i64,f64 should be f64"
       end
     end
   end
 
   describe "tail_loop and tail_call expression types" do
     test "tail_loop type is body type" do
-      assert :i64 == TypeInference.infer_expr_type(
-        {:tail_loop, [:n, :acc], {:literal, 42}})
+      assert :i64 == TypeInference.infer_expr_type({:tail_loop, [:n, :acc], {:literal, 42}})
     end
 
     test "tail_loop with f64 body" do
-      assert :f64 == TypeInference.infer_expr_type(
-        {:tail_loop, [:x], {:literal, 3.14}})
+      assert :f64 == TypeInference.infer_expr_type({:tail_loop, [:x], {:literal, 3.14}})
     end
 
     test "tail_call defaults to i64" do
-      assert :i64 == TypeInference.infer_expr_type(
-        {:tail_call, :foo, [{:literal, 1}]})
+      assert :i64 == TypeInference.infer_expr_type({:tail_call, :foo, [{:literal, 1}]})
     end
   end
 
   describe "block expression types" do
     test "block type is type of last expression" do
-      assert :i64 == TypeInference.infer_expr_type(
-        {:block, [{:binop, :eq, {:literal, 1}, {:literal, 2}}, {:literal, 42}]})
+      assert :i64 ==
+               TypeInference.infer_expr_type(
+                 {:block, [{:binop, :eq, {:literal, 1}, {:literal, 2}}, {:literal, 42}]}
+               )
     end
 
     test "block with single element" do
-      assert :f64 == TypeInference.infer_expr_type(
-        {:block, [{:literal, 3.14}]})
+      assert :f64 == TypeInference.infer_expr_type({:block, [{:literal, 3.14}]})
     end
 
     test "block with comparison as last expr" do
-      assert :i32 == TypeInference.infer_expr_type(
-        {:block, [{:literal, 1}, {:binop, :gt_s, {:literal, 5}, {:literal, 3}}]})
+      assert :i32 ==
+               TypeInference.infer_expr_type(
+                 {:block, [{:literal, 1}, {:binop, :gt_s, {:literal, 5}, {:literal, 3}}]}
+               )
     end
   end
 
@@ -209,39 +207,49 @@ defmodule Firebird.Compiler.TypeInferenceEdgeCasesTest do
     end
 
     test "let with comparison value" do
-      assert :i32 == TypeInference.infer_expr_type(
-        {:let, :flag, {:binop, :eq, {:literal, 1}, {:literal, 1}}})
+      assert :i32 ==
+               TypeInference.infer_expr_type(
+                 {:let, :flag, {:binop, :eq, {:literal, 1}, {:literal, 1}}}
+               )
     end
   end
 
   describe "case expression types" do
     test "case type is first clause body type" do
-      assert :f64 == TypeInference.infer_expr_type(
-        {:case, {:var, :x}, [
-          {{:literal_pat, 0}, nil, {:literal, 1.0}},
-          {:wildcard, nil, {:literal, 2}}
-        ]})
+      assert :f64 ==
+               TypeInference.infer_expr_type(
+                 {:case, {:var, :x},
+                  [
+                    {{:literal_pat, 0}, nil, {:literal, 1.0}},
+                    {:wildcard, nil, {:literal, 2}}
+                  ]}
+               )
     end
 
     test "case with i32 return from first clause" do
-      assert :i32 == TypeInference.infer_expr_type(
-        {:case, {:var, :x}, [
-          {{:literal_pat, 0}, nil, {:binop, :eq, {:literal, 1}, {:literal, 1}}}
-        ]})
+      assert :i32 ==
+               TypeInference.infer_expr_type(
+                 {:case, {:var, :x},
+                  [
+                    {{:literal_pat, 0}, nil, {:binop, :eq, {:literal, 1}, {:literal, 1}}}
+                  ]}
+               )
     end
   end
 
   describe "if expression types" do
     test "if type follows then branch" do
-      assert :f64 == TypeInference.infer_expr_type(
-        {:if, {:literal, 1}, {:literal, 3.14}, {:literal, 0}})
+      assert :f64 ==
+               TypeInference.infer_expr_type(
+                 {:if, {:literal, 1}, {:literal, 3.14}, {:literal, 0}}
+               )
     end
 
     test "if with i32 then branch (comparison)" do
-      assert :i32 == TypeInference.infer_expr_type(
-        {:if, {:literal, 1},
-          {:binop, :eq, {:literal, 1}, {:literal, 2}},
-          {:literal, 0}})
+      assert :i32 ==
+               TypeInference.infer_expr_type(
+                 {:if, {:literal, 1}, {:binop, :eq, {:literal, 1}, {:literal, 2}}, {:literal, 0}}
+               )
     end
   end
 
@@ -267,8 +275,7 @@ defmodule Firebird.Compiler.TypeInferenceEdgeCasesTest do
       # negate isn't directly handled by infer_expr_type since IRGen
       # compiles -x as {:binop, :sub, {:literal, 0}, x}
       # But the unaryop :negate fallback exists - it returns i64
-      assert :i64 == TypeInference.infer_expr_type(
-        {:binop, :sub, {:literal, 0}, {:literal, 5}})
+      assert :i64 == TypeInference.infer_expr_type({:binop, :sub, {:literal, 0}, {:literal, 5}})
     end
   end
 
@@ -294,8 +301,7 @@ defmodule Firebird.Compiler.TypeInferenceEdgeCasesTest do
     test "each function gets independent type inference" do
       f1 = make_function(:int_fn, 1, [:n], {:literal, 42})
       f2 = make_function(:float_fn, 1, [:x], {:literal, 3.14})
-      f3 = make_function(:bool_fn, 2, [:a, :b],
-        {:binop, :eq, {:var, :a}, {:var, :b}})
+      f3 = make_function(:bool_fn, 2, [:a, :b], {:binop, :eq, {:var, :a}, {:var, :b}})
       module = make_module([f1, f2, f3])
 
       assert {:ok, typed} = TypeInference.infer(module)
@@ -315,39 +321,46 @@ defmodule Firebird.Compiler.TypeInferenceEdgeCasesTest do
   describe "nested expression type inference" do
     test "deeply nested arithmetic with mixed types" do
       # (1.0 + 2) * (3 - 4) => f64
-      expr = {:binop, :mul,
-        {:binop, :add, {:literal, 1.0}, {:literal, 2}},
-        {:binop, :sub, {:literal, 3}, {:literal, 4}}}
+      expr =
+        {:binop, :mul, {:binop, :add, {:literal, 1.0}, {:literal, 2}},
+         {:binop, :sub, {:literal, 3}, {:literal, 4}}}
+
       assert :f64 == TypeInference.infer_expr_type(expr)
     end
 
     test "comparison in if condition, arithmetic in branches" do
-      expr = {:if,
-        {:binop, :gt_s, {:literal, 5}, {:literal, 3}},
-        {:binop, :add, {:literal, 1.0}, {:literal, 2.0}},
-        {:literal, 0.0}}
+      expr =
+        {:if, {:binop, :gt_s, {:literal, 5}, {:literal, 3}},
+         {:binop, :add, {:literal, 1.0}, {:literal, 2.0}}, {:literal, 0.0}}
+
       assert :f64 == TypeInference.infer_expr_type(expr)
     end
 
     test "block with let and final expression" do
-      expr = {:block, [
-        {:let, :x, {:literal, 10}},
-        {:let, :y, {:literal, 20}},
-        {:binop, :add, {:var, :x}, {:var, :y}}
-      ]}
+      expr =
+        {:block,
+         [
+           {:let, :x, {:literal, 10}},
+           {:let, :y, {:literal, 20}},
+           {:binop, :add, {:var, :x}, {:var, :y}}
+         ]}
+
       assert :i64 == TypeInference.infer_expr_type(expr)
     end
   end
 
   describe "function with complex body types" do
     test "fibonacci-like function infers i64" do
-      func = make_function(:fib, 1, [:n],
-        {:if,
-          {:binop, :le_s, {:var, :n}, {:literal, 1}},
-          {:var, :n},
-          {:binop, :add,
-            {:call, :fib, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
-            {:call, :fib, [{:binop, :sub, {:var, :n}, {:literal, 2}}]}}})
+      func =
+        make_function(
+          :fib,
+          1,
+          [:n],
+          {:if, {:binop, :le_s, {:var, :n}, {:literal, 1}}, {:var, :n},
+           {:binop, :add, {:call, :fib, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
+            {:call, :fib, [{:binop, :sub, {:var, :n}, {:literal, 2}}]}}}
+        )
+
       module = make_module([func])
 
       assert {:ok, typed} = TypeInference.infer(module)
@@ -357,12 +370,19 @@ defmodule Firebird.Compiler.TypeInferenceEdgeCasesTest do
     end
 
     test "function with case expression" do
-      func = make_function(:classify, 1, [:n],
-        {:case, {:var, :n}, [
-          {{:literal_pat, 0}, nil, {:literal, 100}},
-          {{:literal_pat, 1}, nil, {:literal, 200}},
-          {:wildcard, nil, {:binop, :mul, {:var, :n}, {:literal, 10}}}
-        ]})
+      func =
+        make_function(
+          :classify,
+          1,
+          [:n],
+          {:case, {:var, :n},
+           [
+             {{:literal_pat, 0}, nil, {:literal, 100}},
+             {{:literal_pat, 1}, nil, {:literal, 200}},
+             {:wildcard, nil, {:binop, :mul, {:var, :n}, {:literal, 10}}}
+           ]}
+        )
+
       module = make_module([func])
 
       assert {:ok, typed} = TypeInference.infer(module)
@@ -371,15 +391,20 @@ defmodule Firebird.Compiler.TypeInferenceEdgeCasesTest do
     end
 
     test "tail-recursive function with tail_loop wrapper" do
-      func = make_function(:sum_acc, 2, [:n, :acc],
-        {:tail_loop, [:n, :acc],
-          {:if,
-            {:binop, :eq, {:var, :n}, {:literal, 0}},
-            {:var, :acc},
-            {:tail_call, :sum_acc, [
-              {:binop, :sub, {:var, :n}, {:literal, 1}},
-              {:binop, :add, {:var, :acc}, {:var, :n}}
-            ]}}})
+      func =
+        make_function(
+          :sum_acc,
+          2,
+          [:n, :acc],
+          {:tail_loop, [:n, :acc],
+           {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:var, :acc},
+            {:tail_call, :sum_acc,
+             [
+               {:binop, :sub, {:var, :n}, {:literal, 1}},
+               {:binop, :add, {:var, :acc}, {:var, :n}}
+             ]}}}
+        )
+
       module = make_module([func])
 
       assert {:ok, typed} = TypeInference.infer(module)
diff --git a/test/compiler/type_inference_test.exs b/test/compiler/type_inference_test.exs
index ecd7917..fa3421b 100644
--- a/test/compiler/type_inference_test.exs
+++ b/test/compiler/type_inference_test.exs
@@ -81,10 +81,13 @@ defmodule Firebird.Compiler.TypeInferenceTest do
     end
 
     test "case expression returns type of first clause body" do
-      expr = {:case, {:var, :x}, [
-        {{:literal_pat, 0}, nil, {:literal, 1.0}},
-        {:wildcard, nil, {:literal, 2}}
-      ]}
+      expr =
+        {:case, {:var, :x},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 1.0}},
+           {:wildcard, nil, {:literal, 2}}
+         ]}
+
       assert TypeInference.infer_expr_type(expr) == :f64
     end
 
@@ -138,8 +141,13 @@ defmodule Firebird.Compiler.TypeInferenceTest do
     end
 
     test "infers float params when body has float literals" do
-      func = make_func(:area, [:r],
-        {:binop, :mul, {:literal, 3.14}, {:binop, :mul, {:var, :r}, {:var, :r}}})
+      func =
+        make_func(
+          :area,
+          [:r],
+          {:binop, :mul, {:literal, 3.14}, {:binop, :mul, {:var, :r}, {:var, :r}}}
+        )
+
       module = make_module([func])
 
       {:ok, result} = TypeInference.infer(module)
@@ -149,8 +157,7 @@ defmodule Firebird.Compiler.TypeInferenceTest do
     end
 
     test "infers comparison function returns i32" do
-      func = make_func(:is_positive, [:n],
-        {:binop, :gt_s, {:var, :n}, {:literal, 0}})
+      func = make_func(:is_positive, [:n], {:binop, :gt_s, {:var, :n}, {:literal, 0}})
       module = make_module([func])
 
       {:ok, result} = TypeInference.infer(module)
diff --git a/test/compiler/validator_completeness_test.exs b/test/compiler/validator_completeness_test.exs
index 261ef8c..8669b40 100644
--- a/test/compiler/validator_completeness_test.exs
+++ b/test/compiler/validator_completeness_test.exs
@@ -102,8 +102,10 @@ defmodule Firebird.Compiler.ValidatorCompletenessTest do
       assert [] = Validator.validate_expr({:literal, 0})
       assert [] = Validator.validate_expr({:literal, 42})
       assert [] = Validator.validate_expr({:literal, -1})
-      assert [] = Validator.validate_expr({:literal, 2_147_483_647})  # i32 max
-      assert [] = Validator.validate_expr({:literal, -2_147_483_648}) # i32 min
+      # i32 max
+      assert [] = Validator.validate_expr({:literal, 2_147_483_647})
+      # i32 min
+      assert [] = Validator.validate_expr({:literal, -2_147_483_648})
     end
 
     test "float literals are valid" do
@@ -208,10 +210,11 @@ defmodule Firebird.Compiler.ValidatorCompletenessTest do
     # This test documents the bug. When fixed, these should pass.
 
     test "band (bitwise AND) SHOULD be valid but validator rejects it" do
-      errors = Validator.validate_expr(
-        {:binop, :band, {:var, :p0}, {:literal, 1}},
-        :is_even
-      )
+      errors =
+        Validator.validate_expr(
+          {:binop, :band, {:var, :p0}, {:literal, 1}},
+          :is_even
+        )
 
       # BUG: This should be [] (valid), but currently returns an error
       # because :band is not in the validator's allowed binop list.
@@ -223,29 +226,30 @@ defmodule Firebird.Compiler.ValidatorCompletenessTest do
 
     test "nested binops validate recursively" do
       # (a + b) * (c - d)
-      expr = {:binop, :mul,
-        {:binop, :add, {:var, :a}, {:var, :b}},
-        {:binop, :sub, {:var, :c}, {:var, :d}}}
+      expr =
+        {:binop, :mul, {:binop, :add, {:var, :a}, {:var, :b}},
+         {:binop, :sub, {:var, :c}, {:var, :d}}}
+
       assert [] = Validator.validate_expr(expr)
     end
 
     test "deeply nested binops validate" do
       # ((1 + 2) * 3) + (4 * (5 - 6))
-      expr = {:binop, :add,
-        {:binop, :mul,
-          {:binop, :add, {:literal, 1}, {:literal, 2}},
-          {:literal, 3}},
-        {:binop, :mul,
-          {:literal, 4},
-          {:binop, :sub, {:literal, 5}, {:literal, 6}}}}
+      expr =
+        {:binop, :add,
+         {:binop, :mul, {:binop, :add, {:literal, 1}, {:literal, 2}}, {:literal, 3}},
+         {:binop, :mul, {:literal, 4}, {:binop, :sub, {:literal, 5}, {:literal, 6}}}}
+
       assert [] = Validator.validate_expr(expr)
     end
 
     test "unknown binop is rejected" do
-      errors = Validator.validate_expr(
-        {:binop, :fake_op, {:literal, 1}, {:literal, 2}},
-        :test_fn
-      )
+      errors =
+        Validator.validate_expr(
+          {:binop, :fake_op, {:literal, 1}, {:literal, 2}},
+          :test_fn
+        )
+
       assert length(errors) > 0
       assert hd(errors) =~ "Unknown IR node"
     end
@@ -263,9 +267,8 @@ defmodule Firebird.Compiler.ValidatorCompletenessTest do
     end
 
     test "not with nested expression" do
-      assert [] = Validator.validate_expr(
-        {:unaryop, :not, {:binop, :eq, {:var, :x}, {:literal, 0}}}
-      )
+      assert [] =
+               Validator.validate_expr({:unaryop, :not, {:binop, :eq, {:var, :x}, {:literal, 0}}})
     end
 
     test "negate with literal" do
@@ -290,27 +293,34 @@ defmodule Firebird.Compiler.ValidatorCompletenessTest do
     end
 
     test "call with complex args is valid" do
-      assert [] = Validator.validate_expr(
-        {:call, :add, [
-          {:binop, :mul, {:var, :x}, {:literal, 2}},
-          {:var, :y}
-        ]}
-      )
+      assert [] =
+               Validator.validate_expr(
+                 {:call, :add,
+                  [
+                    {:binop, :mul, {:var, :x}, {:literal, 2}},
+                    {:var, :y}
+                  ]}
+               )
     end
 
     test "call with invalid arg produces error" do
-      errors = Validator.validate_expr(
-        {:call, :add, [{:unsupported, :thing}]},
-        :test
-      )
+      errors =
+        Validator.validate_expr(
+          {:call, :add, [{:unsupported, :thing}]},
+          :test
+        )
+
       assert length(errors) > 0
     end
 
     test "nested calls are valid" do
-      expr = {:call, :add, [
-        {:call, :multiply, [{:literal, 2}, {:literal, 3}]},
-        {:call, :fibonacci, [{:literal, 5}]}
-      ]}
+      expr =
+        {:call, :add,
+         [
+           {:call, :multiply, [{:literal, 2}, {:literal, 3}]},
+           {:call, :fibonacci, [{:literal, 5}]}
+         ]}
+
       assert [] = Validator.validate_expr(expr)
     end
   end
@@ -319,21 +329,18 @@ defmodule Firebird.Compiler.ValidatorCompletenessTest do
 
   describe "validate_expr/2 if expressions" do
     test "simple if is valid" do
-      expr = {:if,
-        {:binop, :gt_s, {:var, :n}, {:literal, 0}},
-        {:var, :n},
-        {:binop, :sub, {:literal, 0}, {:var, :n}}}
+      expr =
+        {:if, {:binop, :gt_s, {:var, :n}, {:literal, 0}}, {:var, :n},
+         {:binop, :sub, {:literal, 0}, {:var, :n}}}
+
       assert [] = Validator.validate_expr(expr)
     end
 
     test "nested if is valid" do
-      expr = {:if,
-        {:binop, :lt_s, {:var, :n}, {:literal, 0}},
-        {:literal, -1},
-        {:if,
-          {:binop, :eq, {:var, :n}, {:literal, 0}},
-          {:literal, 0},
-          {:literal, 1}}}
+      expr =
+        {:if, {:binop, :lt_s, {:var, :n}, {:literal, 0}}, {:literal, -1},
+         {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:literal, 0}, {:literal, 1}}}
+
       assert [] = Validator.validate_expr(expr)
     end
 
@@ -366,13 +373,16 @@ defmodule Firebird.Compiler.ValidatorCompletenessTest do
 
   describe "validate_expr/2 case expressions" do
     test "simple case is valid" do
-      expr = {:case, {:var, :n}, [
-        {{:literal, 0}, nil, {:literal, 1}},
-        {{:literal, 1}, nil, {:literal, 1}},
-        {{:var, :_}, nil, {:binop, :add,
-          {:call, :fib, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
-          {:call, :fib, [{:binop, :sub, {:var, :n}, {:literal, 2}}]}}}
-      ]}
+      expr =
+        {:case, {:var, :n},
+         [
+           {{:literal, 0}, nil, {:literal, 1}},
+           {{:literal, 1}, nil, {:literal, 1}},
+           {{:var, :_}, nil,
+            {:binop, :add, {:call, :fib, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
+             {:call, :fib, [{:binop, :sub, {:var, :n}, {:literal, 2}}]}}}
+         ]}
+
       assert [] = Validator.validate_expr(expr)
     end
 
@@ -389,10 +399,13 @@ defmodule Firebird.Compiler.ValidatorCompletenessTest do
     end
 
     test "multiple invalid clause bodies collect all errors" do
-      expr = {:case, {:var, :x}, [
-        {{:literal, 0}, nil, {:bad, 1}},
-        {{:literal, 1}, nil, {:bad, 2}}
-      ]}
+      expr =
+        {:case, {:var, :x},
+         [
+           {{:literal, 0}, nil, {:bad, 1}},
+           {{:literal, 1}, nil, {:bad, 2}}
+         ]}
+
       errors = Validator.validate_expr(expr, :test)
       assert length(errors) == 2
     end
@@ -417,11 +430,14 @@ defmodule Firebird.Compiler.ValidatorCompletenessTest do
 
   describe "validate_expr/2 blocks" do
     test "block with valid expressions is valid" do
-      expr = {:block, [
-        {:let, :x, {:literal, 5}},
-        {:let, :y, {:literal, 10}},
-        {:binop, :add, {:var, :x}, {:var, :y}}
-      ]}
+      expr =
+        {:block,
+         [
+           {:let, :x, {:literal, 5}},
+           {:let, :y, {:literal, 10}},
+           {:binop, :add, {:var, :x}, {:var, :y}}
+         ]}
+
       assert [] = Validator.validate_expr(expr)
     end
 
@@ -430,11 +446,14 @@ defmodule Firebird.Compiler.ValidatorCompletenessTest do
     end
 
     test "block with invalid expression produces error" do
-      expr = {:block, [
-        {:let, :x, {:literal, 5}},
-        {:bad_node},
-        {:var, :x}
-      ]}
+      expr =
+        {:block,
+         [
+           {:let, :x, {:literal, 5}},
+           {:bad_node},
+           {:var, :x}
+         ]}
+
       errors = Validator.validate_expr(expr, :test)
       assert length(errors) > 0
     end
@@ -450,14 +469,15 @@ defmodule Firebird.Compiler.ValidatorCompletenessTest do
 
   describe "validate_expr/2 tail recursion" do
     test "tail_loop with valid body is valid" do
-      expr = {:tail_loop, [:n, :acc],
-        {:if,
-          {:binop, :le_s, {:var, :n}, {:literal, 0}},
-          {:var, :acc},
-          {:tail_call, :loop, [
-            {:binop, :sub, {:var, :n}, {:literal, 1}},
-            {:binop, :add, {:var, :acc}, {:var, :n}}
-          ]}}}
+      expr =
+        {:tail_loop, [:n, :acc],
+         {:if, {:binop, :le_s, {:var, :n}, {:literal, 0}}, {:var, :acc},
+          {:tail_call, :loop,
+           [
+             {:binop, :sub, {:var, :n}, {:literal, 1}},
+             {:binop, :add, {:var, :acc}, {:var, :n}}
+           ]}}}
+
       assert [] = Validator.validate_expr(expr)
     end
 
@@ -532,10 +552,12 @@ defmodule Firebird.Compiler.ValidatorCompletenessTest do
     end
 
     test "error includes the problematic node" do
-      errors = Validator.validate_expr(
-        {:binop, :mysterious_op, {:literal, 1}, {:literal, 2}},
-        :test
-      )
+      errors =
+        Validator.validate_expr(
+          {:binop, :mysterious_op, {:literal, 1}, {:literal, 2}},
+          :test
+        )
+
       error_text = hd(errors)
       assert error_text =~ "mysterious_op"
     end
@@ -556,38 +578,70 @@ defmodule Firebird.Compiler.ValidatorCompletenessTest do
     """
 
     # Operations the optimizer supports (from eval_binop):
-    @optimizer_ops [:add, :sub, :mul, :div_s, :rem_s,
-                    :eq, :ne, :lt_s, :gt_s, :le_s, :ge_s,
-                    :and_, :or_, :shl, :shr_s, :band]
+    @optimizer_ops [
+      :add,
+      :sub,
+      :mul,
+      :div_s,
+      :rem_s,
+      :eq,
+      :ne,
+      :lt_s,
+      :gt_s,
+      :le_s,
+      :ge_s,
+      :and_,
+      :or_,
+      :shl,
+      :shr_s,
+      :band
+    ]
 
     # Operations the validator accepts:
-    @validator_ops [:add, :sub, :mul, :div_s, :rem_s,
-                    :eq, :ne, :lt_s, :gt_s, :le_s, :ge_s,
-                    :and_, :or_, :shl, :shr_s]
+    @validator_ops [
+      :add,
+      :sub,
+      :mul,
+      :div_s,
+      :rem_s,
+      :eq,
+      :ne,
+      :lt_s,
+      :gt_s,
+      :le_s,
+      :ge_s,
+      :and_,
+      :or_,
+      :shl,
+      :shr_s
+    ]
 
     test "identifies ops in optimizer but not in validator" do
       missing = @optimizer_ops -- @validator_ops
       # This documents the known gap: :band is supported by optimizer but not validator
       assert :band in missing,
-        "Expected :band to be missing from validator. " <>
-        "If this fails, the bug may have been fixed - update this test!"
+             "Expected :band to be missing from validator. " <>
+               "If this fails, the bug may have been fixed - update this test!"
     end
 
     test "all validator ops are also in optimizer" do
       extra = @validator_ops -- @optimizer_ops
+
       assert extra == [],
-        "Validator accepts ops not supported by optimizer: #{inspect(extra)}"
+             "Validator accepts ops not supported by optimizer: #{inspect(extra)}"
     end
 
     test "validator accepts all ops that optimizer does (except known gaps)" do
-      known_gaps = [:band]  # Known missing ops
+      # Known missing ops
+      known_gaps = [:band]
       expected_accepted = @optimizer_ops -- known_gaps
 
       for op <- expected_accepted do
         expr = {:binop, op, {:literal, 1}, {:literal, 2}}
         errors = Validator.validate_expr(expr, :test)
+
         assert errors == [],
-          "Validator should accept :#{op} binop but got errors: #{inspect(errors)}"
+               "Validator should accept :#{op} binop but got errors: #{inspect(errors)}"
       end
     end
   end
@@ -596,11 +650,9 @@ defmodule Firebird.Compiler.ValidatorCompletenessTest do
 
   describe "complex real-world patterns" do
     test "fibonacci pattern validates" do
-      body = {:if,
-        {:binop, :le_s, {:var, :n}, {:literal, 1}},
-        {:var, :n},
-        {:binop, :add,
-          {:call, :fibonacci, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
+      body =
+        {:if, {:binop, :le_s, {:var, :n}, {:literal, 1}}, {:var, :n},
+         {:binop, :add, {:call, :fibonacci, [{:binop, :sub, {:var, :n}, {:literal, 1}}]},
           {:call, :fibonacci, [{:binop, :sub, {:var, :n}, {:literal, 2}}]}}}
 
       func = make_func(:fibonacci, [:n], body)
@@ -608,58 +660,54 @@ defmodule Firebird.Compiler.ValidatorCompletenessTest do
     end
 
     test "tail-recursive factorial validates" do
-      body = {:tail_loop, [:n, :acc],
-        {:if,
-          {:binop, :le_s, {:var, :n}, {:literal, 1}},
-          {:var, :acc},
-          {:tail_call, :fact_acc, [
-            {:binop, :sub, {:var, :n}, {:literal, 1}},
-            {:binop, :mul, {:var, :acc}, {:var, :n}}
-          ]}}}
+      body =
+        {:tail_loop, [:n, :acc],
+         {:if, {:binop, :le_s, {:var, :n}, {:literal, 1}}, {:var, :acc},
+          {:tail_call, :fact_acc,
+           [
+             {:binop, :sub, {:var, :n}, {:literal, 1}},
+             {:binop, :mul, {:var, :acc}, {:var, :n}}
+           ]}}}
 
       func = make_func(:fact_acc, [:n, :acc], body)
       assert :ok = Validator.validate_function(func)
     end
 
     test "GCD with nested conditions validates" do
-      body = {:if,
-        {:binop, :eq, {:var, :b}, {:literal, 0}},
-        {:var, :a},
-        {:call, :gcd, [{:var, :b}, {:binop, :rem_s, {:var, :a}, {:var, :b}}]}}
+      body =
+        {:if, {:binop, :eq, {:var, :b}, {:literal, 0}}, {:var, :a},
+         {:call, :gcd, [{:var, :b}, {:binop, :rem_s, {:var, :a}, {:var, :b}}]}}
 
       func = make_func(:gcd, [:a, :b], body)
       assert :ok = Validator.validate_function(func)
     end
 
     test "abs function with negate validates" do
-      body = {:if,
-        {:binop, :lt_s, {:var, :x}, {:literal, 0}},
-        {:unaryop, :negate, {:var, :x}},
-        {:var, :x}}
+      body =
+        {:if, {:binop, :lt_s, {:var, :x}, {:literal, 0}}, {:unaryop, :negate, {:var, :x}},
+         {:var, :x}}
 
       func = make_func(:abs, [:x], body)
       assert :ok = Validator.validate_function(func)
     end
 
     test "clamp with nested if validates" do
-      body = {:if,
-        {:binop, :lt_s, {:var, :x}, {:var, :min}},
-        {:var, :min},
-        {:if,
-          {:binop, :gt_s, {:var, :x}, {:var, :max}},
-          {:var, :max},
-          {:var, :x}}}
+      body =
+        {:if, {:binop, :lt_s, {:var, :x}, {:var, :min}}, {:var, :min},
+         {:if, {:binop, :gt_s, {:var, :x}, {:var, :max}}, {:var, :max}, {:var, :x}}}
 
       func = make_func(:clamp, [:x, :min, :max], body)
       assert :ok = Validator.validate_function(func)
     end
 
     test "block with let bindings validates" do
-      body = {:block, [
-        {:let, :sum, {:binop, :add, {:var, :a}, {:var, :b}}},
-        {:let, :product, {:binop, :mul, {:var, :a}, {:var, :b}}},
-        {:binop, :add, {:var, :sum}, {:var, :product}}
-      ]}
+      body =
+        {:block,
+         [
+           {:let, :sum, {:binop, :add, {:var, :a}, {:var, :b}}},
+           {:let, :product, {:binop, :mul, {:var, :a}, {:var, :b}}},
+           {:binop, :add, {:var, :sum}, {:var, :product}}
+         ]}
 
       func = make_func(:sum_and_product, [:a, :b], body)
       assert :ok = Validator.validate_function(func)
@@ -674,9 +722,9 @@ defmodule Firebird.Compiler.ValidatorCompletenessTest do
 
     test "logical operations with comparisons" do
       # (x > 0) && (x < 100)
-      body = {:binop, :and_,
-        {:binop, :gt_s, {:var, :x}, {:literal, 0}},
-        {:binop, :lt_s, {:var, :x}, {:literal, 100}}}
+      body =
+        {:binop, :and_, {:binop, :gt_s, {:var, :x}, {:literal, 0}},
+         {:binop, :lt_s, {:var, :x}, {:literal, 100}}}
 
       func = make_func(:in_range, [:x], body)
       assert :ok = Validator.validate_function(func)
@@ -707,8 +755,9 @@ defmodule Firebird.Compiler.ValidatorCompletenessTest do
         {:error, {:validation_errors, errors}} ->
           # Known bug: validator rejects :band
           error_msgs = errors |> Keyword.values() |> List.flatten()
+
           assert Enum.any?(error_msgs, &String.contains?(&1, "band")),
-            "Expected band-related validation error, got: #{inspect(error_msgs)}"
+                 "Expected band-related validation error, got: #{inspect(error_msgs)}"
       end
     end
 
diff --git a/test/compiler/validator_edge_cases_test.exs b/test/compiler/validator_edge_cases_test.exs
index 47d63fa..8ca50c1 100644
--- a/test/compiler/validator_edge_cases_test.exs
+++ b/test/compiler/validator_edge_cases_test.exs
@@ -53,16 +53,15 @@ defmodule Firebird.Compiler.ValidatorEdgeCasesTest do
     end
 
     test "validates nested tail_loop containing tail_call" do
-      expr = {:tail_loop, [:p0, :p1],
-        {:if,
-          {:binop, :eq, {:var, :p0}, {:literal, 0}},
-          {:var, :p1},
-          {:tail_call, :sum_acc, [
-            {:binop, :sub, {:var, :p0}, {:literal, 1}},
-            {:binop, :add, {:var, :p1}, {:var, :p0}}
-          ]}
-        }
-      }
+      expr =
+        {:tail_loop, [:p0, :p1],
+         {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:var, :p1},
+          {:tail_call, :sum_acc,
+           [
+             {:binop, :sub, {:var, :p0}, {:literal, 1}},
+             {:binop, :add, {:var, :p1}, {:var, :p0}}
+           ]}}}
+
       assert [] = Validator.validate_expr(expr, :test)
     end
   end
@@ -85,19 +84,25 @@ defmodule Firebird.Compiler.ValidatorEdgeCasesTest do
     end
 
     test "validates let inside block" do
-      expr = {:block, [
-        {:let, :x, {:literal, 1}},
-        {:let, :y, {:literal, 2}},
-        {:binop, :add, {:var, :x}, {:var, :y}}
-      ]}
+      expr =
+        {:block,
+         [
+           {:let, :x, {:literal, 1}},
+           {:let, :y, {:literal, 2}},
+           {:binop, :add, {:var, :x}, {:var, :y}}
+         ]}
+
       assert [] = Validator.validate_expr(expr, :test)
     end
 
     test "validates let with error inside block" do
-      expr = {:block, [
-        {:let, :x, {:error_node, :bad}},
-        {:var, :x}
-      ]}
+      expr =
+        {:block,
+         [
+           {:let, :x, {:error_node, :bad}},
+           {:var, :x}
+         ]}
+
       errors = Validator.validate_expr(expr, :test)
       assert length(errors) == 1
     end
@@ -106,24 +111,19 @@ defmodule Firebird.Compiler.ValidatorEdgeCasesTest do
   describe "validate_expr/2 for deeply nested structures" do
     test "validates deeply nested if/else" do
       # if (if (if true then 1 else 0) then 2 else 3) then 4 else 5
-      expr = {:if,
+      expr =
         {:if,
-          {:if, {:literal, 1}, {:literal, 1}, {:literal, 0}},
-          {:literal, 2},
-          {:literal, 3}},
-        {:literal, 4},
-        {:literal, 5}}
+         {:if, {:if, {:literal, 1}, {:literal, 1}, {:literal, 0}}, {:literal, 2}, {:literal, 3}},
+         {:literal, 4}, {:literal, 5}}
+
       assert [] = Validator.validate_expr(expr, :test)
     end
 
     test "finds error deeply nested in if condition" do
-      expr = {:if,
-        {:if,
-          {:error_node, :deep_error},
-          {:literal, 1},
-          {:literal, 0}},
-        {:literal, 2},
-        {:literal, 3}}
+      expr =
+        {:if, {:if, {:error_node, :deep_error}, {:literal, 1}, {:literal, 0}}, {:literal, 2},
+         {:literal, 3}}
+
       errors = Validator.validate_expr(expr, :test)
       assert length(errors) == 1
       assert hd(errors) =~ "deep_error"
@@ -141,53 +141,67 @@ defmodule Firebird.Compiler.ValidatorEdgeCasesTest do
     end
 
     test "validates nested case inside if inside block" do
-      expr = {:block, [
-        {:let, :x, {:literal, 5}},
-        {:if, {:binop, :gt_s, {:var, :x}, {:literal, 0}},
-          {:case, {:var, :x}, [
-            {{:literal_pat, 1}, nil, {:literal, 10}},
-            {:wildcard, nil, {:binop, :mul, {:var, :x}, {:literal, 2}}}
-          ]},
-          {:literal, 0}
-        }
-      ]}
+      expr =
+        {:block,
+         [
+           {:let, :x, {:literal, 5}},
+           {:if, {:binop, :gt_s, {:var, :x}, {:literal, 0}},
+            {:case, {:var, :x},
+             [
+               {{:literal_pat, 1}, nil, {:literal, 10}},
+               {:wildcard, nil, {:binop, :mul, {:var, :x}, {:literal, 2}}}
+             ]}, {:literal, 0}}
+         ]}
+
       assert [] = Validator.validate_expr(expr, :test)
     end
   end
 
   describe "validate_expr/2 for case expressions" do
     test "validates case with multiple clauses" do
-      expr = {:case, {:var, :n}, [
-        {{:literal_pat, 0}, nil, {:literal, 1}},
-        {{:literal_pat, 1}, nil, {:literal, 1}},
-        {{:literal_pat, 2}, nil, {:literal, 2}},
-        {:wildcard, nil, {:binop, :add, {:var, :n}, {:literal, 1}}}
-      ]}
+      expr =
+        {:case, {:var, :n},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 1}},
+           {{:literal_pat, 1}, nil, {:literal, 1}},
+           {{:literal_pat, 2}, nil, {:literal, 2}},
+           {:wildcard, nil, {:binop, :add, {:var, :n}, {:literal, 1}}}
+         ]}
+
       assert [] = Validator.validate_expr(expr, :test)
     end
 
     test "validates case with error in subject" do
-      expr = {:case, {:error_node, :bad_subject}, [
-        {:wildcard, nil, {:literal, 0}}
-      ]}
+      expr =
+        {:case, {:error_node, :bad_subject},
+         [
+           {:wildcard, nil, {:literal, 0}}
+         ]}
+
       errors = Validator.validate_expr(expr, :test)
       assert length(errors) == 1
       assert hd(errors) =~ "bad_subject"
     end
 
     test "validates case with errors in multiple clause bodies" do
-      expr = {:case, {:var, :n}, [
-        {{:literal_pat, 0}, nil, {:error_node, :err1}},
-        {:wildcard, nil, {:error_node, :err2}}
-      ]}
+      expr =
+        {:case, {:var, :n},
+         [
+           {{:literal_pat, 0}, nil, {:error_node, :err1}},
+           {:wildcard, nil, {:error_node, :err2}}
+         ]}
+
       errors = Validator.validate_expr(expr, :test)
       assert length(errors) == 2
     end
 
     test "validates case with both subject and body errors" do
-      expr = {:case, {:error_node, :subj_err}, [
-        {:wildcard, nil, {:error_node, :body_err}}
-      ]}
+      expr =
+        {:case, {:error_node, :subj_err},
+         [
+           {:wildcard, nil, {:error_node, :body_err}}
+         ]}
+
       errors = Validator.validate_expr(expr, :test)
       assert length(errors) == 2
     end
@@ -211,13 +225,16 @@ defmodule Firebird.Compiler.ValidatorEdgeCasesTest do
     end
 
     test "finds all errors in block" do
-      expr = {:block, [
-        {:error_node, :e1},
-        {:literal, 1},
-        {:error_node, :e2},
-        {:literal, 2},
-        {:error_node, :e3}
-      ]}
+      expr =
+        {:block,
+         [
+           {:error_node, :e1},
+           {:literal, 1},
+           {:error_node, :e2},
+           {:literal, 2},
+           {:error_node, :e3}
+         ]}
+
       errors = Validator.validate_expr(expr, :test)
       assert length(errors) == 3
     end
@@ -281,43 +298,52 @@ defmodule Firebird.Compiler.ValidatorEdgeCasesTest do
 
   describe "validate_function/1 with complex bodies" do
     test "validates function with tail_loop body" do
-      func = make_function(:sum_acc,
-        {:tail_loop, [:p0, :p1],
-          {:if,
-            {:binop, :eq, {:var, :p0}, {:literal, 0}},
-            {:var, :p1},
-            {:tail_call, :sum_acc, [
-              {:binop, :sub, {:var, :p0}, {:literal, 1}},
-              {:binop, :add, {:var, :p1}, {:var, :p0}}
-            ]}
-          }
-        },
-        arity: 2, params: [:p0, :p1])
+      func =
+        make_function(
+          :sum_acc,
+          {:tail_loop, [:p0, :p1],
+           {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:var, :p1},
+            {:tail_call, :sum_acc,
+             [
+               {:binop, :sub, {:var, :p0}, {:literal, 1}},
+               {:binop, :add, {:var, :p1}, {:var, :p0}}
+             ]}}},
+          arity: 2,
+          params: [:p0, :p1]
+        )
+
       assert :ok = Validator.validate_function(func)
     end
 
     test "rejects function with error inside tail_loop" do
-      func = make_function(:bad,
-        {:tail_loop, [:p0],
-          {:if,
-            {:binop, :eq, {:var, :p0}, {:literal, 0}},
-            {:literal, 0},
-            {:error_node, :bad_tail}
-          }
-        },
-        arity: 1, params: [:p0])
+      func =
+        make_function(
+          :bad,
+          {:tail_loop, [:p0],
+           {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:literal, 0},
+            {:error_node, :bad_tail}}},
+          arity: 1,
+          params: [:p0]
+        )
+
       assert {:error, errors} = Validator.validate_function(func)
       assert length(errors) == 1
     end
 
     test "validates function with block containing lets and calls" do
-      func = make_function(:compute,
-        {:block, [
-          {:let, :temp, {:binop, :mul, {:var, :p0}, {:literal, 2}}},
-          {:let, :result, {:call, :helper, [{:var, :temp}]}},
-          {:binop, :add, {:var, :result}, {:literal, 1}}
-        ]},
-        arity: 1, params: [:p0])
+      func =
+        make_function(
+          :compute,
+          {:block,
+           [
+             {:let, :temp, {:binop, :mul, {:var, :p0}, {:literal, 2}}},
+             {:let, :result, {:call, :helper, [{:var, :temp}]}},
+             {:binop, :add, {:var, :result}, {:literal, 1}}
+           ]},
+          arity: 1,
+          params: [:p0]
+        )
+
       assert :ok = Validator.validate_function(func)
     end
   end
diff --git a/test/compiler/validator_test.exs b/test/compiler/validator_test.exs
index 14a614f..aa114f9 100644
--- a/test/compiler/validator_test.exs
+++ b/test/compiler/validator_test.exs
@@ -122,10 +122,9 @@ defmodule Firebird.Compiler.ValidatorTest do
         name: :complex,
         arity: 2,
         params: [:a, :b],
-        body: {:binop, :mul,
-          {:binop, :add, {:var, :a}, {:literal, 1}},
-          {:binop, :sub, {:var, :b}, {:literal, 2}}
-        },
+        body:
+          {:binop, :mul, {:binop, :add, {:var, :a}, {:literal, 1}},
+           {:binop, :sub, {:var, :b}, {:literal, 2}}},
         clauses: [],
         type: nil
       }
@@ -246,17 +245,15 @@ defmodule Firebird.Compiler.ValidatorTest do
 
   describe "validate_expr/2 if expressions" do
     test "valid if expression" do
-      expr = {:if, {:binop, :gt_s, {:var, :x}, {:literal, 0}},
-        {:var, :x},
-        {:unaryop, :negate, {:var, :x}}}
+      expr =
+        {:if, {:binop, :gt_s, {:var, :x}, {:literal, 0}}, {:var, :x},
+         {:unaryop, :negate, {:var, :x}}}
+
       assert [] = Validator.validate_expr(expr, :test)
     end
 
     test "if propagates errors from all branches" do
-      expr = {:if,
-        {:error_node, :cond_bad},
-        {:error_node, :then_bad},
-        {:error_node, :else_bad}}
+      expr = {:if, {:error_node, :cond_bad}, {:error_node, :then_bad}, {:error_node, :else_bad}}
       errors = Validator.validate_expr(expr, :test)
       assert length(errors) == 3
     end
@@ -264,18 +261,24 @@ defmodule Firebird.Compiler.ValidatorTest do
 
   describe "validate_expr/2 case expressions" do
     test "valid case expression" do
-      expr = {:case, {:var, :x}, [
-        {{:literal_pat, 0}, nil, {:literal, 1}},
-        {:wildcard, nil, {:var, :x}}
-      ]}
+      expr =
+        {:case, {:var, :x},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 1}},
+           {:wildcard, nil, {:var, :x}}
+         ]}
+
       assert [] = Validator.validate_expr(expr, :test)
     end
 
     test "case propagates errors from subject and clause bodies" do
-      expr = {:case, {:error_node, :subject}, [
-        {{:literal_pat, 0}, nil, {:error_node, :body1}},
-        {:wildcard, nil, {:literal, 1}}
-      ]}
+      expr =
+        {:case, {:error_node, :subject},
+         [
+           {{:literal_pat, 0}, nil, {:error_node, :body1}},
+           {:wildcard, nil, {:literal, 1}}
+         ]}
+
       errors = Validator.validate_expr(expr, :test)
       assert length(errors) == 2
     end
@@ -294,20 +297,26 @@ defmodule Firebird.Compiler.ValidatorTest do
 
   describe "validate_expr/2 blocks" do
     test "valid block with multiple expressions" do
-      expr = {:block, [
-        {:let, :x, {:literal, 1}},
-        {:let, :y, {:literal, 2}},
-        {:binop, :add, {:var, :x}, {:var, :y}}
-      ]}
+      expr =
+        {:block,
+         [
+           {:let, :x, {:literal, 1}},
+           {:let, :y, {:literal, 2}},
+           {:binop, :add, {:var, :x}, {:var, :y}}
+         ]}
+
       assert [] = Validator.validate_expr(expr, :test)
     end
 
     test "block collects all errors" do
-      expr = {:block, [
-        {:error_node, :bad1},
-        {:literal, 1},
-        {:error_node, :bad2}
-      ]}
+      expr =
+        {:block,
+         [
+           {:error_node, :bad1},
+           {:literal, 1},
+           {:error_node, :bad2}
+         ]}
+
       errors = Validator.validate_expr(expr, :test)
       assert length(errors) == 2
     end
@@ -315,15 +324,15 @@ defmodule Firebird.Compiler.ValidatorTest do
 
   describe "validate_expr/2 tail recursion" do
     test "valid tail loop" do
-      expr = {:tail_loop, [:n, :acc],
-        {:if, {:binop, :eq, {:var, :n}, {:literal, 0}},
-          {:var, :acc},
-          {:tail_call, :loop, [
-            {:binop, :sub, {:var, :n}, {:literal, 1}},
-            {:binop, :mul, {:var, :acc}, {:var, :n}}
-          ]}
-        }
-      }
+      expr =
+        {:tail_loop, [:n, :acc],
+         {:if, {:binop, :eq, {:var, :n}, {:literal, 0}}, {:var, :acc},
+          {:tail_call, :loop,
+           [
+             {:binop, :sub, {:var, :n}, {:literal, 1}},
+             {:binop, :mul, {:var, :acc}, {:var, :n}}
+           ]}}}
+
       assert [] = Validator.validate_expr(expr, :test)
     end
 
diff --git a/test/compiler/variable_bindings_test.exs b/test/compiler/variable_bindings_test.exs
index a8ec8d3..ff615b3 100644
--- a/test/compiler/variable_bindings_test.exs
+++ b/test/compiler/variable_bindings_test.exs
@@ -123,4 +123,3 @@ defmodule Firebird.Compiler.VariableBindingsTest do
     end
   end
 end
-
diff --git a/test/compiler/wat_gen_comprehensive_test.exs b/test/compiler/wat_gen_comprehensive_test.exs
index d0774ef..e75d553 100644
--- a/test/compiler/wat_gen_comprehensive_test.exs
+++ b/test/compiler/wat_gen_comprehensive_test.exs
@@ -25,10 +25,12 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
       params: params,
       body: body,
       clauses: [],
-      type: type || %IR.FunctionType{
-        params: List.duplicate(:i64, arity),
-        return: :i64
-      }
+      type:
+        type ||
+          %IR.FunctionType{
+            params: List.duplicate(:i64, arity),
+            return: :i64
+          }
     }
   end
 
@@ -355,12 +357,15 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
 
   describe "br_table optimization for dense case expressions" do
     test "dense case with 3+ contiguous patterns uses br_table" do
-      body = {:case, {:var, :p0}, [
-        {{:literal_pat, 0}, nil, {:literal, 100}},
-        {{:literal_pat, 1}, nil, {:literal, 200}},
-        {{:literal_pat, 2}, nil, {:literal, 300}},
-        {:wildcard, nil, {:literal, 999}}
-      ]}
+      body =
+        {:case, {:var, :p0},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 100}},
+           {{:literal_pat, 1}, nil, {:literal, 200}},
+           {{:literal_pat, 2}, nil, {:literal, 300}},
+           {:wildcard, nil, {:literal, 999}}
+         ]}
+
       func = make_function(:dispatch, 1, [:p0], body)
       module = make_module([func])
 
@@ -371,12 +376,15 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
     end
 
     test "br_table dispatch compiles and runs correctly" do
-      body = {:case, {:var, :p0}, [
-        {{:literal_pat, 0}, nil, {:literal, 10}},
-        {{:literal_pat, 1}, nil, {:literal, 20}},
-        {{:literal_pat, 2}, nil, {:literal, 30}},
-        {:wildcard, nil, {:literal, -1}}
-      ]}
+      body =
+        {:case, {:var, :p0},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 10}},
+           {{:literal_pat, 1}, nil, {:literal, 20}},
+           {{:literal_pat, 2}, nil, {:literal, 30}},
+           {:wildcard, nil, {:literal, -1}}
+         ]}
+
       func = make_function(:jt_dispatch, 1, [:p0], body)
       module = make_module([func])
 
@@ -391,12 +399,15 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
 
     test "br_table with gaps in pattern values still works" do
       # Patterns 0, 2, 4 — gaps at 1 and 3 go to default
-      body = {:case, {:var, :p0}, [
-        {{:literal_pat, 0}, nil, {:literal, 100}},
-        {{:literal_pat, 2}, nil, {:literal, 300}},
-        {{:literal_pat, 4}, nil, {:literal, 500}},
-        {:wildcard, nil, {:literal, -1}}
-      ]}
+      body =
+        {:case, {:var, :p0},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 100}},
+           {{:literal_pat, 2}, nil, {:literal, 300}},
+           {{:literal_pat, 4}, nil, {:literal, 500}},
+           {:wildcard, nil, {:literal, -1}}
+         ]}
+
       func = make_function(:sparse_dispatch, 1, [:p0], body)
       module = make_module([func])
 
@@ -410,11 +421,14 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
     end
 
     test "case with only 2 patterns falls back to if/else chain" do
-      body = {:case, {:var, :p0}, [
-        {{:literal_pat, 0}, nil, {:literal, 10}},
-        {{:literal_pat, 1}, nil, {:literal, 20}},
-        {:wildcard, nil, {:literal, 30}}
-      ]}
+      body =
+        {:case, {:var, :p0},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 10}},
+           {{:literal_pat, 1}, nil, {:literal, 20}},
+           {:wildcard, nil, {:literal, 30}}
+         ]}
+
       func = make_function(:small_case, 1, [:p0], body)
       module = make_module([func])
 
@@ -426,12 +440,15 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
 
     test "case with non-contiguous sparse range falls back to if/else" do
       # Patterns 0, 100, 200 => range 201, but only 3 values => too sparse
-      body = {:case, {:var, :p0}, [
-        {{:literal_pat, 0}, nil, {:literal, 1}},
-        {{:literal_pat, 100}, nil, {:literal, 2}},
-        {{:literal_pat, 200}, nil, {:literal, 3}},
-        {:wildcard, nil, {:literal, 0}}
-      ]}
+      body =
+        {:case, {:var, :p0},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 1}},
+           {{:literal_pat, 100}, nil, {:literal, 2}},
+           {{:literal_pat, 200}, nil, {:literal, 3}},
+           {:wildcard, nil, {:literal, 0}}
+         ]}
+
       func = make_function(:very_sparse, 1, [:p0], body)
       module = make_module([func])
 
@@ -441,12 +458,15 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
     end
 
     test "br_table with non-zero min_val subtracts offset" do
-      body = {:case, {:var, :p0}, [
-        {{:literal_pat, 5}, nil, {:literal, 50}},
-        {{:literal_pat, 6}, nil, {:literal, 60}},
-        {{:literal_pat, 7}, nil, {:literal, 70}},
-        {:wildcard, nil, {:literal, 0}}
-      ]}
+      body =
+        {:case, {:var, :p0},
+         [
+           {{:literal_pat, 5}, nil, {:literal, 50}},
+           {{:literal_pat, 6}, nil, {:literal, 60}},
+           {{:literal_pat, 7}, nil, {:literal, 70}},
+           {:wildcard, nil, {:literal, 0}}
+         ]}
+
       func = make_function(:offset_case, 1, [:p0], body)
       module = make_module([func])
 
@@ -466,12 +486,15 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
     end
 
     test "br_table with min_val 0 skips subtraction" do
-      body = {:case, {:var, :p0}, [
-        {{:literal_pat, 0}, nil, {:literal, 10}},
-        {{:literal_pat, 1}, nil, {:literal, 20}},
-        {{:literal_pat, 2}, nil, {:literal, 30}},
-        {:wildcard, nil, {:literal, 0}}
-      ]}
+      body =
+        {:case, {:var, :p0},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 10}},
+           {{:literal_pat, 1}, nil, {:literal, 20}},
+           {{:literal_pat, 2}, nil, {:literal, 30}},
+           {:wildcard, nil, {:literal, 0}}
+         ]}
+
       func = make_function(:zero_based, 1, [:p0], body)
       module = make_module([func])
 
@@ -482,11 +505,14 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
     end
 
     test "br_table without default clause" do
-      body = {:case, {:var, :p0}, [
-        {{:literal_pat, 0}, nil, {:literal, 10}},
-        {{:literal_pat, 1}, nil, {:literal, 20}},
-        {{:literal_pat, 2}, nil, {:literal, 30}}
-      ]}
+      body =
+        {:case, {:var, :p0},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 10}},
+           {{:literal_pat, 1}, nil, {:literal, 20}},
+           {{:literal_pat, 2}, nil, {:literal, 30}}
+         ]}
+
       func = make_function(:no_default, 1, [:p0], body)
       module = make_module([func])
 
@@ -500,17 +526,19 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
   describe "TCO body with case expressions" do
     test "tail_loop containing case with tail_call in branches" do
       # Sum using TCO + case dispatch on base condition
-      body = {:tail_loop, [:p0, :p1],
-        {:case, {:var, :p0}, [
-          {{:literal_pat, 0}, nil, {:var, :p1}},
-          {:wildcard, nil,
-            {:tail_call, :tco_case_sum, [
-              {:binop, :sub, {:var, :p0}, {:literal, 1}},
-              {:binop, :add, {:var, :p1}, {:var, :p0}}
-            ]}
-          }
-        ]}
-      }
+      body =
+        {:tail_loop, [:p0, :p1],
+         {:case, {:var, :p0},
+          [
+            {{:literal_pat, 0}, nil, {:var, :p1}},
+            {:wildcard, nil,
+             {:tail_call, :tco_case_sum,
+              [
+                {:binop, :sub, {:var, :p0}, {:literal, 1}},
+                {:binop, :add, {:var, :p1}, {:var, :p0}}
+              ]}}
+          ]}}
+
       func = make_function(:tco_case_sum, 2, [:p0, :p1], body)
       module = make_module([func])
 
@@ -526,19 +554,21 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
 
     test "TCO case with br_table generates correct dispatch" do
       # Dense case in TCO body should also use br_table
-      body = {:tail_loop, [:p0, :p1],
-        {:case, {:var, :p0}, [
-          {{:literal_pat, 0}, nil, {:var, :p1}},
-          {{:literal_pat, 1}, nil, {:binop, :add, {:var, :p1}, {:literal, 1}}},
-          {{:literal_pat, 2}, nil, {:binop, :add, {:var, :p1}, {:literal, 2}}},
-          {:wildcard, nil,
-            {:tail_call, :tco_dense, [
-              {:binop, :sub, {:var, :p0}, {:literal, 1}},
-              {:binop, :add, {:var, :p1}, {:var, :p0}}
-            ]}
-          }
-        ]}
-      }
+      body =
+        {:tail_loop, [:p0, :p1],
+         {:case, {:var, :p0},
+          [
+            {{:literal_pat, 0}, nil, {:var, :p1}},
+            {{:literal_pat, 1}, nil, {:binop, :add, {:var, :p1}, {:literal, 1}}},
+            {{:literal_pat, 2}, nil, {:binop, :add, {:var, :p1}, {:literal, 2}}},
+            {:wildcard, nil,
+             {:tail_call, :tco_dense,
+              [
+                {:binop, :sub, {:var, :p0}, {:literal, 1}},
+                {:binop, :add, {:var, :p1}, {:var, :p0}}
+              ]}}
+          ]}}
+
       func = make_function(:tco_dense, 2, [:p0, :p1], body)
       module = make_module([func])
 
@@ -554,17 +584,16 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
 
   describe "TCO body with block expressions" do
     test "tail_loop body is a block with let bindings and tail_call" do
-      body = {:tail_loop, [:p0, :p1],
-        {:if,
-          {:binop, :eq, {:var, :p0}, {:literal, 0}},
-          {:var, :p1},
-          {:block, [
-            {:let, :next_n, {:binop, :sub, {:var, :p0}, {:literal, 1}}},
-            {:let, :next_acc, {:binop, :add, {:var, :p1}, {:var, :p0}}},
-            {:tail_call, :block_tco, [{:var, :next_n}, {:var, :next_acc}]}
-          ]}
-        }
-      }
+      body =
+        {:tail_loop, [:p0, :p1],
+         {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:var, :p1},
+          {:block,
+           [
+             {:let, :next_n, {:binop, :sub, {:var, :p0}, {:literal, 1}}},
+             {:let, :next_acc, {:binop, :add, {:var, :p1}, {:var, :p0}}},
+             {:tail_call, :block_tco, [{:var, :next_n}, {:var, :next_acc}]}
+           ]}}}
+
       func = make_function(:block_tco, 2, [:p0, :p1], body)
       module = make_module([func])
 
@@ -621,10 +650,11 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
 
     test "callee param types are used for argument coercion" do
       # i64 function calling f64 function with i64 args should coerce args to f64
-      f64_func = make_f64_function(:fadd, 2, [:a, :b],
-        {:binop, :add, {:var, :a}, {:var, :b}})
-      i64_func = make_function(:call_fadd, 2, [:p0, :p1],
-        {:call, :fadd, [{:var, :p0}, {:var, :p1}]})
+      f64_func = make_f64_function(:fadd, 2, [:a, :b], {:binop, :add, {:var, :a}, {:var, :b}})
+
+      i64_func =
+        make_function(:call_fadd, 2, [:p0, :p1], {:call, :fadd, [{:var, :p0}, {:var, :p1}]})
+
       module = make_module([f64_func, i64_func])
 
       assert {:ok, wat} = WATGen.generate(module)
@@ -693,14 +723,20 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
 
   describe "let binding type inference" do
     test "let binding stores result from f64 function as f64 local" do
-      f64_func = make_f64_function(:compute, 1, [:a],
-        {:binop, :mul, {:var, :a}, {:literal, 2.0}})
-
-      main = make_f64_function(:use_compute, 1, [:a],
-        {:block, [
-          {:let, :result, {:call, :compute, [{:var, :a}]}},
-          {:binop, :add, {:var, :result}, {:literal, 1.0}}
-        ]})
+      f64_func = make_f64_function(:compute, 1, [:a], {:binop, :mul, {:var, :a}, {:literal, 2.0}})
+
+      main =
+        make_f64_function(
+          :use_compute,
+          1,
+          [:a],
+          {:block,
+           [
+             {:let, :result, {:call, :compute, [{:var, :a}]}},
+             {:binop, :add, {:var, :result}, {:literal, 1.0}}
+           ]}
+        )
+
       module = make_module([f64_func, main])
 
       assert {:ok, wat} = WATGen.generate(module)
@@ -716,12 +752,19 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
     test "multiple let bindings with different types" do
       f64_func = make_f64_function(:to_float, 0, [], {:literal, 3.14})
 
-      main = make_function(:mixed_lets, 1, [:p0],
-        {:block, [
-          {:let, :int_val, {:binop, :add, {:var, :p0}, {:literal, 1}}},
-          {:let, :float_val, {:call, :to_float, []}},
-          {:var, :int_val}
-        ]})
+      main =
+        make_function(
+          :mixed_lets,
+          1,
+          [:p0],
+          {:block,
+           [
+             {:let, :int_val, {:binop, :add, {:var, :p0}, {:literal, 1}}},
+             {:let, :float_val, {:call, :to_float, []}},
+             {:var, :int_val}
+           ]}
+        )
+
       module = make_module([f64_func, main])
 
       assert {:ok, wat} = WATGen.generate(module)
@@ -753,13 +796,18 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
     end
 
     test "deeply nested blocks compile correctly" do
-      body = {:block, [
-        {:block, [
-          {:block, [
-            {:literal, 99}
-          ]}
-        ]}
-      ]}
+      body =
+        {:block,
+         [
+           {:block,
+            [
+              {:block,
+               [
+                 {:literal, 99}
+               ]}
+            ]}
+         ]}
+
       func = make_function(:deep_block, 0, [], body)
       module = make_module([func])
 
@@ -818,9 +866,7 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
     end
 
     test "if type inferred from then branch" do
-      body = {:if, {:binop, :gt_s, {:var, :p0}, {:literal, 0}},
-        {:literal, 1.5},
-        {:literal, 0.0}}
+      body = {:if, {:binop, :gt_s, {:var, :p0}, {:literal, 0}}, {:literal, 1.5}, {:literal, 0.0}}
       type = %IR.FunctionType{params: [:i64], return: :f64}
       func = make_function(:cond_float, 1, [:p0], body, type)
       module = make_module([func])
@@ -892,8 +938,7 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
 
   describe "WAT formatting" do
     test "generated WAT is properly indented" do
-      body = {:if, {:binop, :gt_s, {:var, :p0}, {:literal, 0}},
-        {:var, :p0}, {:literal, 0}}
+      body = {:if, {:binop, :gt_s, {:var, :p0}, {:literal, 0}}, {:var, :p0}, {:literal, 0}}
       func = make_function(:abs, 1, [:p0], body)
       module = make_module([func])
 
@@ -919,6 +964,7 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
         clauses: [],
         type: nil
       }
+
       module = make_module([func])
 
       assert {:ok, wat} = WATGen.generate(module)
@@ -932,16 +978,15 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
   describe "complex integration" do
     test "GCD with TCO compiles and runs" do
       # gcd(a, 0) = a; gcd(a, b) = gcd(b, a rem b)
-      body = {:tail_loop, [:p0, :p1],
-        {:if,
-          {:binop, :eq, {:var, :p1}, {:literal, 0}},
-          {:var, :p0},
-          {:tail_call, :gcd, [
-            {:var, :p1},
-            {:binop, :rem_s, {:var, :p0}, {:var, :p1}}
-          ]}
-        }
-      }
+      body =
+        {:tail_loop, [:p0, :p1],
+         {:if, {:binop, :eq, {:var, :p1}, {:literal, 0}}, {:var, :p0},
+          {:tail_call, :gcd,
+           [
+             {:var, :p1},
+             {:binop, :rem_s, {:var, :p0}, {:var, :p1}}
+           ]}}}
+
       func = make_function(:gcd, 2, [:p0, :p1], body)
       module = make_module([func])
 
@@ -954,11 +999,10 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
     end
 
     test "absolute value using negate" do
-      body = {:if,
-        {:binop, :lt_s, {:var, :p0}, {:literal, 0}},
-        {:unaryop, :negate, {:var, :p0}},
-        {:var, :p0}
-      }
+      body =
+        {:if, {:binop, :lt_s, {:var, :p0}, {:literal, 0}}, {:unaryop, :negate, {:var, :p0}},
+         {:var, :p0}}
+
       func = make_function(:abs, 1, [:p0], body)
       module = make_module([func])
 
@@ -971,9 +1015,7 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
 
     test "bitwise operations combined" do
       # Extract bits 4-7: (x >> 4) & 0xF
-      body = {:binop, :band,
-        {:binop, :shr_s, {:var, :p0}, {:literal, 4}},
-        {:literal, 15}}
+      body = {:binop, :band, {:binop, :shr_s, {:var, :p0}, {:literal, 4}}, {:literal, 15}}
       func = make_function(:nibble, 1, [:p0], body)
       module = make_module([func])
 
@@ -986,13 +1028,15 @@ defmodule Firebird.Compiler.WATGenComprehensiveTest do
     end
 
     test "multiple functions with different types" do
-      i64_add = make_function(:iadd, 2, [:a, :b],
-        {:binop, :add, {:var, :a}, {:var, :b}})
-      f64_add = make_f64_function(:fadd, 2, [:a, :b],
-        {:binop, :add, {:var, :a}, {:var, :b}})
-      i32_eq = make_function(:eq, 2, [:a, :b],
-        {:binop, :eq, {:var, :a}, {:var, :b}},
-        %IR.FunctionType{params: [:i64, :i64], return: :i32})
+      i64_add = make_function(:iadd, 2, [:a, :b], {:binop, :add, {:var, :a}, {:var, :b}})
+      f64_add = make_f64_function(:fadd, 2, [:a, :b], {:binop, :add, {:var, :a}, {:var, :b}})
+
+      i32_eq =
+        make_function(:eq, 2, [:a, :b], {:binop, :eq, {:var, :a}, {:var, :b}}, %IR.FunctionType{
+          params: [:i64, :i64],
+          return: :i32
+        })
+
       module = make_module([i64_add, f64_add, i32_eq])
 
       {:ok, pid} = compile_and_run(module)
diff --git a/test/compiler/wat_gen_edge_cases_test.exs b/test/compiler/wat_gen_edge_cases_test.exs
index ae452b2..1fa4962 100644
--- a/test/compiler/wat_gen_edge_cases_test.exs
+++ b/test/compiler/wat_gen_edge_cases_test.exs
@@ -18,10 +18,12 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
       params: params,
       body: body,
       clauses: [],
-      type: type || %IR.FunctionType{
-        params: List.duplicate(:i64, arity),
-        return: :i64
-      }
+      type:
+        type ||
+          %IR.FunctionType{
+            params: List.duplicate(:i64, arity),
+            return: :i64
+          }
     }
   end
 
@@ -34,11 +36,14 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
   describe "case expression WAT generation" do
     test "generates case with literal patterns" do
       # case n do 0 -> 100; 1 -> 200; _ -> 300 end
-      body = {:case, {:var, :p0}, [
-        {{:literal_pat, 0}, nil, {:literal, 100}},
-        {{:literal_pat, 1}, nil, {:literal, 200}},
-        {:wildcard, nil, {:literal, 300}}
-      ]}
+      body =
+        {:case, {:var, :p0},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 100}},
+           {{:literal_pat, 1}, nil, {:literal, 200}},
+           {:wildcard, nil, {:literal, 300}}
+         ]}
+
       func = make_function(:case_test, 1, [:p0], body)
       module = make_module([func])
 
@@ -53,11 +58,14 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
     end
 
     test "case expression compiles and runs correctly" do
-      body = {:case, {:var, :p0}, [
-        {{:literal_pat, 0}, nil, {:literal, 10}},
-        {{:literal_pat, 1}, nil, {:literal, 20}},
-        {:wildcard, nil, {:literal, 30}}
-      ]}
+      body =
+        {:case, {:var, :p0},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 10}},
+           {{:literal_pat, 1}, nil, {:literal, 20}},
+           {:wildcard, nil, {:literal, 30}}
+         ]}
+
       func = make_function(:case_run, 1, [:p0], body)
       module = make_module([func])
 
@@ -69,10 +77,13 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
     end
 
     test "case with variable pattern" do
-      body = {:case, {:var, :p0}, [
-        {{:literal_pat, 0}, nil, {:literal, 42}},
-        {{:var_pat, :x}, nil, {:var, :p0}}
-      ]}
+      body =
+        {:case, {:var, :p0},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 42}},
+           {{:var_pat, :x}, nil, {:var, :p0}}
+         ]}
+
       func = make_function(:case_var, 1, [:p0], body)
       module = make_module([func])
 
@@ -83,9 +94,12 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
     end
 
     test "case with single wildcard clause" do
-      body = {:case, {:var, :p0}, [
-        {:wildcard, nil, {:binop, :mul, {:var, :p0}, {:literal, 2}}}
-      ]}
+      body =
+        {:case, {:var, :p0},
+         [
+           {:wildcard, nil, {:binop, :mul, {:var, :p0}, {:literal, 2}}}
+         ]}
+
       func = make_function(:double, 1, [:p0], body)
       module = make_module([func])
 
@@ -98,10 +112,13 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
   describe "let binding WAT generation" do
     test "generates let binding" do
       # let x = a + b; x * x
-      body = {:block, [
-        {:let, :x, {:binop, :add, {:var, :p0}, {:var, :p1}}},
-        {:binop, :mul, {:var, :x}, {:var, :x}}
-      ]}
+      body =
+        {:block,
+         [
+           {:let, :x, {:binop, :add, {:var, :p0}, {:var, :p1}}},
+           {:binop, :mul, {:var, :x}, {:var, :x}}
+         ]}
+
       func = make_function(:sum_squared, 2, [:p0, :p1], body)
       module = make_module([func])
 
@@ -112,10 +129,13 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
     end
 
     test "let binding compiles and runs" do
-      body = {:block, [
-        {:let, :x, {:binop, :add, {:var, :p0}, {:var, :p1}}},
-        {:binop, :mul, {:var, :x}, {:var, :x}}
-      ]}
+      body =
+        {:block,
+         [
+           {:let, :x, {:binop, :add, {:var, :p0}, {:var, :p1}}},
+           {:binop, :mul, {:var, :x}, {:var, :x}}
+         ]}
+
       func = make_function(:sum_sq, 2, [:p0, :p1], body)
       module = make_module([func])
 
@@ -126,11 +146,14 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
     end
 
     test "multiple let bindings" do
-      body = {:block, [
-        {:let, :x, {:binop, :add, {:var, :p0}, {:literal, 1}}},
-        {:let, :y, {:binop, :mul, {:var, :x}, {:literal, 2}}},
-        {:binop, :add, {:var, :x}, {:var, :y}}
-      ]}
+      body =
+        {:block,
+         [
+           {:let, :x, {:binop, :add, {:var, :p0}, {:literal, 1}}},
+           {:let, :y, {:binop, :mul, {:var, :x}, {:literal, 2}}},
+           {:binop, :add, {:var, :x}, {:var, :y}}
+         ]}
+
       func = make_function(:multi_let, 1, [:p0], body)
       module = make_module([func])
 
@@ -143,10 +166,13 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
     test "block init let uses local.set (no tee+drop)" do
       # In block init position, let bindings should use local.set directly
       # instead of local.tee + drop, saving one instruction per binding.
-      body = {:block, [
-        {:let, :x, {:binop, :add, {:var, :p0}, {:literal, 10}}},
-        {:var, :x}
-      ]}
+      body =
+        {:block,
+         [
+           {:let, :x, {:binop, :add, {:var, :p0}, {:literal, 10}}},
+           {:var, :x}
+         ]}
+
       func = make_function(:init_let, 1, [:p0], body)
       module = make_module([func])
 
@@ -157,6 +183,7 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
       # No unnecessary drop after a let in init position
       lines = String.split(wat, "\n") |> Enum.map(&String.trim/1)
       set_idx = Enum.find_index(lines, &(&1 == "local.set $x"))
+
       if set_idx do
         next_line = Enum.at(lines, set_idx + 1)
         refute next_line == "drop"
@@ -178,16 +205,15 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
   describe "tail loop / TCO WAT generation" do
     test "generates tail loop structure" do
       # Tail-recursive sum: sum_acc(0, acc) -> acc; sum_acc(n, acc) -> sum_acc(n-1, acc+n)
-      body = {:tail_loop, [:p0, :p1],
-        {:if,
-          {:binop, :eq, {:var, :p0}, {:literal, 0}},
-          {:var, :p1},
-          {:tail_call, :sum_acc, [
-            {:binop, :sub, {:var, :p0}, {:literal, 1}},
-            {:binop, :add, {:var, :p1}, {:var, :p0}}
-          ]}
-        }
-      }
+      body =
+        {:tail_loop, [:p0, :p1],
+         {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:var, :p1},
+          {:tail_call, :sum_acc,
+           [
+             {:binop, :sub, {:var, :p0}, {:literal, 1}},
+             {:binop, :add, {:var, :p1}, {:var, :p0}}
+           ]}}}
+
       func = make_function(:sum_acc, 2, [:p0, :p1], body)
       module = make_module([func])
 
@@ -201,16 +227,15 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
     end
 
     test "tail loop compiles and runs correctly" do
-      body = {:tail_loop, [:p0, :p1],
-        {:if,
-          {:binop, :eq, {:var, :p0}, {:literal, 0}},
-          {:var, :p1},
-          {:tail_call, :sum_acc, [
-            {:binop, :sub, {:var, :p0}, {:literal, 1}},
-            {:binop, :add, {:var, :p1}, {:var, :p0}}
-          ]}
-        }
-      }
+      body =
+        {:tail_loop, [:p0, :p1],
+         {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:var, :p1},
+          {:tail_call, :sum_acc,
+           [
+             {:binop, :sub, {:var, :p0}, {:literal, 1}},
+             {:binop, :add, {:var, :p1}, {:var, :p0}}
+           ]}}}
+
       func = make_function(:sum_acc, 2, [:p0, :p1], body)
       module = make_module([func])
 
@@ -225,16 +250,15 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
     end
 
     test "tail loop handles large inputs without stack overflow" do
-      body = {:tail_loop, [:p0, :p1],
-        {:if,
-          {:binop, :eq, {:var, :p0}, {:literal, 0}},
-          {:var, :p1},
-          {:tail_call, :count, [
-            {:binop, :sub, {:var, :p0}, {:literal, 1}},
-            {:binop, :add, {:var, :p1}, {:literal, 1}}
-          ]}
-        }
-      }
+      body =
+        {:tail_loop, [:p0, :p1],
+         {:if, {:binop, :eq, {:var, :p0}, {:literal, 0}}, {:var, :p1},
+          {:tail_call, :count,
+           [
+             {:binop, :sub, {:var, :p0}, {:literal, 1}},
+             {:binop, :add, {:var, :p1}, {:literal, 1}}
+           ]}}}
+
       func = make_function(:count, 2, [:p0, :p1], body)
       module = make_module([func])
 
@@ -268,10 +292,10 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
     end
 
     test "boolean operators return i32 coerced to i64" do
-      body = {:binop, :and_,
-        {:binop, :gt_s, {:var, :p0}, {:literal, 0}},
-        {:binop, :lt_s, {:var, :p0}, {:literal, 10}}
-      }
+      body =
+        {:binop, :and_, {:binop, :gt_s, {:var, :p0}, {:literal, 0}},
+         {:binop, :lt_s, {:var, :p0}, {:literal, 10}}}
+
       func = make_function(:in_range, 1, [:p0], body)
       module = make_module([func])
 
@@ -284,10 +308,10 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
     end
 
     test "or operator" do
-      body = {:binop, :or_,
-        {:binop, :eq, {:var, :p0}, {:literal, 0}},
-        {:binop, :eq, {:var, :p0}, {:literal, 1}}
-      }
+      body =
+        {:binop, :or_, {:binop, :eq, {:var, :p0}, {:literal, 0}},
+         {:binop, :eq, {:var, :p0}, {:literal, 1}}}
+
       func = make_function(:is_bool, 1, [:p0], body)
       module = make_module([func])
 
@@ -300,11 +324,7 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
 
     test "comparison used as i32 condition in if" do
       # if a > b then a else b (max)
-      body = {:if,
-        {:binop, :gt_s, {:var, :p0}, {:var, :p1}},
-        {:var, :p0},
-        {:var, :p1}
-      }
+      body = {:if, {:binop, :gt_s, {:var, :p0}, {:var, :p1}}, {:var, :p0}, {:var, :p1}}
       func = make_function(:max, 2, [:p0, :p1], body)
       module = make_module([func])
 
@@ -441,16 +461,13 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
   describe "deeply nested expressions" do
     test "deeply nested arithmetic compiles and runs" do
       # ((a + b) * (a - b)) + ((a * b) - (a + b))
-      body = {:binop, :add,
-        {:binop, :mul,
-          {:binop, :add, {:var, :p0}, {:var, :p1}},
-          {:binop, :sub, {:var, :p0}, {:var, :p1}}
-        },
-        {:binop, :sub,
-          {:binop, :mul, {:var, :p0}, {:var, :p1}},
-          {:binop, :add, {:var, :p0}, {:var, :p1}}
-        }
-      }
+      body =
+        {:binop, :add,
+         {:binop, :mul, {:binop, :add, {:var, :p0}, {:var, :p1}},
+          {:binop, :sub, {:var, :p0}, {:var, :p1}}},
+         {:binop, :sub, {:binop, :mul, {:var, :p0}, {:var, :p1}},
+          {:binop, :add, {:var, :p0}, {:var, :p1}}}}
+
       func = make_function(:complex, 2, [:p0, :p1], body)
       module = make_module([func])
 
@@ -462,15 +479,11 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
 
     test "nested if expressions" do
       # if a > 0 then (if a > 10 then 2 else 1) else 0
-      body = {:if,
-        {:binop, :gt_s, {:var, :p0}, {:literal, 0}},
-        {:if,
-          {:binop, :gt_s, {:var, :p0}, {:literal, 10}},
-          {:literal, 2},
-          {:literal, 1}
-        },
-        {:literal, 0}
-      }
+      body =
+        {:if, {:binop, :gt_s, {:var, :p0}, {:literal, 0}},
+         {:if, {:binop, :gt_s, {:var, :p0}, {:literal, 10}}, {:literal, 2}, {:literal, 1}},
+         {:literal, 0}}
+
       func = make_function(:classify, 1, [:p0], body)
       module = make_module([func])
 
@@ -485,10 +498,11 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
 
   describe "multiple functions interacting" do
     test "function calling another function" do
-      helper = make_function(:double, 1, [:p0],
-        {:binop, :mul, {:var, :p0}, {:literal, 2}})
-      main = make_function(:quadruple, 1, [:p0],
-        {:call, :double, [{:call, :double, [{:var, :p0}]}]})
+      helper = make_function(:double, 1, [:p0], {:binop, :mul, {:var, :p0}, {:literal, 2}})
+
+      main =
+        make_function(:quadruple, 1, [:p0], {:call, :double, [{:call, :double, [{:var, :p0}]}]})
+
       module = make_module([helper, main])
 
       {:ok, pid} = compile_and_run(module)
@@ -510,17 +524,21 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
     end
 
     test "block with side-effect-like drops" do
-      body = {:block, [
-        {:binop, :add, {:literal, 1}, {:literal, 2}},
-        {:binop, :mul, {:literal, 3}, {:literal, 4}},
-        {:literal, 99}
-      ]}
+      body =
+        {:block,
+         [
+           {:binop, :add, {:literal, 1}, {:literal, 2}},
+           {:binop, :mul, {:literal, 3}, {:literal, 4}},
+           {:literal, 99}
+         ]}
+
       func = make_function(:block_drops, 0, [], body)
       module = make_module([func])
 
       assert {:ok, wat} = WATGen.generate(module)
       # First two expressions should be dropped
-      assert String.split(wat, "drop") |> length() >= 3  # at least 2 drops
+      # at least 2 drops
+      assert String.split(wat, "drop") |> length() >= 3
 
       {:ok, pid} = compile_and_run(module)
       assert {:ok, [99]} = Firebird.call(pid, :block_drops, [])
@@ -531,16 +549,16 @@ defmodule Firebird.Compiler.WATGenEdgeCasesTest do
   describe "recursive function (non-TCO)" do
     test "recursive fibonacci compiles and runs" do
       # fib(0) = 0, fib(1) = 1, fib(n) = fib(n-1) + fib(n-2)
-      body = {:case, {:var, :p0}, [
-        {{:literal_pat, 0}, nil, {:literal, 0}},
-        {{:literal_pat, 1}, nil, {:literal, 1}},
-        {:wildcard, nil,
-          {:binop, :add,
-            {:call, :fib, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]},
-            {:call, :fib, [{:binop, :sub, {:var, :p0}, {:literal, 2}}]}
-          }
-        }
-      ]}
+      body =
+        {:case, {:var, :p0},
+         [
+           {{:literal_pat, 0}, nil, {:literal, 0}},
+           {{:literal_pat, 1}, nil, {:literal, 1}},
+           {:wildcard, nil,
+            {:binop, :add, {:call, :fib, [{:binop, :sub, {:var, :p0}, {:literal, 1}}]},
+             {:call, :fib, [{:binop, :sub, {:var, :p0}, {:literal, 2}}]}}}
+         ]}
+
       func = make_function(:fib, 1, [:p0], body)
       module = make_module([func])
 
diff --git a/test/compiler/wat_gen_test.exs b/test/compiler/wat_gen_test.exs
index 131f972..5d8bf09 100644
--- a/test/compiler/wat_gen_test.exs
+++ b/test/compiler/wat_gen_test.exs
@@ -18,10 +18,12 @@ defmodule Firebird.Compiler.WATGenTest do
       params: params,
       body: body,
       clauses: [],
-      type: type || %IR.FunctionType{
-        params: List.duplicate(:i64, arity),
-        return: :i64
-      }
+      type:
+        type ||
+          %IR.FunctionType{
+            params: List.duplicate(:i64, arity),
+            return: :i64
+          }
     }
   end
 
@@ -60,8 +62,7 @@ defmodule Firebird.Compiler.WATGenTest do
       ]
 
       for {op, wasm_op} <- ops do
-        func = make_function(:"test_#{op}", 2, [:a, :b],
-          {:binop, op, {:var, :a}, {:var, :b}})
+        func = make_function(:"test_#{op}", 2, [:a, :b], {:binop, op, {:var, :a}, {:var, :b}})
         module = make_module([func])
 
         assert {:ok, wat} = WATGen.generate(module)
@@ -81,8 +82,7 @@ defmodule Firebird.Compiler.WATGenTest do
 
       for {op, wasm_op} <- ops do
         # Comparisons return i32, so we need coercion to i64
-        func = make_function(:"cmp_#{op}", 2, [:a, :b],
-          {:binop, op, {:var, :a}, {:var, :b}})
+        func = make_function(:"cmp_#{op}", 2, [:a, :b], {:binop, op, {:var, :a}, {:var, :b}})
         module = make_module([func])
 
         assert {:ok, wat} = WATGen.generate(module)
@@ -91,11 +91,7 @@ defmodule Firebird.Compiler.WATGenTest do
     end
 
     test "generates WAT for if/else" do
-      body = {:if,
-        {:binop, :gt_s, {:var, :p0}, {:var, :p1}},
-        {:var, :p0},
-        {:var, :p1}
-      }
+      body = {:if, {:binop, :gt_s, {:var, :p0}, {:var, :p1}}, {:var, :p0}, {:var, :p1}}
       func = make_function(:max, 2, [:p0, :p1], body)
       module = make_module([func])
 
@@ -125,10 +121,10 @@ defmodule Firebird.Compiler.WATGenTest do
 
     test "generates WAT for nested expressions" do
       # (a + b) * (a - b)
-      body = {:binop, :mul,
-        {:binop, :add, {:var, :p0}, {:var, :p1}},
-        {:binop, :sub, {:var, :p0}, {:var, :p1}}
-      }
+      body =
+        {:binop, :mul, {:binop, :add, {:var, :p0}, {:var, :p1}},
+         {:binop, :sub, {:var, :p0}, {:var, :p1}}}
+
       func = make_function(:diff_squares, 2, [:p0, :p1], body)
       module = make_module([func])
 
@@ -170,8 +166,13 @@ defmodule Firebird.Compiler.WATGenTest do
 
   describe "generate_function/1" do
     test "generates correct function signature" do
-      func = make_function(:test, 3, [:a, :b, :c],
-        {:binop, :add, {:var, :a}, {:binop, :add, {:var, :b}, {:var, :c}}})
+      func =
+        make_function(
+          :test,
+          3,
+          [:a, :b, :c],
+          {:binop, :add, {:var, :a}, {:binop, :add, {:var, :b}, {:var, :c}}}
+        )
 
       wat = WATGen.generate_function(func)
       assert String.contains?(wat, "(param $a i64)")
diff --git a/test/compiler_e2e_patterns_test.exs b/test/compiler_e2e_patterns_test.exs
index a5ef6d2..b1321aa 100644
--- a/test/compiler_e2e_patterns_test.exs
+++ b/test/compiler_e2e_patterns_test.exs
@@ -201,7 +201,7 @@ defmodule Firebird.CompilerE2EPatternsTest do
       assert_compiles_to(@pattern_source, :factorial, [0], 1)
       assert_compiles_to(@pattern_source, :factorial, [1], 1)
       assert_compiles_to(@pattern_source, :factorial, [5], 120)
-      assert_compiles_to(@pattern_source, :factorial, [10], 3628800)
+      assert_compiles_to(@pattern_source, :factorial, [10], 3_628_800)
     end
 
     test "fibonacci" do
@@ -249,7 +249,7 @@ defmodule Firebird.CompilerE2EPatternsTest do
       assert_compiles_to(@tco_source, :fact, [0, 1], 1)
       assert_compiles_to(@tco_source, :fact, [1, 1], 1)
       assert_compiles_to(@tco_source, :fact, [5, 1], 120)
-      assert_compiles_to(@tco_source, :fact, [10, 1], 3628800)
+      assert_compiles_to(@tco_source, :fact, [10, 1], 3_628_800)
     end
 
     test "TCO doesn't overflow on large inputs" do
@@ -332,7 +332,9 @@ defmodule Firebird.CompilerE2EPatternsTest do
     end
 
     test "WAT contains optimized constant for double(5)" do
-      {:ok, result} = Compiler.compile_source(@const_prop_source, optimize: true, inline: true, wat_only: true)
+      {:ok, result} =
+        Compiler.compile_source(@const_prop_source, optimize: true, inline: true, wat_only: true)
+
       # After inlining double(5) → 5*2 and const prop → 10
       assert result.wat =~ "i64.const 10"
     end
@@ -555,7 +557,10 @@ defmodule Firebird.CompilerE2EPatternsTest do
     test "fibonacci works with all optimization combinations" do
       for optimize <- [false, true], tco <- [false, true], inline <- [false, true] do
         assert_compiles_to(@opt_source, :fib, [10], 55,
-          optimize: optimize, tco: tco, inline: inline)
+          optimize: optimize,
+          tco: tco,
+          inline: inline
+        )
       end
     end
 
@@ -590,6 +595,7 @@ defmodule Firebird.CompilerE2EPatternsTest do
         def add(a, b), do: a + b
       end
       """
+
       # Should compile but with no exports (functions not annotated with @wasm)
       result = Compiler.compile_source(source)
       # Depending on implementation, may produce empty module or error
@@ -650,6 +656,7 @@ defmodule Firebird.CompilerE2EPatternsTest do
 
       try do
         exports = Firebird.exports(instance)
+
         for func <- [:add, :sub, :mul, :square, :cube, :is_positive, :is_even] do
           assert func in exports, "Expected #{func} to be exported"
         end
diff --git a/test/compiler_integration_test.exs b/test/compiler_integration_test.exs
index 8b37f53..327a7b1 100644
--- a/test/compiler_integration_test.exs
+++ b/test/compiler_integration_test.exs
@@ -166,6 +166,7 @@ defmodule Firebird.CompilerIntegrationTest do
       """
 
       expected = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+
       for {expected_val, n} <- Enum.with_index(expected) do
         assert {:ok, [^expected_val]} = compile_and_run(source, "fibonacci", [n])
       end
@@ -184,7 +185,7 @@ defmodule Firebird.CompilerIntegrationTest do
       assert {:ok, [1]} = compile_and_run(source, "factorial", [1])
       assert {:ok, [6]} = compile_and_run(source, "factorial", [3])
       assert {:ok, [120]} = compile_and_run(source, "factorial", [5])
-      assert {:ok, [3628800]} = compile_and_run(source, "factorial", [10])
+      assert {:ok, [3_628_800]} = compile_and_run(source, "factorial", [10])
     end
 
     test "power function with pattern matching" do
diff --git a/test/compiler_options_integration_test.exs b/test/compiler_options_integration_test.exs
index a817e09..c781f2d 100644
--- a/test/compiler_options_integration_test.exs
+++ b/test/compiler_options_integration_test.exs
@@ -8,7 +8,10 @@ defmodule Firebird.CompilerOptionsIntegrationTest do
 
   alias Firebird.Compiler
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_comp_opts_test_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_comp_opts_test_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -312,6 +315,7 @@ defmodule Firebird.CompilerOptionsIntegrationTest do
 
     test "creates output_dir if it doesn't exist", %{tmp: tmp} do
       nested = Path.join(tmp, "deep/nested/dir")
+
       source = """
       defmodule NestedOutput do
         @wasm true
@@ -329,6 +333,7 @@ defmodule Firebird.CompilerOptionsIntegrationTest do
   describe "compile/2 with file path" do
     test "compiles a .ex file", %{tmp: tmp} do
       path = Path.join(tmp, "test_module.ex")
+
       File.write!(path, """
       defmodule FileCompTest do
         @wasm true
@@ -347,6 +352,7 @@ defmodule Firebird.CompilerOptionsIntegrationTest do
 
     test "compiles a .exs file", %{tmp: tmp} do
       path = Path.join(tmp, "test_module.exs")
+
       File.write!(path, """
       defmodule ExsCompTest do
         @wasm true
@@ -421,8 +427,11 @@ defmodule Firebird.CompilerOptionsIntegrationTest do
 
       # This should either compile with error_nodes or fail at validation
       result = Compiler.compile_source(source)
+
       case result do
-        {:error, _} -> assert true
+        {:error, _} ->
+          assert true
+
         {:ok, _} ->
           # If it somehow compiles, the WASM might still be valid but the
           # behavior would be undefined - this is acceptable
@@ -438,9 +447,11 @@ defmodule Firebird.CompilerOptionsIntegrationTest do
 
       # Empty module = no functions = valid but empty
       result = Compiler.compile_source(source)
+
       case result do
         {:ok, r} ->
           assert r.module == :EmptyMod
+
         {:error, _} ->
           # Also acceptable
           assert true
@@ -722,6 +733,7 @@ defmodule Firebird.CompilerOptionsIntegrationTest do
         (func (export "answer") (result i32)
           i32.const 42))
       """
+
       {:ok, wasm} = Compiler.wat_to_wasm(wat)
       {:ok, inst} = Firebird.load(wasm)
       assert {:ok, [42]} = Firebird.call(inst, "answer", [])
diff --git a/test/compiler_pipeline_test.exs b/test/compiler_pipeline_test.exs
index 0767625..e8934e3 100644
--- a/test/compiler_pipeline_test.exs
+++ b/test/compiler_pipeline_test.exs
@@ -351,4 +351,3 @@ defmodule CompilerPipelineTest do
     end
   end
 end
-
diff --git a/test/compiler_test.exs b/test/compiler_test.exs
index 96a6290..c155573 100644
--- a/test/compiler_test.exs
+++ b/test/compiler_test.exs
@@ -97,6 +97,7 @@ defmodule Firebird.CompilerTest do
       """
 
       assert {:ok, result} = Compiler.compile_source(source)
+
       for op <- ["i64.add", "i64.mul", "i64.sub", "i64.div_s", "i64.rem_s"] do
         assert String.contains?(result.wat, op), "Expected #{op} in WAT"
       end
@@ -164,7 +165,8 @@ defmodule Firebird.CompilerTest do
       end
       """
 
-      output_dir = Path.join(System.tmp_dir!(), "firebird_test_#{:erlang.unique_integer([:positive])}")
+      output_dir =
+        Path.join(System.tmp_dir!(), "firebird_test_#{:erlang.unique_integer([:positive])}")
 
       try do
         assert {:ok, _} = Compiler.compile_source(source, output_dir: output_dir)
diff --git a/test/concurrent_wasm_test.exs b/test/concurrent_wasm_test.exs
index dbb14f3..5489cb4 100644
--- a/test/concurrent_wasm_test.exs
+++ b/test/concurrent_wasm_test.exs
@@ -52,19 +52,21 @@ defmodule ConcurrentWasmTest do
       {:ok, rust} = Firebird.load("fixtures/rust_algorithms.wasm")
       {:ok, go} = Firebird.load("fixtures/go_algorithms.wasm", wasi: true)
 
-      rust_task = Task.async(fn ->
-        for n <- [1, 5, 10, 27] do
-          {:ok, [r]} = Firebird.call(rust, :collatz_steps, [n])
-          r
-        end
-      end)
+      rust_task =
+        Task.async(fn ->
+          for n <- [1, 5, 10, 27] do
+            {:ok, [r]} = Firebird.call(rust, :collatz_steps, [n])
+            r
+          end
+        end)
 
-      go_task = Task.async(fn ->
-        for n <- [1, 5, 10, 27] do
-          {:ok, [r]} = Firebird.call(go, :collatz_steps, [n])
-          r
-        end
-      end)
+      go_task =
+        Task.async(fn ->
+          for n <- [1, 5, 10, 27] do
+            {:ok, [r]} = Firebird.call(go, :collatz_steps, [n])
+            r
+          end
+        end)
 
       rust_results = Task.await(rust_task)
       go_results = Task.await(go_task)
diff --git a/test/cross_language_math_test.exs b/test/cross_language_math_test.exs
index cdf7f28..9ed285c 100644
--- a/test/cross_language_math_test.exs
+++ b/test/cross_language_math_test.exs
@@ -39,7 +39,13 @@ defmodule Firebird.CrossLanguageMathTest do
 
   describe "add/2 cross-language consistency" do
     test "basic addition", ctx do
-      for {a, b, expected} <- [{0, 0, 0}, {1, 2, 3}, {100, 200, 300}, {-5, 3, -2}, {-10, -20, -30}] do
+      for {a, b, expected} <- [
+            {0, 0, 0},
+            {1, 2, 3},
+            {100, 200, 300},
+            {-5, 3, -2},
+            {-10, -20, -30}
+          ] do
         results = call_all(ctx, :add, [a, b])
         assert results.rust == [expected], "Rust add(#{a}, #{b}) = #{inspect(results.rust)}"
         assert results.go == [expected], "Go add(#{a}, #{b}) = #{inspect(results.go)}"
@@ -61,7 +67,7 @@ defmodule Firebird.CrossLanguageMathTest do
 
   describe "factorial/1 cross-language consistency" do
     test "small factorials", ctx do
-      for {n, expected} <- [{0, 1}, {1, 1}, {5, 120}, {10, 3628800}, {12, 479001600}] do
+      for {n, expected} <- [{0, 1}, {1, 1}, {5, 120}, {10, 3_628_800}, {12, 479_001_600}] do
         results = call_all(ctx, :factorial, [n])
         assert results.rust == [expected], "factorial(#{n})"
         assert results.go == [expected], "factorial(#{n})"
@@ -103,7 +109,7 @@ defmodule Firebird.CrossLanguageMathTest do
 
   describe "is_prime/1 cross-language consistency" do
     test "prime detection", ctx do
-      primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 97, 101, 104729]
+      primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 97, 101, 104_729]
       non_primes = [0, 1, 4, 6, 8, 9, 10, 15, 100, 1000]
 
       for p <- primes do
@@ -124,7 +130,13 @@ defmodule Firebird.CrossLanguageMathTest do
 
   describe "power/2 cross-language consistency" do
     test "exponentiation", ctx do
-      for {base, exp, expected} <- [{2, 0, 1}, {2, 10, 1024}, {3, 5, 243}, {5, 3, 125}, {10, 4, 10000}] do
+      for {base, exp, expected} <- [
+            {2, 0, 1},
+            {2, 10, 1024},
+            {3, 5, 243},
+            {5, 3, 125},
+            {10, 4, 10000}
+          ] do
         results = call_all(ctx, :power, [base, exp])
         assert results.rust == [expected], "power(#{base}, #{exp})"
         assert results.go == [expected], "power(#{base}, #{exp})"
@@ -233,20 +245,28 @@ defmodule Firebird.CrossLanguageMathTest do
     end
 
     test "run_batch on Rust module" do
-      {:ok, results} = Firebird.WasmRunner.run_batch(@rust_wasm, [
-        {:add, [5, 3]},
-        {:multiply, [4, 7]},
-        {:fibonacci, [10]}
-      ])
+      {:ok, results} =
+        Firebird.WasmRunner.run_batch(@rust_wasm, [
+          {:add, [5, 3]},
+          {:multiply, [4, 7]},
+          {:fibonacci, [10]}
+        ])
+
       assert results == [8, 28, 55]
     end
 
     test "run_batch on Go module" do
-      {:ok, results} = Firebird.WasmRunner.run_batch(@go_wasm, [
-        {:add, [5, 3]},
-        {:multiply, [4, 7]},
-        {:fibonacci, [10]}
-      ], wasi: true)
+      {:ok, results} =
+        Firebird.WasmRunner.run_batch(
+          @go_wasm,
+          [
+            {:add, [5, 3]},
+            {:multiply, [4, 7]},
+            {:fibonacci, [10]}
+          ],
+          wasi: true
+        )
+
       assert results == [8, 28, 55]
     end
 
@@ -263,18 +283,26 @@ defmodule Firebird.CrossLanguageMathTest do
     test "validate_call checks arity" do
       {:ok, pid} = Firebird.load(@rust_wasm)
       assert :ok = Firebird.WasmRunner.validate_call(pid, :add, [1, 2])
-      assert {:error, {:arity_mismatch, :add, _}} = Firebird.WasmRunner.validate_call(pid, :add, [1])
-      assert {:error, {:unknown_function, :nonexistent}} = Firebird.WasmRunner.validate_call(pid, :nonexistent, [])
+
+      assert {:error, {:arity_mismatch, :add, _}} =
+               Firebird.WasmRunner.validate_call(pid, :add, [1])
+
+      assert {:error, {:unknown_function, :nonexistent}} =
+               Firebird.WasmRunner.validate_call(pid, :nonexistent, [])
+
       Firebird.stop(pid)
     end
 
     test "compare across modules" do
-      {:ok, results} = Firebird.WasmRunner.compare(
-        [@rust_wasm, {@go_wasm, [wasi: true]}],
-        :add,
-        [5, 3]
-      )
+      {:ok, results} =
+        Firebird.WasmRunner.compare(
+          [@rust_wasm, {@go_wasm, [wasi: true]}],
+          :add,
+          [5, 3]
+        )
+
       assert length(results) == 2
+
       for {_source, result} <- results do
         assert result == {:ok, [8]}
       end
diff --git a/test/cross_language_test.exs b/test/cross_language_test.exs
index 2c02b16..2c6097a 100644
--- a/test/cross_language_test.exs
+++ b/test/cross_language_test.exs
@@ -23,7 +23,8 @@ defmodule CrossLanguageTest do
 
   describe "add/2 - WAT vs Go" do
     test "produces identical results", %{wat: wat, go: go} do
-      test_cases = [{0, 0}, {1, 2}, {-1, 1}, {100, 200}, {-50, -30}, {2147483, 100}]
+      test_cases = [{0, 0}, {1, 2}, {-1, 1}, {100, 200}, {-50, -30}, {2_147_483, 100}]
+
       for {a, b} <- test_cases do
         {:ok, [wat_r]} = Firebird.call(wat, :add, [a, b])
         {:ok, [go_r]} = Firebird.call(go, :add, [a, b])
@@ -35,6 +36,7 @@ defmodule CrossLanguageTest do
   describe "multiply/2 - WAT vs Go" do
     test "produces identical results", %{wat: wat, go: go} do
       test_cases = [{0, 0}, {1, 1}, {3, 4}, {-5, 6}, {100, 100}]
+
       for {a, b} <- test_cases do
         {:ok, [wat_r]} = Firebird.call(wat, :multiply, [a, b])
         {:ok, [go_r]} = Firebird.call(go, :multiply, [a, b])
@@ -89,7 +91,7 @@ defmodule CrossLanguageTest do
     end
 
     test "digit_sum produces identical results", %{rust_algo: rust, go_algo: go} do
-      for n <- [0, 5, 99, 123, 999, 123456789] do
+      for n <- [0, 5, 99, 123, 999, 123_456_789] do
         {:ok, [rust_r]} = Firebird.call(rust, :digit_sum, [n])
         {:ok, [go_r]} = Firebird.call(go, :digit_sum, [n])
         assert rust_r == go_r, "digit_sum(#{n}): Rust=#{rust_r}, Go=#{go_r}"
@@ -106,6 +108,7 @@ defmodule CrossLanguageTest do
 
     test "lcm produces identical results", %{rust_algo: rust, go_algo: go} do
       pairs = [{4, 6}, {12, 18}, {7, 5}, {0, 5}, {100, 75}]
+
       for {a, b} <- pairs do
         {:ok, [rust_r]} = Firebird.call(rust, :lcm, [a, b])
         {:ok, [go_r]} = Firebird.call(go, :lcm, [a, b])
diff --git a/test/dx_api_completeness_test.exs b/test/dx_api_completeness_test.exs
index 17e5d65..85dcc48 100644
--- a/test/dx_api_completeness_test.exs
+++ b/test/dx_api_completeness_test.exs
@@ -40,11 +40,12 @@ defmodule Firebird.DxApiCompletenessTest do
     end
 
     test "with_instance/2" do
-      assert {:ok, 16} = Firebird.with_instance(@sample_path, fn wasm ->
-        {:ok, [a]} = Firebird.call(wasm, :add, [5, 3])
-        {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 2])
-        b
-      end)
+      assert {:ok, 16} =
+               Firebird.with_instance(@sample_path, fn wasm ->
+                 {:ok, [a]} = Firebird.call(wasm, :add, [5, 3])
+                 {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 2])
+                 b
+               end)
     end
 
     test "pipe/3 and pipe!/3" do
@@ -97,11 +98,14 @@ defmodule Firebird.DxApiCompletenessTest do
 
     test "call_many/2" do
       wasm = Firebird.load!(@sample_path)
-      {:ok, results} = Firebird.call_many(wasm, [
-        {:add, [1, 2]},
-        {:multiply, [3, 4]}
-      ])
-      assert [[3], '\f'] = results
+
+      {:ok, results} =
+        Firebird.call_many(wasm, [
+          {:add, [1, 2]},
+          {:multiply, [3, 4]}
+        ])
+
+      assert [[3], ~c"\f"] = results
       Firebird.stop(wasm)
     end
 
diff --git a/test/dx_api_surface_test.exs b/test/dx_api_surface_test.exs
index eb0a60d..43bb8b0 100644
--- a/test/dx_api_surface_test.exs
+++ b/test/dx_api_surface_test.exs
@@ -109,9 +109,11 @@ defmodule Firebird.DxApiSurfaceTest do
 
   describe "Block & Pipe APIs" do
     test "with_instance/2" do
-      {:ok, result} = Firebird.with_instance(@sample, fn wasm ->
-        Firebird.call_one!(wasm, :add, [5, 3])
-      end)
+      {:ok, result} =
+        Firebird.with_instance(@sample, fn wasm ->
+          Firebird.call_one!(wasm, :add, [5, 3])
+        end)
+
       assert result == 8
     end
 
diff --git a/test/dx_argument_validation_test.exs b/test/dx_argument_validation_test.exs
index eebb147..8f88d60 100644
--- a/test/dx_argument_validation_test.exs
+++ b/test/dx_argument_validation_test.exs
@@ -10,9 +10,11 @@ defmodule Firebird.DxArgumentValidationTest do
     test "raises helpful error when args is not a list" do
       wasm = Firebird.load!(@sample_path)
 
-      error = assert_raise ArgumentError, fn ->
-        Firebird.call(wasm, :add, 5)
-      end
+      error =
+        assert_raise ArgumentError, fn ->
+          Firebird.call(wasm, :add, 5)
+        end
+
       assert error.message =~ "expects args as a list"
       assert error.message =~ "[5, 3]"
 
@@ -22,9 +24,11 @@ defmodule Firebird.DxArgumentValidationTest do
     test "raises helpful error when args is a tuple" do
       wasm = Firebird.load!(@sample_path)
 
-      error = assert_raise ArgumentError, fn ->
-        Firebird.call(wasm, :add, {5, 3})
-      end
+      error =
+        assert_raise ArgumentError, fn ->
+          Firebird.call(wasm, :add, {5, 3})
+        end
+
       assert error.message =~ "expects args as a list"
 
       Firebird.stop(wasm)
@@ -35,9 +39,11 @@ defmodule Firebird.DxArgumentValidationTest do
     test "raises helpful error when args is not a list" do
       wasm = Firebird.load!(@sample_path)
 
-      error = assert_raise ArgumentError, fn ->
-        Firebird.call!(wasm, :add, 5)
-      end
+      error =
+        assert_raise ArgumentError, fn ->
+          Firebird.call!(wasm, :add, 5)
+        end
+
       assert error.message =~ "expects args as a list"
 
       Firebird.stop(wasm)
diff --git a/test/dx_complete_workflow_test.exs b/test/dx_complete_workflow_test.exs
index 222aa4a..eb589d4 100644
--- a/test/dx_complete_workflow_test.exs
+++ b/test/dx_complete_workflow_test.exs
@@ -77,11 +77,13 @@ defmodule Firebird.DxCompleteWorkflowTest do
 
   describe "Step 4: Block API (with_instance)" do
     test "auto-cleanup with with_instance" do
-      {:ok, result} = Firebird.with_instance(@sample, fn wasm ->
-        {:ok, a} = Firebird.call_one(wasm, :add, [5, 3])
-        {:ok, b} = Firebird.call_one(wasm, :multiply, [a, 2])
-        b
-      end)
+      {:ok, result} =
+        Firebird.with_instance(@sample, fn wasm ->
+          {:ok, a} = Firebird.call_one(wasm, :add, [5, 3])
+          {:ok, b} = Firebird.call_one(wasm, :multiply, [a, 2])
+          b
+        end)
+
       assert result == 16
     end
   end
@@ -116,11 +118,14 @@ defmodule Firebird.DxCompleteWorkflowTest do
   describe "Step 7: Batch calls" do
     test "call_many executes multiple calls" do
       {:ok, wasm} = Firebird.load(@sample)
-      {:ok, results} = Firebird.call_many(wasm, [
-        {:add, [1, 2]},
-        {:multiply, [3, 4]},
-        {:fibonacci, [10]}
-      ])
+
+      {:ok, results} =
+        Firebird.call_many(wasm, [
+          {:add, [1, 2]},
+          {:multiply, [3, 4]},
+          {:fibonacci, [10]}
+        ])
+
       assert results == [[3], [12], [55]]
       Firebird.stop(wasm)
     end
@@ -145,9 +150,12 @@ defmodule Firebird.DxCompleteWorkflowTest do
 
     test "call_one! raises with function name in message" do
       {:ok, wasm} = Firebird.load(@sample)
-      error = assert_raise RuntimeError, fn ->
-        Firebird.call_one!(wasm, :nonexistent, [1])
-      end
+
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.call_one!(wasm, :nonexistent, [1])
+        end
+
       assert error.message =~ "nonexistent"
       assert error.message =~ "not found"
       Firebird.stop(wasm)
diff --git a/test/dx_convenience_api_test.exs b/test/dx_convenience_api_test.exs
index 01b30ba..769c66d 100644
--- a/test/dx_convenience_api_test.exs
+++ b/test/dx_convenience_api_test.exs
@@ -49,11 +49,13 @@ defmodule Firebird.DxConvenienceApiTest do
 
   describe "Firebird.with_instance/3 with call_one" do
     test "block API with single-value unwrapping" do
-      {:ok, result} = Firebird.with_instance(Firebird.sample_wasm_path(), fn wasm ->
-        a = Firebird.call_one!(wasm, :add, [5, 3])
-        b = Firebird.call_one!(wasm, :multiply, [a, 2])
-        b
-      end)
+      {:ok, result} =
+        Firebird.with_instance(Firebird.sample_wasm_path(), fn wasm ->
+          a = Firebird.call_one!(wasm, :add, [5, 3])
+          b = Firebird.call_one!(wasm, :multiply, [a, 2])
+          b
+        end)
+
       assert result == 16
     end
   end
diff --git a/test/dx_convenience_test.exs b/test/dx_convenience_test.exs
index 5ae8948..1386f9b 100644
--- a/test/dx_convenience_test.exs
+++ b/test/dx_convenience_test.exs
@@ -19,9 +19,11 @@ defmodule Firebird.DXConvenienceTest do
     test "cleans up after itself" do
       # Run should not leave lingering processes
       before = length(Process.list())
+
       for _ <- 1..5 do
         {:ok, _} = Firebird.run(@math_wasm, :add, [1, 1])
       end
+
       # Allow some tolerance for async cleanup
       :timer.sleep(50)
       after_count = length(Process.list())
@@ -51,10 +53,11 @@ defmodule Firebird.DXConvenienceTest do
 
   describe "Firebird.with_instance/3 - block API" do
     test "auto-cleans up after block" do
-      {:ok, result} = Firebird.with_instance(@math_wasm, fn wasm ->
-        {:ok, [a]} = Firebird.call(wasm, :add, [5, 3])
-        a
-      end)
+      {:ok, result} =
+        Firebird.with_instance(@math_wasm, fn wasm ->
+          {:ok, [a]} = Firebird.call(wasm, :add, [5, 3])
+          a
+        end)
 
       assert result == 8
     end
@@ -68,9 +71,10 @@ defmodule Firebird.DXConvenienceTest do
     end
 
     test "returns error for bad wasm" do
-      assert {:error, _} = Firebird.with_instance("nonexistent.wasm", fn _wasm ->
-        :should_not_reach
-      end)
+      assert {:error, _} =
+               Firebird.with_instance("nonexistent.wasm", fn _wasm ->
+                 :should_not_reach
+               end)
     end
   end
 
@@ -104,9 +108,10 @@ defmodule Firebird.DXConvenienceTest do
 
   describe "Firebird.load!/2 - error messages" do
     test "raises with helpful message for missing file" do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.load!("nonexistent.wasm")
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.load!("nonexistent.wasm")
+        end
 
       assert error.message =~ "not found"
       assert error.message =~ "priv/wasm/"
@@ -136,9 +141,10 @@ defmodule Firebird.DXConvenienceTest do
 
   describe "Firebird.describe/1" do
     test "describes a file path" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Firebird.describe(@math_wasm)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Firebird.describe(@math_wasm)
+        end)
 
       assert output =~ "math.wasm"
       assert output =~ "add"
@@ -147,9 +153,10 @@ defmodule Firebird.DXConvenienceTest do
     test "describes a running instance" do
       {:ok, instance} = Firebird.load(@math_wasm)
 
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Firebird.describe(instance)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Firebird.describe(instance)
+        end)
 
       assert output =~ "alive"
       assert output =~ "add"
@@ -160,11 +167,12 @@ defmodule Firebird.DXConvenienceTest do
 
   describe "Firebird.from_wat/2" do
     test "loads WAT source as WASM" do
-      {:ok, wasm} = Firebird.from_wat("""
-      (module
-        (func (export "add") (param i32 i32) (result i32)
-          local.get 0 local.get 1 i32.add))
-      """)
+      {:ok, wasm} =
+        Firebird.from_wat("""
+        (module
+          (func (export "add") (param i32 i32) (result i32)
+            local.get 0 local.get 1 i32.add))
+        """)
 
       assert {:ok, [8]} = Firebird.call(wasm, :add, [5, 3])
       Firebird.stop(wasm)
@@ -173,11 +181,12 @@ defmodule Firebird.DXConvenienceTest do
 
   describe "Firebird.from_wat!/2" do
     test "loads WAT source, raising on error" do
-      wasm = Firebird.from_wat!("""
-      (module
-        (func (export "double") (param i32) (result i32)
-          local.get 0 i32.const 2 i32.mul))
-      """)
+      wasm =
+        Firebird.from_wat!("""
+        (module
+          (func (export "double") (param i32) (result i32)
+            local.get 0 i32.const 2 i32.mul))
+        """)
 
       assert [10] = Firebird.call!(wasm, :double, [5])
       Firebird.stop(wasm)
@@ -218,12 +227,13 @@ defmodule Firebird.DXConvenienceTest do
 
   describe "Firebird.playground/0" do
     test "returns a working WASM instance" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        wasm = Firebird.playground()
-        assert is_pid(wasm)
-        assert {:ok, [8]} = Firebird.call(wasm, :add, [5, 3])
-        Firebird.stop(wasm)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          wasm = Firebird.playground()
+          assert is_pid(wasm)
+          assert {:ok, [8]} = Firebird.call(wasm, :add, [5, 3])
+          Firebird.stop(wasm)
+        end)
 
       assert output =~ "playground ready"
     end
@@ -231,9 +241,10 @@ defmodule Firebird.DXConvenienceTest do
 
   describe "Firebird.demo/0" do
     test "runs without error" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.demo()
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.demo()
+        end)
 
       assert output =~ "Demo"
       assert output =~ "add(5, 3)"
@@ -245,9 +256,10 @@ defmodule Firebird.DXConvenienceTest do
     test "suggests similar function names" do
       {:ok, instance} = Firebird.load(@math_wasm)
 
-      error = assert_raise RuntimeError, fn ->
-        Firebird.call!(instance, :addd, [5, 3])
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.call!(instance, :addd, [5, 3])
+        end
 
       # Should suggest "add" for "addd"
       assert error.message =~ "add" or error.message =~ "Available functions"
diff --git a/test/dx_describe_test.exs b/test/dx_describe_test.exs
index 1c8ae31..2f3c338 100644
--- a/test/dx_describe_test.exs
+++ b/test/dx_describe_test.exs
@@ -3,36 +3,45 @@ defmodule Firebird.DxDescribeTest do
 
   describe "describe/1 with smart path resolution" do
     test "describe works with bare filename" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe("math.wasm")
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe("math.wasm")
+        end)
+
       assert output =~ "math.wasm"
       assert output =~ "add"
       assert output =~ "fibonacci"
     end
 
     test "describe works with full path" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe("fixtures/math.wasm")
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe("fixtures/math.wasm")
+        end)
+
       assert output =~ "math.wasm"
       assert output =~ "add"
     end
 
     test "describe works with pid" do
       wasm = Firebird.load!("math.wasm")
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe(wasm)
-      end)
+
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe(wasm)
+        end)
+
       assert output =~ "WASM Instance"
       assert output =~ "alive"
       Firebird.stop(wasm)
     end
 
     test "describe handles missing file gracefully" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe("totally_missing.wasm")
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe("totally_missing.wasm")
+        end)
+
       assert output =~ "Cannot inspect"
     end
   end
diff --git a/test/dx_edge_cases_test.exs b/test/dx_edge_cases_test.exs
index 2ba98e2..2805508 100644
--- a/test/dx_edge_cases_test.exs
+++ b/test/dx_edge_cases_test.exs
@@ -89,9 +89,11 @@ defmodule Firebird.DXEdgeCasesTest do
 
   describe "with_instance edge cases" do
     test "returns error when file not found" do
-      result = Firebird.with_instance("nonexistent.wasm", fn _wasm ->
-        :unreachable
-      end)
+      result =
+        Firebird.with_instance("nonexistent.wasm", fn _wasm ->
+          :unreachable
+        end)
+
       assert {:error, _} = result
     end
 
@@ -104,14 +106,18 @@ defmodule Firebird.DXEdgeCasesTest do
     end
 
     test "nested with_instance" do
-      {:ok, result} = Firebird.with_instance(@math_wasm, fn wasm1 ->
-        {:ok, inner} = Firebird.with_instance(@math_wasm, fn wasm2 ->
-          {:ok, [a]} = Firebird.call(wasm1, :add, [1, 2])
-          {:ok, [b]} = Firebird.call(wasm2, :multiply, [a, 3])
-          b
+      {:ok, result} =
+        Firebird.with_instance(@math_wasm, fn wasm1 ->
+          {:ok, inner} =
+            Firebird.with_instance(@math_wasm, fn wasm2 ->
+              {:ok, [a]} = Firebird.call(wasm1, :add, [1, 2])
+              {:ok, [b]} = Firebird.call(wasm2, :multiply, [a, 3])
+              b
+            end)
+
+          inner
         end)
-        inner
-      end)
+
       assert result == 9
     end
   end
@@ -184,11 +190,14 @@ defmodule Firebird.DXEdgeCasesTest do
 
     test "stops on first error" do
       {:ok, wasm} = Firebird.load(@math_wasm)
-      result = Firebird.call_many(wasm, [
-        {:add, [1, 2]},
-        {:nonexistent, [1]},
-        {:add, [3, 4]}
-      ])
+
+      result =
+        Firebird.call_many(wasm, [
+          {:add, [1, 2]},
+          {:nonexistent, [1]},
+          {:add, [3, 4]}
+        ])
+
       assert {:error, _} = result
       Firebird.stop(wasm)
     end
@@ -203,9 +212,11 @@ defmodule Firebird.DXEdgeCasesTest do
 
     test "pipe! raises for bad function" do
       {:ok, wasm} = Firebird.load(@math_wasm)
+
       assert_raise RuntimeError, fn ->
         Firebird.pipe!(wasm, :nonexistent, [1])
       end
+
       Firebird.stop(wasm)
     end
   end
diff --git a/test/dx_error_messages_test.exs b/test/dx_error_messages_test.exs
index 0ed31a3..a1d3c34 100644
--- a/test/dx_error_messages_test.exs
+++ b/test/dx_error_messages_test.exs
@@ -9,26 +9,32 @@ defmodule Firebird.DxErrorMessagesTest do
 
   describe "call_one! error messages" do
     test "suggests similar function name", %{wasm: wasm} do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.call_one!(wasm, :addd, [5, 3])
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.call_one!(wasm, :addd, [5, 3])
+        end
+
       assert error.message =~ "Did you mean: add?"
       assert error.message =~ "Available:"
     end
 
     test "shows available functions for completely wrong name", %{wasm: wasm} do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.call_one!(wasm, :zzzzz, [5, 3])
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.call_one!(wasm, :zzzzz, [5, 3])
+        end
+
       assert error.message =~ "Available functions:"
     end
   end
 
   describe "load! error messages" do
     test "helpful message for missing file" do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.load!("/nonexistent/path/math.wasm")
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.load!("/nonexistent/path/math.wasm")
+        end
+
       assert error.message =~ "WASM file not found"
       assert error.message =~ "priv/wasm/"
     end
diff --git a/test/dx_error_quality_test.exs b/test/dx_error_quality_test.exs
index ff1efad..18ecfb1 100644
--- a/test/dx_error_quality_test.exs
+++ b/test/dx_error_quality_test.exs
@@ -9,9 +9,11 @@ defmodule Firebird.DxErrorQualityTest do
 
   describe "file not found errors" do
     test "load! shows searched paths" do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.load!("nonexistent_module.wasm")
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.load!("nonexistent_module.wasm")
+        end
+
       assert error.message =~ "WASM file not found"
       assert error.message =~ "nonexistent_module.wasm"
       assert error.message =~ "Searched locations"
@@ -20,16 +22,20 @@ defmodule Firebird.DxErrorQualityTest do
     end
 
     test "load! suggests mix firebird.init" do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.load!("missing.wasm")
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.load!("missing.wasm")
+        end
+
       assert error.message =~ "firebird.init"
     end
 
     test "load! suggests sample_wasm_path" do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.load!("missing.wasm")
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.load!("missing.wasm")
+        end
+
       assert error.message =~ "sample_wasm_path"
     end
   end
@@ -80,7 +86,7 @@ defmodule Firebird.DxErrorQualityTest do
   describe "validation errors" do
     test "validate returns error for non-wasm file" do
       # Create a temp file with invalid content
-      tmp = Path.join(System.tmp_dir!(), "not_wasm_#{:rand.uniform(100000)}.wasm")
+      tmp = Path.join(System.tmp_dir!(), "not_wasm_#{:rand.uniform(100_000)}.wasm")
       File.write!(tmp, "this is not wasm")
 
       result = Firebird.validate(tmp)
diff --git a/test/dx_mix_tasks_test.exs b/test/dx_mix_tasks_test.exs
index 79b1f6c..0eac405 100644
--- a/test/dx_mix_tasks_test.exs
+++ b/test/dx_mix_tasks_test.exs
@@ -6,9 +6,11 @@ defmodule Firebird.DxMixTasksTest do
 
   describe "mix firebird (list tasks)" do
     test "lists available tasks" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Mix.Tasks.Firebird.run([])
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Mix.Tasks.Firebird.run([])
+        end)
+
       assert output =~ "firebird.init"
       assert output =~ "firebird.doctor"
       assert output =~ "firebird.gen"
@@ -18,9 +20,11 @@ defmodule Firebird.DxMixTasksTest do
 
   describe "mix firebird.doctor" do
     test "runs all checks" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Mix.Tasks.Firebird.Doctor.run([])
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Mix.Tasks.Firebird.Doctor.run([])
+        end)
+
       assert output =~ "Wasmex dependency"
       assert output =~ "WASM runtime"
       assert output =~ "Function calls"
@@ -28,18 +32,22 @@ defmodule Firebird.DxMixTasksTest do
     end
 
     test "reports all checks passing" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Mix.Tasks.Firebird.Doctor.run([])
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Mix.Tasks.Firebird.Doctor.run([])
+        end)
+
       assert output =~ "checks passed"
     end
   end
 
   describe "mix firebird.inspect" do
     test "inspects a WASM file" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Mix.Tasks.Firebird.Inspect.run(["fixtures/math.wasm"])
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Mix.Tasks.Firebird.Inspect.run(["fixtures/math.wasm"])
+        end)
+
       assert output =~ "add"
       assert output =~ "multiply"
       assert output =~ "fibonacci"
@@ -49,7 +57,7 @@ defmodule Firebird.DxMixTasksTest do
 
   describe "mix firebird.init" do
     test "creates expected files in temp directory" do
-      tmp = Path.join(System.tmp_dir!(), "firebird_init_test_#{:rand.uniform(100000)}")
+      tmp = Path.join(System.tmp_dir!(), "firebird_init_test_#{:rand.uniform(100_000)}")
       File.mkdir_p!(tmp)
 
       # Change to temp dir for the test
@@ -57,9 +65,10 @@ defmodule Firebird.DxMixTasksTest do
       File.cd!(tmp)
 
       try do
-        output = ExUnit.CaptureIO.capture_io(fn ->
-          Mix.Tasks.Firebird.Init.run([])
-        end)
+        output =
+          ExUnit.CaptureIO.capture_io(fn ->
+            Mix.Tasks.Firebird.Init.run([])
+          end)
 
         assert output =~ "Initializing Firebird"
         assert File.dir?(Path.join(tmp, "wasm"))
@@ -73,7 +82,7 @@ defmodule Firebird.DxMixTasksTest do
 
   describe "mix firebird.gen" do
     test "generates a module from a WASM file" do
-      tmp = Path.join(System.tmp_dir!(), "firebird_gen_test_#{:rand.uniform(100000)}")
+      tmp = Path.join(System.tmp_dir!(), "firebird_gen_test_#{:rand.uniform(100_000)}")
       File.mkdir_p!(tmp)
 
       original_dir = File.cwd!()
@@ -82,9 +91,10 @@ defmodule Firebird.DxMixTasksTest do
       try do
         wasm_path = Path.join(original_dir, "fixtures/math.wasm")
 
-        output = ExUnit.CaptureIO.capture_io(fn ->
-          Mix.Tasks.Firebird.Gen.run([wasm_path, "--module", "TestGen.Math"])
-        end)
+        output =
+          ExUnit.CaptureIO.capture_io(fn ->
+            Mix.Tasks.Firebird.Gen.run([wasm_path, "--module", "TestGen.Math"])
+          end)
 
         assert output =~ "Generated"
 
diff --git a/test/dx_module_workflow_test.exs b/test/dx_module_workflow_test.exs
index 281dc5c..ed325c0 100644
--- a/test/dx_module_workflow_test.exs
+++ b/test/dx_module_workflow_test.exs
@@ -21,6 +21,7 @@ defmodule Firebird.DxModuleWorkflowTest do
   describe "manual declaration module" do
     setup do
       {:ok, _pid} = ManualMath.start_link()
+
       on_exit(fn ->
         try do
           ManualMath.stop()
@@ -28,6 +29,7 @@ defmodule Firebird.DxModuleWorkflowTest do
           :exit, _ -> :ok
         end
       end)
+
       :ok
     end
 
@@ -58,6 +60,7 @@ defmodule Firebird.DxModuleWorkflowTest do
   describe "auto-discovery module" do
     setup do
       {:ok, _pid} = AutoMath.start_link()
+
       on_exit(fn ->
         try do
           AutoMath.stop()
@@ -65,6 +68,7 @@ defmodule Firebird.DxModuleWorkflowTest do
           :exit, _ -> :ok
         end
       end)
+
       :ok
     end
 
@@ -92,7 +96,9 @@ defmodule Firebird.DxModuleWorkflowTest do
     test "manual module has child_spec" do
       spec = ManualMath.child_spec([])
       assert spec.id == ManualMath
-      assert is_function(elem(spec.start, 2) |> hd() |> Keyword.get(:name, nil) || fn -> nil end) || true
+
+      assert is_function(elem(spec.start, 2) |> hd() |> Keyword.get(:name, nil) || fn -> nil end) ||
+               true
     end
 
     test "auto module has child_spec" do
diff --git a/test/dx_onboarding_test.exs b/test/dx_onboarding_test.exs
index 76a9659..9ee2e80 100644
--- a/test/dx_onboarding_test.exs
+++ b/test/dx_onboarding_test.exs
@@ -66,11 +66,13 @@ defmodule Firebird.DxOnboardingTest do
 
   describe "Step 5: with_instance (auto-cleanup)" do
     test "with_instance cleans up automatically" do
-      {:ok, result} = Firebird.with_instance(@sample_path, fn wasm ->
-        {:ok, [a]} = Firebird.call(wasm, :add, [5, 3])
-        {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 2])
-        b
-      end)
+      {:ok, result} =
+        Firebird.with_instance(@sample_path, fn wasm ->
+          {:ok, [a]} = Firebird.call(wasm, :add, [5, 3])
+          {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 2])
+          b
+        end)
+
       assert result == 16
     end
   end
@@ -120,11 +122,12 @@ defmodule Firebird.DxOnboardingTest do
     end
 
     test "quick with inline WAT" do
-      assert 42 = Firebird.quick(
-        "(module (func (export \"answer\") (result i32) i32.const 42))",
-        :answer,
-        []
-      )
+      assert 42 =
+               Firebird.quick(
+                 "(module (func (export \"answer\") (result i32) i32.const 42))",
+                 :answer,
+                 []
+               )
     end
   end
 
@@ -142,9 +145,11 @@ defmodule Firebird.DxOnboardingTest do
 
     test "call_one! raises on missing function" do
       wasm = Firebird.load!(@sample_path)
+
       assert_raise RuntimeError, fn ->
         Firebird.call_one!(wasm, :this_does_not_exist, [1])
       end
+
       Firebird.stop(wasm)
     end
   end
@@ -152,7 +157,10 @@ defmodule Firebird.DxOnboardingTest do
   describe "map/3 for batch processing" do
     test "maps a function over multiple inputs" do
       wasm = Firebird.load!(@sample_path)
-      results = Firebird.map(wasm, :fibonacci, [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]])
+
+      results =
+        Firebird.map(wasm, :fibonacci, [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]])
+
       assert results == [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
       Firebird.stop(wasm)
     end
@@ -170,7 +178,8 @@ defmodule Firebird.DxOnboardingTest do
       wasm = Firebird.load!(@sample_path)
       {[sum], wasm2} = Firebird.pipe!(wasm, :add, [5, 3])
       assert sum == 8
-      assert wasm == wasm2  # same instance
+      # same instance
+      assert wasm == wasm2
       {[product], _wasm3} = Firebird.pipe!(wasm2, :multiply, [sum, 2])
       assert product == 16
       Firebird.stop(wasm)
@@ -179,13 +188,15 @@ defmodule Firebird.DxOnboardingTest do
 
   describe "WAT inline compilation" do
     test "from_wat loads a WAT module" do
-      {:ok, wasm} = Firebird.from_wat("""
-      (module
-        (func (export "add") (param i32 i32) (result i32)
-          local.get 0
-          local.get 1
-          i32.add))
-      """)
+      {:ok, wasm} =
+        Firebird.from_wat("""
+        (module
+          (func (export "add") (param i32 i32) (result i32)
+            local.get 0
+            local.get 1
+            i32.add))
+        """)
+
       assert {:ok, [8]} = Firebird.call(wasm, :add, [5, 3])
       Firebird.stop(wasm)
     end
diff --git a/test/dx_pool_workflow_test.exs b/test/dx_pool_workflow_test.exs
index 9d568e8..18c938b 100644
--- a/test/dx_pool_workflow_test.exs
+++ b/test/dx_pool_workflow_test.exs
@@ -8,11 +8,13 @@ defmodule Firebird.DxPoolWorkflowTest do
 
   describe "pool via supervision tree pattern" do
     setup do
-      {:ok, pid} = Firebird.Pool.start_link(
-        wasm: @sample_path,
-        size: 2,
-        name: :test_math_pool
-      )
+      {:ok, pid} =
+        Firebird.Pool.start_link(
+          wasm: @sample_path,
+          size: 2,
+          name: :test_math_pool
+        )
+
       on_exit(fn ->
         try do
           GenServer.stop(pid)
@@ -20,6 +22,7 @@ defmodule Firebird.DxPoolWorkflowTest do
           :exit, _ -> :ok
         end
       end)
+
       :ok
     end
 
@@ -40,11 +43,12 @@ defmodule Firebird.DxPoolWorkflowTest do
     end
 
     test "concurrent calls work" do
-      tasks = for i <- 1..10 do
-        Task.async(fn ->
-          Firebird.Pool.call_one!(:test_math_pool, :add, [i, i])
-        end)
-      end
+      tasks =
+        for i <- 1..10 do
+          Task.async(fn ->
+            Firebird.Pool.call_one!(:test_math_pool, :add, [i, i])
+          end)
+        end
 
       results = Task.await_many(tasks)
       assert results == Enum.map(1..10, &(&1 * 2))
@@ -53,11 +57,13 @@ defmodule Firebird.DxPoolWorkflowTest do
 
   describe "pool via Firebird convenience API" do
     setup do
-      {:ok, pid} = Firebird.start_pool(
-        wasm: @sample_path,
-        size: 2,
-        name: :test_convenience_pool
-      )
+      {:ok, pid} =
+        Firebird.start_pool(
+          wasm: @sample_path,
+          size: 2,
+          name: :test_convenience_pool
+        )
+
       on_exit(fn ->
         try do
           Firebird.stop_pool(:test_convenience_pool)
@@ -65,6 +71,7 @@ defmodule Firebird.DxPoolWorkflowTest do
           :exit, _ -> :ok
         end
       end)
+
       {:ok, pool_pid: pid}
     end
 
diff --git a/test/dx_quick_api_test.exs b/test/dx_quick_api_test.exs
index eb31240..b843fda 100644
--- a/test/dx_quick_api_test.exs
+++ b/test/dx_quick_api_test.exs
@@ -24,15 +24,17 @@ defmodule Firebird.DxQuickApiTest do
           i32.const 2
           i32.mul))
       """
+
       assert 10 = Firebird.quick(wat, :double, [5])
     end
 
     test "works with single-line WAT" do
-      assert 42 = Firebird.quick(
-        ~s|(module (func (export "answer") (result i32) i32.const 42))|,
-        :answer,
-        []
-      )
+      assert 42 =
+               Firebird.quick(
+                 ~s|(module (func (export "answer") (result i32) i32.const 42))|,
+                 :answer,
+                 []
+               )
     end
 
     test "raises on invalid function" do
diff --git a/test/dx_sixty_seconds_test.exs b/test/dx_sixty_seconds_test.exs
index acc3a20..40a0da1 100644
--- a/test/dx_sixty_seconds_test.exs
+++ b/test/dx_sixty_seconds_test.exs
@@ -11,9 +11,11 @@ defmodule Firebird.DxSixtySecondsTest do
   end
 
   test "Step 2: demo runs without error" do
-    output = ExUnit.CaptureIO.capture_io(fn ->
-      assert :ok = Firebird.demo()
-    end)
+    output =
+      ExUnit.CaptureIO.capture_io(fn ->
+        assert :ok = Firebird.demo()
+      end)
+
     assert output =~ "Everything works"
   end
 
@@ -34,20 +36,24 @@ defmodule Firebird.DxSixtySecondsTest do
   end
 
   test "Step 5: with_instance (auto-cleanup)" do
-    {:ok, result} = Firebird.with_instance("math.wasm", fn wasm ->
-      {:ok, [a]} = Firebird.call(wasm, :add, [5, 3])
-      {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 2])
-      b
-    end)
+    {:ok, result} =
+      Firebird.with_instance("math.wasm", fn wasm ->
+        {:ok, [a]} = Firebird.call(wasm, :add, [5, 3])
+        {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 2])
+        b
+      end)
+
     assert result == 16
   end
 
   test "Step 6: inline WAT" do
-    result = Firebird.quick(
-      "(module (func (export \"answer\") (result i32) i32.const 42))",
-      :answer,
-      []
-    )
+    result =
+      Firebird.quick(
+        "(module (func (export \"answer\") (result i32) i32.const 42))",
+        :answer,
+        []
+      )
+
     assert result == 42
   end
 
@@ -67,9 +73,11 @@ defmodule Firebird.DxSixtySecondsTest do
   end
 
   test "Step 9: describe a WASM file" do
-    output = ExUnit.CaptureIO.capture_io(fn ->
-      Firebird.describe("math.wasm")
-    end)
+    output =
+      ExUnit.CaptureIO.capture_io(fn ->
+        Firebird.describe("math.wasm")
+      end)
+
     assert output =~ "add"
     assert output =~ "fibonacci"
   end
diff --git a/test/dx_status_test.exs b/test/dx_status_test.exs
index 3bb2df2..541b550 100644
--- a/test/dx_status_test.exs
+++ b/test/dx_status_test.exs
@@ -3,9 +3,11 @@ defmodule Firebird.DxStatusTest do
 
   describe "Firebird.status/0" do
     test "prints status without error" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.status()
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.status()
+        end)
+
       assert output =~ "Firebird"
       assert output =~ "Runtime: working"
       assert output =~ "Tools"
diff --git a/test/dx_wat_workflow_test.exs b/test/dx_wat_workflow_test.exs
index 1c6d67f..c0a9402 100644
--- a/test/dx_wat_workflow_test.exs
+++ b/test/dx_wat_workflow_test.exs
@@ -7,13 +7,14 @@ defmodule Firebird.DxWatWorkflowTest do
 
   describe "from_wat/1 - load WAT directly" do
     test "creates instance from WAT string" do
-      {:ok, wasm} = Firebird.from_wat("""
-      (module
-        (func (export "add") (param i32 i32) (result i32)
-          local.get 0
-          local.get 1
-          i32.add))
-      """)
+      {:ok, wasm} =
+        Firebird.from_wat("""
+        (module
+          (func (export "add") (param i32 i32) (result i32)
+            local.get 0
+            local.get 1
+            i32.add))
+        """)
 
       assert {:ok, 8} = Firebird.call_one(wasm, :add, [5, 3])
       Firebird.stop(wasm)
@@ -30,7 +31,8 @@ defmodule Firebird.DxWatWorkflowTest do
     test "compiles WAT to bytes" do
       {:ok, bytes} = Firebird.compile_wat("(module)")
       assert is_binary(bytes)
-      assert <<0, 97, 115, 109, _::binary>> = bytes  # WASM magic number
+      # WASM magic number
+      assert <<0, 97, 115, 109, _::binary>> = bytes
     end
 
     test "returns error for invalid WAT" do
@@ -40,26 +42,38 @@ defmodule Firebird.DxWatWorkflowTest do
 
   describe "Quick.eval_wat/3" do
     test "evaluates WAT inline" do
-      {:ok, [42]} = Firebird.Quick.eval_wat("""
-      (module
-        (func (export "answer") (result i32)
-          i32.const 42))
-      """, "answer")
+      {:ok, [42]} =
+        Firebird.Quick.eval_wat(
+          """
+          (module
+            (func (export "answer") (result i32)
+              i32.const 42))
+          """,
+          "answer"
+        )
     end
 
     test "eval_wat! returns directly" do
-      [42] = Firebird.Quick.eval_wat!("""
-      (module
-        (func (export "answer") (result i32)
-          i32.const 42))
-      """, "answer")
+      [42] =
+        Firebird.Quick.eval_wat!(
+          """
+          (module
+            (func (export "answer") (result i32)
+              i32.const 42))
+          """,
+          "answer"
+        )
     end
   end
 
   describe "Quick.wat_fn/3" do
     test "creates callable from WAT body" do
-      add = Firebird.Quick.wat_fn("add", "(param i32 i32) (result i32)",
-        "local.get 0 local.get 1 i32.add")
+      add =
+        Firebird.Quick.wat_fn(
+          "add",
+          "(param i32 i32) (result i32)",
+          "local.get 0 local.get 1 i32.add"
+        )
 
       assert {:ok, [8]} = add.([5, 3])
       assert {:ok, [12]} = add.([7, 5])
@@ -82,13 +96,14 @@ defmodule Firebird.DxWatWorkflowTest do
     test "compile-time WAT compilation" do
       import Firebird.Sigils
 
-      bytes = wat!("""
-      (module
-        (func (export "double") (param i32) (result i32)
-          local.get 0
-          i32.const 2
-          i32.mul))
-      """)
+      bytes =
+        wat!("""
+        (module
+          (func (export "double") (param i32) (result i32)
+            local.get 0
+            i32.const 2
+            i32.mul))
+        """)
 
       assert is_binary(bytes)
       {:ok, wasm} = Firebird.load(bytes)
diff --git a/test/dx_workflow_test.exs b/test/dx_workflow_test.exs
index 568662d..9a07b0d 100644
--- a/test/dx_workflow_test.exs
+++ b/test/dx_workflow_test.exs
@@ -17,12 +17,14 @@ defmodule Firebird.DXWorkflowTest do
       assert output =~ "add(5, 3) = 8"
 
       # Step 3: Playground
-      wasm = ExUnit.CaptureIO.capture_io(fn ->
-        Firebird.playground()
-      end) |> then(fn _ ->
-        # Playground prints output, but we just need a real instance
-        Firebird.load!(Firebird.sample_wasm_path())
-      end)
+      wasm =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Firebird.playground()
+        end)
+        |> then(fn _ ->
+          # Playground prints output, but we just need a real instance
+          Firebird.load!(Firebird.sample_wasm_path())
+        end)
 
       # Step 4: Experiment
       assert {:ok, [8]} = Firebird.call(wasm, :add, [5, 3])
@@ -37,9 +39,10 @@ defmodule Firebird.DXWorkflowTest do
     end
 
     test "run multiple independent computations" do
-      results = for {func, args} <- [{:add, [5, 3]}, {:multiply, [4, 7]}, {:fibonacci, [10]}] do
-        Firebird.run!(@math_wasm, func, args)
-      end
+      results =
+        for {func, args} <- [{:add, [5, 3]}, {:multiply, [4, 7]}, {:fibonacci, [10]}] do
+          Firebird.run!(@math_wasm, func, args)
+        end
 
       assert results == [[8], [28], [55]]
     end
@@ -78,11 +81,12 @@ defmodule Firebird.DXWorkflowTest do
 
   describe "Workflow: Block computation" do
     test "with_instance for auto-cleanup" do
-      {:ok, result} = Firebird.with_instance(@math_wasm, fn wasm ->
-        {:ok, [a]} = Firebird.call(wasm, :add, [5, 3])
-        {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 2])
-        b
-      end)
+      {:ok, result} =
+        Firebird.with_instance(@math_wasm, fn wasm ->
+          {:ok, [a]} = Firebird.call(wasm, :add, [5, 3])
+          {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 2])
+          b
+        end)
 
       assert result == 16
     end
@@ -107,13 +111,14 @@ defmodule Firebird.DXWorkflowTest do
 
   describe "Workflow: Inline WAT prototyping" do
     test "from_wat! for quick WASM creation" do
-      wasm = Firebird.from_wat!("""
-      (module
-        (func (export "square") (param i32) (result i32)
-          local.get 0
-          local.get 0
-          i32.mul))
-      """)
+      wasm =
+        Firebird.from_wat!("""
+        (module
+          (func (export "square") (param i32) (result i32)
+            local.get 0
+            local.get 0
+            i32.mul))
+        """)
 
       assert {:ok, [25]} = Firebird.call(wasm, :square, [5])
       assert {:ok, [100]} = Firebird.call(wasm, :square, [10])
@@ -123,13 +128,14 @@ defmodule Firebird.DXWorkflowTest do
     test "compile-time wat! macro" do
       import Firebird.Sigils
 
-      bytes = wat!("""
-      (module
-        (func (export "triple") (param i32) (result i32)
-          local.get 0
-          i32.const 3
-          i32.mul))
-      """)
+      bytes =
+        wat!("""
+        (module
+          (func (export "triple") (param i32) (result i32)
+            local.get 0
+            i32.const 3
+            i32.mul))
+        """)
 
       {:ok, wasm} = Firebird.load(bytes)
       assert {:ok, [15]} = Firebird.call(wasm, :triple, [5])
@@ -137,10 +143,14 @@ defmodule Firebird.DXWorkflowTest do
     end
 
     test "Quick.eval_wat for one-off eval" do
-      assert {:ok, [42]} = Firebird.Quick.eval_wat("""
-      (module
-        (func (export "answer") (result i32) i32.const 42))
-      """, "answer")
+      assert {:ok, [42]} =
+               Firebird.Quick.eval_wat(
+                 """
+                 (module
+                   (func (export "answer") (result i32) i32.const 42))
+                 """,
+                 "answer"
+               )
     end
   end
 
@@ -158,9 +168,10 @@ defmodule Firebird.DXWorkflowTest do
     end
 
     test "describe file" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Firebird.describe(@math_wasm)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Firebird.describe(@math_wasm)
+        end)
 
       assert output =~ "add"
     end
@@ -168,9 +179,10 @@ defmodule Firebird.DXWorkflowTest do
     test "describe running instance" do
       {:ok, wasm} = Firebird.load(@math_wasm)
 
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Firebird.describe(wasm)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Firebird.describe(wasm)
+        end)
 
       assert output =~ "alive"
       Firebird.stop(wasm)
@@ -189,17 +201,22 @@ defmodule Firebird.DXWorkflowTest do
     end
 
     test "helpful error message from load!" do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.load!("nonexistent.wasm")
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.load!("nonexistent.wasm")
+        end
+
       assert error.message =~ "not found"
     end
 
     test "helpful error message from call!" do
       {:ok, wasm} = Firebird.load(@math_wasm)
-      error = assert_raise RuntimeError, fn ->
-        Firebird.call!(wasm, :nonexistent, [1])
-      end
+
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.call!(wasm, :nonexistent, [1])
+        end
+
       assert error.message =~ "Available functions" or error.message =~ "failed"
       Firebird.stop(wasm)
     end
@@ -246,8 +263,12 @@ defmodule Firebird.DXWorkflowTest do
     end
 
     test "wat_fn for custom inline functions" do
-      add = Firebird.Quick.wat_fn("add", "(param i32 i32) (result i32)",
-        "local.get 0 local.get 1 i32.add")
+      add =
+        Firebird.Quick.wat_fn(
+          "add",
+          "(param i32 i32) (result i32)",
+          "local.get 0 local.get 1 i32.add"
+        )
 
       assert {:ok, [8]} = add.([5, 3])
       assert {:ok, [0]} = add.([0, 0])
diff --git a/test/errors_test.exs b/test/errors_test.exs
index 2f9722e..25d5fcb 100644
--- a/test/errors_test.exs
+++ b/test/errors_test.exs
@@ -140,11 +140,12 @@ defmodule Firebird.WasmErrorTest do
     end
 
     test "can be caught with rescue" do
-      result = try do
-        raise Firebird.WasmError.load_failed(:bad)
-      rescue
-        e in Firebird.WasmError -> {:caught, e.reason}
-      end
+      result =
+        try do
+          raise Firebird.WasmError.load_failed(:bad)
+        rescue
+          e in Firebird.WasmError -> {:caught, e.reason}
+        end
 
       assert {:caught, :bad} = result
     end
diff --git a/test/firebird/api_completeness_test.exs b/test/firebird/api_completeness_test.exs
index fcd9fef..d2f8373 100644
--- a/test/firebird/api_completeness_test.exs
+++ b/test/firebird/api_completeness_test.exs
@@ -42,10 +42,12 @@ defmodule Firebird.APICompletenessTest do
     end
 
     test "call_many/2", %{pid: pid} do
-      {:ok, results} = Firebird.call_many(pid, [
-        {:add, [1, 2]},
-        {:multiply, [3, 4]}
-      ])
+      {:ok, results} =
+        Firebird.call_many(pid, [
+          {:add, [1, 2]},
+          {:multiply, [3, 4]}
+        ])
+
       assert results == [[3], [12]]
     end
 
@@ -131,10 +133,12 @@ defmodule Firebird.APICompletenessTest do
     end
 
     test "with_instance/2" do
-      {:ok, result} = Firebird.with_instance(@math_wasm, fn wasm ->
-        {:ok, [r]} = Firebird.call(wasm, :add, [10, 20])
-        r
-      end)
+      {:ok, result} =
+        Firebird.with_instance(@math_wasm, fn wasm ->
+          {:ok, [r]} = Firebird.call(wasm, :add, [10, 20])
+          r
+        end)
+
       assert result == 30
     end
 
diff --git a/test/firebird/api_comprehensive_test.exs b/test/firebird/api_comprehensive_test.exs
index eff60d5..0ad474f 100644
--- a/test/firebird/api_comprehensive_test.exs
+++ b/test/firebird/api_comprehensive_test.exs
@@ -453,9 +453,10 @@ defmodule Firebird.ApiComprehensiveTest do
     end
 
     test "passes working instance to block" do
-      assert {:ok, true} = Firebird.with_instance(@math_wasm, fn pid ->
-        Firebird.function_exists?(pid, :add)
-      end)
+      assert {:ok, true} =
+               Firebird.with_instance(@math_wasm, fn pid ->
+                 Firebird.function_exists?(pid, :add)
+               end)
     end
 
     test "instance is dead after block completes" do
diff --git a/test/firebird/check_test.exs b/test/firebird/check_test.exs
index 78ece66..4a001c2 100644
--- a/test/firebird/check_test.exs
+++ b/test/firebird/check_test.exs
@@ -37,9 +37,10 @@ defmodule Firebird.CheckTest do
     end
 
     test "prints expected output" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Firebird.demo()
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Firebird.demo()
+        end)
 
       assert output =~ "Firebird Demo"
       assert output =~ "add(5, 3) = 8"
diff --git a/test/firebird/convenience_api_test.exs b/test/firebird/convenience_api_test.exs
index 0b3f6a7..101ae41 100644
--- a/test/firebird/convenience_api_test.exs
+++ b/test/firebird/convenience_api_test.exs
@@ -10,18 +10,19 @@ defmodule Firebird.ConvenienceApiTest do
 
     test "returns error for missing file" do
       assert {:error, {:file_error, :enoent, _}} =
-        Firebird.load_priv(:firebird, "wasm/nonexistent.wasm")
+               Firebird.load_priv(:firebird, "wasm/nonexistent.wasm")
     end
   end
 
   describe "playground/0" do
     test "returns a working WASM instance" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        wasm = Firebird.playground()
-        assert Process.alive?(wasm)
-        assert {:ok, [8]} = Firebird.call(wasm, :add, [5, 3])
-        Firebird.stop(wasm)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          wasm = Firebird.playground()
+          assert Process.alive?(wasm)
+          assert {:ok, [8]} = Firebird.call(wasm, :add, [5, 3])
+          Firebird.stop(wasm)
+        end)
 
       assert output =~ "playground ready"
     end
@@ -35,6 +36,7 @@ defmodule Firebird.ConvenienceApiTest do
           i32.const 42)
       )
       """
+
       {:ok, wasm} = Firebird.from_wat(wat)
       assert {:ok, [42]} = Firebird.call(wasm, :answer, [])
       Firebird.stop(wasm)
@@ -43,10 +45,11 @@ defmodule Firebird.ConvenienceApiTest do
 
   describe "with_instance/3" do
     test "auto-cleans up after block" do
-      {:ok, result} = Firebird.with_instance("fixtures/math.wasm", fn wasm ->
-        {:ok, [sum]} = Firebird.call(wasm, :add, [10, 20])
-        sum
-      end)
+      {:ok, result} =
+        Firebird.with_instance("fixtures/math.wasm", fn wasm ->
+          {:ok, [sum]} = Firebird.call(wasm, :add, [10, 20])
+          sum
+        end)
 
       assert result == 30
     end
diff --git a/test/firebird/convenience_extended_test.exs b/test/firebird/convenience_extended_test.exs
index 0b4fd45..d9f70ae 100644
--- a/test/firebird/convenience_extended_test.exs
+++ b/test/firebird/convenience_extended_test.exs
@@ -64,9 +64,10 @@ defmodule Firebird.ConvenienceExtendedTest do
 
   describe "with_instance/3 edge cases" do
     test "returns error when file not found" do
-      assert {:error, _} = Firebird.with_instance("/nonexistent.wasm", fn _wasm ->
-        :should_not_reach
-      end)
+      assert {:error, _} =
+               Firebird.with_instance("/nonexistent.wasm", fn _wasm ->
+                 :should_not_reach
+               end)
     end
 
     test "cleans up even if block raises" do
@@ -79,10 +80,12 @@ defmodule Firebird.ConvenienceExtendedTest do
     end
 
     test "can pass options" do
-      {:ok, result} = Firebird.with_instance(@math_wasm, fn wasm ->
-        {:ok, [sum]} = Firebird.call(wasm, :add, [100, 200])
-        sum
-      end)
+      {:ok, result} =
+        Firebird.with_instance(@math_wasm, fn wasm ->
+          {:ok, [sum]} = Firebird.call(wasm, :add, [100, 200])
+          sum
+        end)
+
       assert result == 300
     end
   end
@@ -91,9 +94,11 @@ defmodule Firebird.ConvenienceExtendedTest do
     test "cleans up instance after successful call" do
       # Run should not leak processes
       initial_count = length(Process.list())
+
       for _ <- 1..5 do
         {:ok, [_]} = Firebird.run(@math_wasm, :add, [1, 2])
       end
+
       # Allow some slack for GC
       Process.sleep(50)
       final_count = length(Process.list())
diff --git a/test/firebird/convenience_test.exs b/test/firebird/convenience_test.exs
index f079156..e97ead5 100644
--- a/test/firebird/convenience_test.exs
+++ b/test/firebird/convenience_test.exs
@@ -58,11 +58,12 @@ defmodule Firebird.ConvenienceTest do
 
   describe "with_instance/3" do
     test "provides instance to block and cleans up" do
-      assert {:ok, 16} = Firebird.with_instance(@math_wasm, fn instance ->
-        {:ok, [a]} = Firebird.call(instance, :add, [5, 3])
-        {:ok, [b]} = Firebird.call(instance, :multiply, [a, 2])
-        b
-      end)
+      assert {:ok, 16} =
+               Firebird.with_instance(@math_wasm, fn instance ->
+                 {:ok, [a]} = Firebird.call(instance, :add, [5, 3])
+                 {:ok, [b]} = Firebird.call(instance, :multiply, [a, 2])
+                 b
+               end)
     end
 
     test "cleans up even if block raises" do
@@ -74,18 +75,21 @@ defmodule Firebird.ConvenienceTest do
     end
 
     test "returns error for bad file" do
-      assert {:error, _} = Firebird.with_instance("/nonexistent.wasm", fn _instance ->
-        :should_not_reach
-      end)
+      assert {:error, _} =
+               Firebird.with_instance("/nonexistent.wasm", fn _instance ->
+                 :should_not_reach
+               end)
     end
 
     test "allows multiple calls within block" do
-      assert {:ok, results} = Firebird.with_instance(@math_wasm, fn instance ->
-        for n <- [5, 10, 15] do
-          {:ok, [result]} = Firebird.call(instance, :fibonacci, [n])
-          result
-        end
-      end)
+      assert {:ok, results} =
+               Firebird.with_instance(@math_wasm, fn instance ->
+                 for n <- [5, 10, 15] do
+                   {:ok, [result]} = Firebird.call(instance, :fibonacci, [n])
+                   result
+                 end
+               end)
+
       assert results == [5, 55, 610]
     end
   end
diff --git a/test/firebird/describe_test.exs b/test/firebird/describe_test.exs
index ec97b3b..79378b7 100644
--- a/test/firebird/describe_test.exs
+++ b/test/firebird/describe_test.exs
@@ -3,9 +3,10 @@ defmodule Firebird.DescribeTest do
 
   describe "describe/1 with file path" do
     test "prints summary of a WASM file" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe("fixtures/math.wasm")
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe("fixtures/math.wasm")
+        end)
 
       assert output =~ "math.wasm"
       assert output =~ "Functions"
@@ -21,9 +22,10 @@ defmodule Firebird.DescribeTest do
     end
 
     test "prints summary of a running instance", %{wasm: wasm} do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe(wasm)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe(wasm)
+        end)
 
       assert output =~ "alive"
       assert output =~ "Memory"
@@ -34,9 +36,10 @@ defmodule Firebird.DescribeTest do
 
   describe "describe/1 with invalid path" do
     test "handles missing file gracefully" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe("nonexistent.wasm")
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe("nonexistent.wasm")
+        end)
 
       assert output =~ "Cannot inspect"
     end
diff --git a/test/firebird/dx_integration_test.exs b/test/firebird/dx_integration_test.exs
index daa04f9..81cdede 100644
--- a/test/firebird/dx_integration_test.exs
+++ b/test/firebird/dx_integration_test.exs
@@ -24,13 +24,15 @@ defmodule Firebird.DxIntegrationTest do
 
   describe "WAT inline workflow" do
     test "write and run WASM inline" do
-      wasm = Firebird.from_wat!("""
-      (module
-        (func (export "greet") (result i32) i32.const 42)
-        (func (export "add") (param i32 i32) (result i32)
-          local.get 0 local.get 1 i32.add)
-      )
-      """)
+      wasm =
+        Firebird.from_wat!("""
+        (module
+          (func (export "greet") (result i32) i32.const 42)
+          (func (export "add") (param i32 i32) (result i32)
+            local.get 0 local.get 1 i32.add)
+        )
+        """)
+
       assert [42] = Firebird.call!(wasm, :greet, [])
       assert [15] = Firebird.call!(wasm, :add, [7, 8])
       Firebird.stop(wasm)
@@ -73,11 +75,13 @@ defmodule Firebird.DxIntegrationTest do
 
   describe "with_instance workflow" do
     test "auto cleanup after block" do
-      {:ok, result} = Firebird.with_instance("fixtures/math.wasm", fn wasm ->
-        {:ok, [a]} = Firebird.call(wasm, :add, [5, 3])
-        {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 2])
-        b
-      end)
+      {:ok, result} =
+        Firebird.with_instance("fixtures/math.wasm", fn wasm ->
+          {:ok, [a]} = Firebird.call(wasm, :add, [5, 3])
+          {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 2])
+          b
+        end)
+
       assert result == 16
     end
   end
@@ -85,22 +89,27 @@ defmodule Firebird.DxIntegrationTest do
   describe "error handling" do
     test "missing file gives helpful error" do
       assert {:error, {:file_error, :enoent, "nonexistent.wasm"}} =
-        Firebird.load("nonexistent.wasm")
+               Firebird.load("nonexistent.wasm")
     end
 
     test "load! gives suggestion for missing file" do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.load!("nonexistent.wasm")
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.load!("nonexistent.wasm")
+        end
+
       assert error.message =~ "WASM file not found"
       assert error.message =~ "priv/wasm/"
     end
 
     test "calling non-existent function gives helpful error" do
       {:ok, wasm} = Firebird.load("fixtures/math.wasm")
-      error = assert_raise RuntimeError, fn ->
-        Firebird.call!(wasm, :nonexistent, [1])
-      end
+
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.call!(wasm, :nonexistent, [1])
+        end
+
       assert error.message =~ "Available functions"
       Firebird.stop(wasm)
     end
@@ -108,9 +117,11 @@ defmodule Firebird.DxIntegrationTest do
 
   describe "introspection" do
     test "describe prints useful info" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Firebird.describe("fixtures/math.wasm")
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Firebird.describe("fixtures/math.wasm")
+        end)
+
       assert output =~ "math.wasm"
       assert output =~ "add"
     end
diff --git a/test/firebird/dx_test.exs b/test/firebird/dx_test.exs
index b76e8b6..da32c80 100644
--- a/test/firebird/dx_test.exs
+++ b/test/firebird/dx_test.exs
@@ -96,7 +96,7 @@ defmodule Firebird.DXTest do
   describe "helpful error messages" do
     test "file not found gives clear error" do
       assert {:error, {:file_error, :enoent, "/nonexistent.wasm"}} =
-        Firebird.load("/nonexistent.wasm")
+               Firebird.load("/nonexistent.wasm")
     end
 
     test "load! gives clear raise message" do
@@ -192,18 +192,21 @@ defmodule Firebird.DXTest do
 
   describe "with_instance block API" do
     test "auto-cleanup after block" do
-      {:ok, 8} = Firebird.with_instance(@math_wasm, fn instance ->
-        {:ok, [result]} = Firebird.call(instance, :add, [5, 3])
-        result
-      end)
+      {:ok, 8} =
+        Firebird.with_instance(@math_wasm, fn instance ->
+          {:ok, [result]} = Firebird.call(instance, :add, [5, 3])
+          result
+        end)
     end
 
     test "chains multiple calls" do
-      {:ok, result} = Firebird.with_instance(@math_wasm, fn wasm ->
-        {:ok, [a]} = Firebird.call(wasm, :add, [10, 20])
-        {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 2])
-        b
-      end)
+      {:ok, result} =
+        Firebird.with_instance(@math_wasm, fn wasm ->
+          {:ok, [a]} = Firebird.call(wasm, :add, [10, 20])
+          {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 2])
+          b
+        end)
+
       assert result == 60
     end
   end
@@ -227,22 +230,28 @@ defmodule Firebird.DXTest do
   describe "batch operations" do
     test "call_many runs multiple calls" do
       {:ok, pid} = Firebird.load(@math_wasm)
-      {:ok, results} = Firebird.call_many(pid, [
-        {:add, [1, 2]},
-        {:multiply, [3, 4]},
-        {:fibonacci, [10]}
-      ])
+
+      {:ok, results} =
+        Firebird.call_many(pid, [
+          {:add, [1, 2]},
+          {:multiply, [3, 4]},
+          {:fibonacci, [10]}
+        ])
+
       assert results == [[3], [12], [55]]
       Firebird.stop(pid)
     end
 
     test "call_many stops on first error" do
       {:ok, pid} = Firebird.load(@math_wasm)
-      result = Firebird.call_many(pid, [
-        {:add, [1, 2]},
-        {:nonexistent, [1]},
-        {:multiply, [3, 4]}
-      ])
+
+      result =
+        Firebird.call_many(pid, [
+          {:add, [1, 2]},
+          {:nonexistent, [1]},
+          {:multiply, [3, 4]}
+        ])
+
       assert {:error, _} = result
       Firebird.stop(pid)
     end
diff --git a/test/firebird/error_messages_test.exs b/test/firebird/error_messages_test.exs
index 7e27ae3..2745c6e 100644
--- a/test/firebird/error_messages_test.exs
+++ b/test/firebird/error_messages_test.exs
@@ -6,9 +6,10 @@ defmodule Firebird.ErrorMessagesTest do
 
   describe "load! error messages" do
     test "file not found includes path and suggestions" do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.load!("/tmp/missing_module.wasm")
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.load!("/tmp/missing_module.wasm")
+        end
 
       assert error.message =~ "not found"
       assert error.message =~ "missing_module.wasm"
@@ -16,9 +17,10 @@ defmodule Firebird.ErrorMessagesTest do
     end
 
     test "invalid wasm bytes gives useful message" do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.load!(<<0, 97, 115, 109, 0, 0, 0, 0>>)
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.load!(<<0, 97, 115, 109, 0, 0, 0, 0>>)
+        end
 
       assert error.message =~ "Failed to load"
     end
@@ -27,7 +29,7 @@ defmodule Firebird.ErrorMessagesTest do
   describe "load error tuples" do
     test "file not found returns structured error" do
       assert {:error, {:file_error, :enoent, "/nonexistent.wasm"}} =
-        Firebird.load("/nonexistent.wasm")
+               Firebird.load("/nonexistent.wasm")
     end
 
     test "load_file with nonexistent path returns structured error" do
diff --git a/test/firebird/error_suggestions_test.exs b/test/firebird/error_suggestions_test.exs
index 7c81c82..d7b9380 100644
--- a/test/firebird/error_suggestions_test.exs
+++ b/test/firebird/error_suggestions_test.exs
@@ -9,18 +9,20 @@ defmodule Firebird.ErrorSuggestionsTest do
 
   describe "call! error messages" do
     test "suggests similar function names on typo", %{wasm: wasm} do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.call!(wasm, :ad, [5, 3])
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.call!(wasm, :ad, [5, 3])
+        end
 
       assert error.message =~ "Available functions"
       assert error.message =~ "add"
     end
 
     test "lists available functions when function not found", %{wasm: wasm} do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.call!(wasm, :nonexistent_function, [1])
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.call!(wasm, :nonexistent_function, [1])
+        end
 
       assert error.message =~ "Available functions"
     end
@@ -28,9 +30,10 @@ defmodule Firebird.ErrorSuggestionsTest do
 
   describe "load! error messages" do
     test "suggests common locations for missing files" do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.load!("nonexistent.wasm")
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.load!("nonexistent.wasm")
+        end
 
       assert error.message =~ "WASM file not found"
       assert error.message =~ "priv/wasm/"
@@ -41,7 +44,7 @@ defmodule Firebird.ErrorSuggestionsTest do
       # We can't easily test this without a module that requires WASI imports
       # but we verify the error path exists
       assert_raise RuntimeError, ~r/WASM file not found|Failed to load/, fn ->
-        Firebird.load!("/tmp/definitely_does_not_exist_#{:rand.uniform(999999)}.wasm")
+        Firebird.load!("/tmp/definitely_does_not_exist_#{:rand.uniform(999_999)}.wasm")
       end
     end
   end
diff --git a/test/firebird/full_flow_test.exs b/test/firebird/full_flow_test.exs
index 206053d..f47b7dc 100644
--- a/test/firebird/full_flow_test.exs
+++ b/test/firebird/full_flow_test.exs
@@ -38,10 +38,12 @@ defmodule Firebird.FullFlowTest do
       assert {:ok, [120]} = Firebird.call(wasm, :factorial, [5])
 
       # 5. Batch call
-      {:ok, results} = Firebird.call_many(wasm, [
-        {:add, [1, 2]},
-        {:multiply, [3, 4]}
-      ])
+      {:ok, results} =
+        Firebird.call_many(wasm, [
+          {:add, [1, 2]},
+          {:multiply, [3, 4]}
+        ])
+
       assert results == [[3], [12]]
 
       # 6. Clean up
@@ -52,11 +54,13 @@ defmodule Firebird.FullFlowTest do
 
   describe "Flow 3: block API" do
     test "with_instance auto-cleanup" do
-      {:ok, result} = Firebird.with_instance(@math_wasm, fn wasm ->
-        {:ok, [a]} = Firebird.call(wasm, :add, [10, 20])
-        {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 3])
-        b
-      end)
+      {:ok, result} =
+        Firebird.with_instance(@math_wasm, fn wasm ->
+          {:ok, [a]} = Firebird.call(wasm, :add, [10, 20])
+          {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 3])
+          b
+        end)
+
       assert result == 90
     end
   end
@@ -66,6 +70,7 @@ defmodule Firebird.FullFlowTest do
       children = [
         {Firebird.Pool, wasm: @math_wasm, size: 2, name: :flow_test_pool}
       ]
+
       {:ok, sup} = Supervisor.start_link(children, strategy: :one_for_one)
 
       # Use the pool
@@ -73,12 +78,14 @@ defmodule Firebird.FullFlowTest do
       assert [8] = Firebird.Pool.call!(:flow_test_pool, :add, [5, 3])
 
       # Concurrent access
-      tasks = for i <- 1..10 do
-        Task.async(fn ->
-          [result] = Firebird.Pool.call!(:flow_test_pool, :add, [i, i])
-          result
-        end)
-      end
+      tasks =
+        for i <- 1..10 do
+          Task.async(fn ->
+            [result] = Firebird.Pool.call!(:flow_test_pool, :add, [i, i])
+            result
+          end)
+        end
+
       results = Task.await_many(tasks)
       assert results == Enum.map(1..10, &(&1 * 2))
 
diff --git a/test/firebird/inspector_gen_test.exs b/test/firebird/inspector_gen_test.exs
index c7ddb11..6e23a23 100644
--- a/test/firebird/inspector_gen_test.exs
+++ b/test/firebird/inspector_gen_test.exs
@@ -21,7 +21,7 @@ defmodule Firebird.InspectorGenTest do
 
     test "returns error for nonexistent file" do
       assert {:error, {:file_error, :enoent}} =
-        Firebird.Inspector.inspect_file("/nonexistent.wasm")
+               Firebird.Inspector.inspect_file("/nonexistent.wasm")
     end
   end
 
@@ -36,7 +36,8 @@ defmodule Firebird.InspectorGenTest do
     end
 
     test "generates wasm_module style" do
-      code = Firebird.Inspector.generate_module("TestInspector.Math2", @math_wasm, style: :wasm_module)
+      code =
+        Firebird.Inspector.generate_module("TestInspector.Math2", @math_wasm, style: :wasm_module)
 
       assert code =~ "defmodule TestInspector.Math2"
       assert code =~ "use Firebird.WasmModule"
diff --git a/test/firebird/module_auto_test.exs b/test/firebird/module_auto_test.exs
index 646d7b6..e8d2351 100644
--- a/test/firebird/module_auto_test.exs
+++ b/test/firebird/module_auto_test.exs
@@ -9,6 +9,7 @@ defmodule Firebird.ModuleAutoTest do
 
   setup do
     {:ok, _pid} = AutoMath.start_link()
+
     on_exit(fn ->
       try do
         AutoMath.stop()
@@ -16,6 +17,7 @@ defmodule Firebird.ModuleAutoTest do
         :exit, _ -> :ok
       end
     end)
+
     :ok
   end
 
diff --git a/test/firebird/module_validation_test.exs b/test/firebird/module_validation_test.exs
index 5d8203d..61ba670 100644
--- a/test/firebird/module_validation_test.exs
+++ b/test/firebird/module_validation_test.exs
@@ -8,33 +8,37 @@ defmodule Firebird.ModuleValidationTest do
     use Firebird.Module, wasm: Path.expand("../../fixtures/math.wasm", __DIR__)
 
     wasm_fn :add, args: 2
-    wasm_fn :nonexistent_function, args: 1  # This doesn't exist!
+    # This doesn't exist!
+    wasm_fn :nonexistent_function, args: 1
   end
 
   describe "module validation" do
     test "warns when declared function is not in WASM exports" do
-      log = capture_log(fn ->
-        {:ok, _pid} = MismatchedModule.start_link(name: :validation_test_1)
-        MismatchedModule.stop(name: :validation_test_1)
-      end)
+      log =
+        capture_log(fn ->
+          {:ok, _pid} = MismatchedModule.start_link(name: :validation_test_1)
+          MismatchedModule.stop(name: :validation_test_1)
+        end)
 
       assert log =~ "nonexistent_function"
       assert log =~ "not found"
     end
 
     test "valid functions still work despite warning" do
-      _log = capture_log(fn ->
-        {:ok, _pid} = MismatchedModule.start_link(name: :validation_test_2)
-        assert {:ok, [8]} = MismatchedModule.call(:add, [5, 3], name: :validation_test_2)
-        MismatchedModule.stop(name: :validation_test_2)
-      end)
+      _log =
+        capture_log(fn ->
+          {:ok, _pid} = MismatchedModule.start_link(name: :validation_test_2)
+          assert {:ok, [8]} = MismatchedModule.call(:add, [5, 3], name: :validation_test_2)
+          MismatchedModule.stop(name: :validation_test_2)
+        end)
     end
 
     test "can disable validation" do
-      log = capture_log(fn ->
-        {:ok, _pid} = MismatchedModule.start_link(name: :validation_test_3, validate: false)
-        MismatchedModule.stop(name: :validation_test_3)
-      end)
+      log =
+        capture_log(fn ->
+          {:ok, _pid} = MismatchedModule.start_link(name: :validation_test_3, validate: false)
+          MismatchedModule.stop(name: :validation_test_3)
+        end)
 
       refute log =~ "nonexistent_function"
     end
@@ -47,11 +51,12 @@ defmodule Firebird.ModuleValidationTest do
     end
 
     test "gives clear error when WASM file is missing" do
-      log = capture_log(fn ->
-        Process.flag(:trap_exit, true)
-        result = MissingFileModule.start_link(name: :missing_file_test)
-        assert match?({:error, _}, result)
-      end)
+      log =
+        capture_log(fn ->
+          Process.flag(:trap_exit, true)
+          result = MissingFileModule.start_link(name: :missing_file_test)
+          assert match?({:error, _}, result)
+        end)
 
       assert log =~ "not found"
     end
diff --git a/test/firebird/pool_dx_test.exs b/test/firebird/pool_dx_test.exs
index 7d40993..2ddaa82 100644
--- a/test/firebird/pool_dx_test.exs
+++ b/test/firebird/pool_dx_test.exs
@@ -67,7 +67,10 @@ defmodule Firebird.PoolDXTest do
     test "returns valid child spec" do
       spec = Firebird.Pool.child_spec(wasm: @math_wasm, size: 2, name: :test_pool)
       assert spec.id == :test_pool
-      assert spec.start == {Firebird.Pool, :start_link, [[wasm: @math_wasm, size: 2, name: :test_pool]]}
+
+      assert spec.start ==
+               {Firebird.Pool, :start_link, [[wasm: @math_wasm, size: 2, name: :test_pool]]}
+
       assert spec.type == :worker
     end
 
@@ -80,6 +83,7 @@ defmodule Firebird.PoolDXTest do
       children = [
         {Firebird.Pool, wasm: @math_wasm, size: 2, name: :supervised_pool}
       ]
+
       {:ok, sup} = Supervisor.start_link(children, strategy: :one_for_one)
 
       assert {:ok, [8]} = Firebird.Pool.call(:supervised_pool, :add, [5, 3])
@@ -93,12 +97,13 @@ defmodule Firebird.PoolDXTest do
     test "handles concurrent calls" do
       {:ok, pool} = Firebird.Pool.start_link(wasm: @math_wasm, size: 4)
 
-      tasks = for i <- 1..20 do
-        Task.async(fn ->
-          {:ok, [result]} = Firebird.Pool.call(pool, :add, [i, i])
-          result
-        end)
-      end
+      tasks =
+        for i <- 1..20 do
+          Task.async(fn ->
+            {:ok, [result]} = Firebird.Pool.call(pool, :add, [i, i])
+            result
+          end)
+        end
 
       results = Task.await_many(tasks)
       expected = for i <- 1..20, do: i * 2
diff --git a/test/firebird_api_boundary_test.exs b/test/firebird_api_boundary_test.exs
index 3eeebb2..710b2ae 100644
--- a/test/firebird_api_boundary_test.exs
+++ b/test/firebird_api_boundary_test.exs
@@ -135,22 +135,34 @@ defmodule Firebird.ApiBoundaryTest do
     end
 
     test "with inline WAT source" do
-      result = Firebird.quick("""
-      (module
-        (func (export "double") (param i32) (result i32)
-          local.get 0
-          i32.const 2
-          i32.mul))
-      """, :double, [21])
+      result =
+        Firebird.quick(
+          """
+          (module
+            (func (export "double") (param i32) (result i32)
+              local.get 0
+              i32.const 2
+              i32.mul))
+          """,
+          :double,
+          [21]
+        )
+
       assert result == 42
     end
 
     test "with minimal WAT module" do
-      result = Firebird.quick("""
-      (module
-        (func (export "answer") (result i32)
-          i32.const 99))
-      """, :answer, [])
+      result =
+        Firebird.quick(
+          """
+          (module
+            (func (export "answer") (result i32)
+              i32.const 99))
+          """,
+          :answer,
+          []
+        )
+
       assert result == 99
     end
 
@@ -172,18 +184,22 @@ defmodule Firebird.ApiBoundaryTest do
   # ===========================================================================
   describe "with_instance/3" do
     test "returns {:ok, result} on success" do
-      {:ok, result} = Firebird.with_instance(@rust_wasm, fn pid ->
-        {:ok, [sum]} = Firebird.call(pid, :add, [10, 20])
-        sum
-      end)
+      {:ok, result} =
+        Firebird.with_instance(@rust_wasm, fn pid ->
+          {:ok, [sum]} = Firebird.call(pid, :add, [10, 20])
+          sum
+        end)
+
       assert result == 30
     end
 
     test "cleans up instance after callback" do
-      {:ok, _} = Firebird.with_instance(@rust_wasm, fn pid ->
-        assert Process.alive?(pid)
-        :done
-      end)
+      {:ok, _} =
+        Firebird.with_instance(@rust_wasm, fn pid ->
+          assert Process.alive?(pid)
+          :done
+        end)
+
       # Instance should be stopped (can't easily verify this without capturing pid)
     end
 
@@ -207,19 +223,24 @@ defmodule Firebird.ApiBoundaryTest do
           raise "test cleanup"
         end)
       end
+
       # No dangling processes
     end
 
     test "nested with_instance calls work" do
-      {:ok, result} = Firebird.with_instance(@rust_wasm, fn pid1 ->
-        {:ok, [a]} = Firebird.call(pid1, :add, [5, 3])
+      {:ok, result} =
+        Firebird.with_instance(@rust_wasm, fn pid1 ->
+          {:ok, [a]} = Firebird.call(pid1, :add, [5, 3])
 
-        {:ok, inner} = Firebird.with_instance(@rust_wasm, fn pid2 ->
-          {:ok, [b]} = Firebird.call(pid2, :multiply, [a, 2])
-          b
+          {:ok, inner} =
+            Firebird.with_instance(@rust_wasm, fn pid2 ->
+              {:ok, [b]} = Firebird.call(pid2, :multiply, [a, 2])
+              b
+            end)
+
+          inner
         end)
-        inner
-      end)
+
       assert result == 16
     end
 
@@ -231,10 +252,16 @@ defmodule Firebird.ApiBoundaryTest do
     end
 
     test "with_instance with Go WASM" do
-      {:ok, result} = Firebird.with_instance(@go_wasm, fn pid ->
-        {:ok, [sum]} = Firebird.call(pid, :add, [100, 200])
-        sum
-      end, wasi: true)
+      {:ok, result} =
+        Firebird.with_instance(
+          @go_wasm,
+          fn pid ->
+            {:ok, [sum]} = Firebird.call(pid, :add, [100, 200])
+            sum
+          end,
+          wasi: true
+        )
+
       assert result == 300
     end
   end
@@ -297,7 +324,10 @@ defmodule Firebird.ApiBoundaryTest do
     end
 
     test "returns error for non-WASM binary" do
-      assert {:error, _} = Firebird.validate("this is definitely not WASM data, it is too long to be mistaken")
+      assert {:error, _} =
+               Firebird.validate(
+                 "this is definitely not WASM data, it is too long to be mistaken"
+               )
     end
 
     test "returns error for truncated WASM" do
@@ -400,10 +430,13 @@ defmodule Firebird.ApiBoundaryTest do
     end
 
     test "raises with suggestion for similar function name", %{wasm: pid} do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.call_one!(pid, :addd, [5, 3])
-      end
-      assert error.message =~ "Did you mean" or error.message =~ "not found" or error.message =~ "Available"
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.call_one!(pid, :addd, [5, 3])
+        end
+
+      assert error.message =~ "Did you mean" or error.message =~ "not found" or
+               error.message =~ "Available"
     end
 
     test "raises for completely different function name", %{wasm: pid} do
diff --git a/test/firebird_api_coverage_test.exs b/test/firebird_api_coverage_test.exs
index fee7e0f..68e726d 100644
--- a/test/firebird_api_coverage_test.exs
+++ b/test/firebird_api_coverage_test.exs
@@ -120,9 +120,10 @@ defmodule Firebird.APICoverageTest do
     test "prints instance description" do
       {:ok, instance} = Firebird.load(@math_wasm)
 
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe(instance)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe(instance)
+        end)
 
       assert output =~ "WASM Instance"
       assert output =~ "alive"
@@ -135,9 +136,10 @@ defmodule Firebird.APICoverageTest do
     test "shows function signatures" do
       {:ok, instance} = Firebird.load(@math_wasm)
 
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Firebird.describe(instance)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Firebird.describe(instance)
+        end)
 
       assert output =~ "add"
       Firebird.stop(instance)
@@ -146,18 +148,20 @@ defmodule Firebird.APICoverageTest do
 
   describe "Firebird.describe/1 with file path" do
     test "prints file description" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe(@math_wasm)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe(@math_wasm)
+        end)
 
       assert output =~ "math.wasm"
       assert output =~ "Functions"
     end
 
     test "handles nonexistent file gracefully" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe("nonexistent.wasm")
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe("nonexistent.wasm")
+        end)
 
       assert output =~ "Cannot inspect" or output =~ "❌"
     end
@@ -222,20 +226,32 @@ defmodule Firebird.APICoverageTest do
     end
 
     test "quick with inline WAT" do
-      result = Firebird.quick("""
-      (module
-        (func (export "answer") (result i32)
-          i32.const 42))
-      """, "answer", [])
+      result =
+        Firebird.quick(
+          """
+          (module
+            (func (export "answer") (result i32)
+              i32.const 42))
+          """,
+          "answer",
+          []
+        )
+
       assert result == 42
     end
 
     test "quick with inline WAT and args" do
-      result = Firebird.quick("""
-      (module
-        (func (export "add") (param i32 i32) (result i32)
-          local.get 0 local.get 1 i32.add))
-      """, "add", [10, 20])
+      result =
+        Firebird.quick(
+          """
+          (module
+            (func (export "add") (param i32 i32) (result i32)
+              local.get 0 local.get 1 i32.add))
+          """,
+          "add",
+          [10, 20]
+        )
+
       assert result == 30
     end
 
@@ -252,10 +268,11 @@ defmodule Firebird.APICoverageTest do
 
   describe "Firebird.with_instance/3" do
     test "provides instance and auto-cleans up" do
-      {:ok, result} = Firebird.with_instance(@math_wasm, fn instance ->
-        {:ok, [sum]} = Firebird.call(instance, :add, [5, 3])
-        sum
-      end)
+      {:ok, result} =
+        Firebird.with_instance(@math_wasm, fn instance ->
+          {:ok, [sum]} = Firebird.call(instance, :add, [5, 3])
+          sum
+        end)
 
       assert result == 8
     end
@@ -263,10 +280,11 @@ defmodule Firebird.APICoverageTest do
     test "instance is stopped after block" do
       pid_ref = make_ref()
 
-      {:ok, _pid} = Firebird.with_instance(@math_wasm, fn instance ->
-        send(self(), {pid_ref, instance})
-        instance
-      end)
+      {:ok, _pid} =
+        Firebird.with_instance(@math_wasm, fn instance ->
+          send(self(), {pid_ref, instance})
+          instance
+        end)
 
       receive do
         {^pid_ref, instance_pid} ->
@@ -277,11 +295,12 @@ defmodule Firebird.APICoverageTest do
     end
 
     test "chains multiple calls" do
-      {:ok, result} = Firebird.with_instance(@math_wasm, fn w ->
-        {:ok, [a]} = Firebird.call(w, :add, [10, 20])
-        {:ok, [b]} = Firebird.call(w, :multiply, [a, 2])
-        b
-      end)
+      {:ok, result} =
+        Firebird.with_instance(@math_wasm, fn w ->
+          {:ok, [a]} = Firebird.call(w, :add, [10, 20])
+          {:ok, [b]} = Firebird.call(w, :multiply, [a, 2])
+          b
+        end)
 
       assert result == 60
     end
@@ -367,11 +386,13 @@ defmodule Firebird.APICoverageTest do
     end
 
     test "compiles WAT with function" do
-      {:ok, bytes} = Firebird.compile_wat("""
-      (module
-        (func (export "const42") (result i32)
-          i32.const 42))
-      """)
+      {:ok, bytes} =
+        Firebird.compile_wat("""
+        (module
+          (func (export "const42") (result i32)
+            i32.const 42))
+        """)
+
       assert is_binary(bytes)
     end
 
@@ -394,11 +415,12 @@ defmodule Firebird.APICoverageTest do
 
   describe "Firebird.from_wat/2" do
     test "loads instance from WAT source" do
-      {:ok, instance} = Firebird.from_wat("""
-      (module
-        (func (export "double") (param i32) (result i32)
-          local.get 0 i32.const 2 i32.mul))
-      """)
+      {:ok, instance} =
+        Firebird.from_wat("""
+        (module
+          (func (export "double") (param i32) (result i32)
+            local.get 0 i32.const 2 i32.mul))
+        """)
 
       {:ok, [10]} = Firebird.call(instance, :double, [5])
       Firebird.stop(instance)
@@ -409,12 +431,13 @@ defmodule Firebird.APICoverageTest do
     end
 
     test "loads WAT with memory" do
-      {:ok, instance} = Firebird.from_wat("""
-      (module
-        (memory (export "memory") 1)
-        (func (export "load_i32") (param i32) (result i32)
-          local.get 0 i32.load))
-      """)
+      {:ok, instance} =
+        Firebird.from_wat("""
+        (module
+          (memory (export "memory") 1)
+          (func (export "load_i32") (param i32) (result i32)
+            local.get 0 i32.load))
+        """)
 
       assert Process.alive?(instance)
       Firebird.stop(instance)
@@ -423,10 +446,11 @@ defmodule Firebird.APICoverageTest do
 
   describe "Firebird.from_wat!/2" do
     test "returns pid directly" do
-      instance = Firebird.from_wat!("""
-      (module
-        (func (export "id") (param i32) (result i32) local.get 0))
-      """)
+      instance =
+        Firebird.from_wat!("""
+        (module
+          (func (export "id") (param i32) (result i32) local.get 0))
+        """)
 
       assert is_pid(instance)
       {:ok, [42]} = Firebird.call(instance, :id, [42])
@@ -452,11 +476,12 @@ defmodule Firebird.APICoverageTest do
     end
 
     test "calls multiple functions in sequence", %{wasm: w} do
-      {:ok, results} = Firebird.call_many(w, [
-        {:add, [1, 2]},
-        {:multiply, [3, 4]},
-        {:fibonacci, [10]}
-      ])
+      {:ok, results} =
+        Firebird.call_many(w, [
+          {:add, [1, 2]},
+          {:multiply, [3, 4]},
+          {:fibonacci, [10]}
+        ])
 
       assert results == [[3], [12], [55]]
     end
@@ -470,10 +495,11 @@ defmodule Firebird.APICoverageTest do
     end
 
     test "returns error if any call fails", %{wasm: w} do
-      result = Firebird.call_many(w, [
-        {:add, [1, 2]},
-        {:nonexistent, [1]}
-      ])
+      result =
+        Firebird.call_many(w, [
+          {:add, [1, 2]},
+          {:nonexistent, [1]}
+        ])
 
       # Depending on implementation: might return error at first failure
       # or collect partial results
@@ -1022,13 +1048,14 @@ defmodule Firebird.APICoverageTest do
     end
 
     test "from_wat -> pipeline -> run" do
-      {:ok, instance} = Firebird.from_wat("""
-      (module
-        (func (export "add") (param i32 i32) (result i32)
-          local.get 0 local.get 1 i32.add)
-        (func (export "double") (param i32) (result i32)
-          local.get 0 i32.const 2 i32.mul))
-      """)
+      {:ok, instance} =
+        Firebird.from_wat("""
+        (module
+          (func (export "add") (param i32 i32) (result i32)
+            local.get 0 local.get 1 i32.add)
+          (func (export "double") (param i32) (result i32)
+            local.get 0 i32.const 2 i32.mul))
+        """)
 
       {:ok, [result]} =
         Firebird.pipeline(instance)
diff --git a/test/firebird_api_edge_cases_comprehensive_test.exs b/test/firebird_api_edge_cases_comprehensive_test.exs
index e5f2606..7be5201 100644
--- a/test/firebird_api_edge_cases_comprehensive_test.exs
+++ b/test/firebird_api_edge_cases_comprehensive_test.exs
@@ -15,11 +15,12 @@ defmodule Firebird.ApiEdgeCasesComprehensiveTest do
   # ---------------------------------------------------------------------------
   describe "from_wat/1" do
     test "loads a valid WAT module" do
-      {:ok, wasm} = Firebird.from_wat("""
-      (module
-        (func (export "add") (param i32 i32) (result i32)
-          local.get 0 local.get 1 i32.add))
-      """)
+      {:ok, wasm} =
+        Firebird.from_wat("""
+        (module
+          (func (export "add") (param i32 i32) (result i32)
+            local.get 0 local.get 1 i32.add))
+        """)
 
       assert Process.alive?(wasm)
       assert {:ok, [8]} = Firebird.call(wasm, :add, [5, 3])
@@ -38,15 +39,16 @@ defmodule Firebird.ApiEdgeCasesComprehensiveTest do
     end
 
     test "loads module with multiple functions" do
-      {:ok, wasm} = Firebird.from_wat("""
-      (module
-        (func (export "add") (param i32 i32) (result i32)
-          local.get 0 local.get 1 i32.add)
-        (func (export "sub") (param i32 i32) (result i32)
-          local.get 0 local.get 1 i32.sub)
-        (func (export "const42") (result i32)
-          i32.const 42))
-      """)
+      {:ok, wasm} =
+        Firebird.from_wat("""
+        (module
+          (func (export "add") (param i32 i32) (result i32)
+            local.get 0 local.get 1 i32.add)
+          (func (export "sub") (param i32 i32) (result i32)
+            local.get 0 local.get 1 i32.sub)
+          (func (export "const42") (result i32)
+            i32.const 42))
+        """)
 
       assert {:ok, [8]} = Firebird.call(wasm, :add, [5, 3])
       assert {:ok, [2]} = Firebird.call(wasm, :sub, [5, 3])
@@ -55,12 +57,13 @@ defmodule Firebird.ApiEdgeCasesComprehensiveTest do
     end
 
     test "loads module with memory" do
-      {:ok, wasm} = Firebird.from_wat("""
-      (module
-        (memory (export "memory") 1)
-        (func (export "load_byte") (param i32) (result i32)
-          local.get 0 i32.load8_u))
-      """)
+      {:ok, wasm} =
+        Firebird.from_wat("""
+        (module
+          (memory (export "memory") 1)
+          (func (export "load_byte") (param i32) (result i32)
+            local.get 0 i32.load8_u))
+        """)
 
       assert {:ok, _} = Firebird.call(wasm, :load_byte, [0])
       Firebird.stop(wasm)
@@ -69,11 +72,12 @@ defmodule Firebird.ApiEdgeCasesComprehensiveTest do
 
   describe "from_wat!/1" do
     test "returns pid directly for valid WAT" do
-      wasm = Firebird.from_wat!("""
-      (module
-        (func (export "double") (param i32) (result i32)
-          local.get 0 i32.const 2 i32.mul))
-      """)
+      wasm =
+        Firebird.from_wat!("""
+        (module
+          (func (export "double") (param i32) (result i32)
+            local.get 0 i32.const 2 i32.mul))
+        """)
 
       assert is_pid(wasm)
       assert [10] = Firebird.call!(wasm, :double, [5])
@@ -109,10 +113,11 @@ defmodule Firebird.ApiEdgeCasesComprehensiveTest do
     end
 
     test "compiled bytes are valid WASM" do
-      {:ok, bytes} = Firebird.compile_wat("""
-      (module
-        (func (export "noop")))
-      """)
+      {:ok, bytes} =
+        Firebird.compile_wat("""
+        (module
+          (func (export "noop")))
+        """)
 
       {:ok, wasm} = Firebird.load(bytes)
       assert Process.alive?(wasm)
@@ -121,12 +126,13 @@ defmodule Firebird.ApiEdgeCasesComprehensiveTest do
 
     test "handles large WAT input" do
       # Generate a module with many functions
-      funcs = for i <- 1..20 do
-        """
-        (func (export "f#{i}") (param i32) (result i32)
-          local.get 0 i32.const #{i} i32.add)
-        """
-      end
+      funcs =
+        for i <- 1..20 do
+          """
+          (func (export "f#{i}") (param i32) (result i32)
+            local.get 0 i32.const #{i} i32.add)
+          """
+        end
 
       wat = "(module\n#{Enum.join(funcs, "\n")}\n)"
       {:ok, bytes} = Firebird.compile_wat(wat)
@@ -166,11 +172,12 @@ defmodule Firebird.ApiEdgeCasesComprehensiveTest do
     test "auto-stops instance after block" do
       pid_ref = make_ref()
 
-      {:ok, _} = Firebird.with_instance(@math_wasm, fn instance ->
-        Process.put(pid_ref, instance)
-        {:ok, [8]} = Firebird.call(instance, :add, [5, 3])
-        8
-      end)
+      {:ok, _} =
+        Firebird.with_instance(@math_wasm, fn instance ->
+          Process.put(pid_ref, instance)
+          {:ok, [8]} = Firebird.call(instance, :add, [5, 3])
+          8
+        end)
 
       instance = Process.get(pid_ref)
       # Instance should be stopped after block
@@ -201,11 +208,12 @@ defmodule Firebird.ApiEdgeCasesComprehensiveTest do
     end
 
     test "composes multiple calls" do
-      {:ok, result} = Firebird.with_instance(@math_wasm, fn wasm ->
-        {:ok, [sum]} = Firebird.call(wasm, :add, [10, 20])
-        {:ok, [product]} = Firebird.call(wasm, :multiply, [sum, 3])
-        product
-      end)
+      {:ok, result} =
+        Firebird.with_instance(@math_wasm, fn wasm ->
+          {:ok, [sum]} = Firebird.call(wasm, :add, [10, 20])
+          {:ok, [product]} = Firebird.call(wasm, :multiply, [sum, 3])
+          product
+        end)
 
       assert result == 90
     end
@@ -309,11 +317,12 @@ defmodule Firebird.ApiEdgeCasesComprehensiveTest do
     end
 
     test "executes multiple calls in sequence", %{wasm: wasm} do
-      {:ok, results} = Firebird.call_many(wasm, [
-        {:add, [1, 2]},
-        {:multiply, [3, 4]},
-        {:fibonacci, [10]}
-      ])
+      {:ok, results} =
+        Firebird.call_many(wasm, [
+          {:add, [1, 2]},
+          {:multiply, [3, 4]},
+          {:fibonacci, [10]}
+        ])
 
       assert results == [[3], [12], [55]]
     end
@@ -323,11 +332,12 @@ defmodule Firebird.ApiEdgeCasesComprehensiveTest do
     end
 
     test "returns error if any call fails", %{wasm: wasm} do
-      result = Firebird.call_many(wasm, [
-        {:add, [1, 2]},
-        {:nonexistent, [1]},
-        {:add, [3, 4]}
-      ])
+      result =
+        Firebird.call_many(wasm, [
+          {:add, [1, 2]},
+          {:nonexistent, [1]},
+          {:add, [3, 4]}
+        ])
 
       assert {:error, _} = result
     end
@@ -471,9 +481,10 @@ defmodule Firebird.ApiEdgeCasesComprehensiveTest do
     test "prints info for a running instance" do
       {:ok, wasm} = Firebird.load(@math_wasm)
 
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe(wasm)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe(wasm)
+        end)
 
       assert output =~ "WASM Instance"
       assert output =~ "alive"
@@ -483,18 +494,20 @@ defmodule Firebird.ApiEdgeCasesComprehensiveTest do
     end
 
     test "prints info for a file path" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe(@math_wasm)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe(@math_wasm)
+        end)
 
       assert output =~ "math.wasm"
       assert output =~ "Functions"
     end
 
     test "handles nonexistent file gracefully" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe("/nonexistent/path.wasm")
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe("/nonexistent/path.wasm")
+        end)
 
       assert output =~ "Cannot inspect" or output =~ "❌"
     end
@@ -502,9 +515,10 @@ defmodule Firebird.ApiEdgeCasesComprehensiveTest do
     test "shows function signatures for instance" do
       {:ok, wasm} = Firebird.load(@math_wasm)
 
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Firebird.describe(wasm)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Firebird.describe(wasm)
+        end)
 
       assert output =~ "Exports"
 
@@ -522,7 +536,8 @@ defmodule Firebird.ApiEdgeCasesComprehensiveTest do
 
       case result do
         {:ok, bytes} -> assert is_binary(bytes)
-        {:error, _} -> :ok  # Some runtimes may not support serialization
+        # Some runtimes may not support serialization
+        {:error, _} -> :ok
       end
 
       Firebird.stop(wasm)
@@ -534,11 +549,13 @@ defmodule Firebird.ApiEdgeCasesComprehensiveTest do
   # ---------------------------------------------------------------------------
   describe "memory operations" do
     setup do
-      {:ok, wasm} = Firebird.from_wat("""
-      (module
-        (memory (export "memory") 1)
-        (func (export "noop")))
-      """)
+      {:ok, wasm} =
+        Firebird.from_wat("""
+        (module
+          (memory (export "memory") 1)
+          (func (export "noop")))
+        """)
+
       on_exit(fn -> if Process.alive?(wasm), do: Firebird.stop(wasm) end)
       {:ok, wasm: wasm}
     end
@@ -639,8 +656,10 @@ defmodule Firebird.ApiEdgeCasesComprehensiveTest do
         {:ok, {params, results}} ->
           assert length(params) == 2
           assert length(results) == 1
+
         {:error, _} ->
-          :ok  # Some modules may not expose type info
+          # Some modules may not expose type info
+          :ok
       end
 
       Firebird.stop(wasm)
@@ -653,7 +672,9 @@ defmodule Firebird.ApiEdgeCasesComprehensiveTest do
         {:ok, {params, results}} ->
           assert Enum.all?(params, &(&1 in [:f64, :f32]))
           assert length(results) == 1
-        _ -> :ok
+
+        _ ->
+          :ok
       end
 
       Firebird.stop(wasm)
diff --git a/test/firebird_api_edge_cases_test.exs b/test/firebird_api_edge_cases_test.exs
index b5d091f..5dae1b8 100644
--- a/test/firebird_api_edge_cases_test.exs
+++ b/test/firebird_api_edge_cases_test.exs
@@ -85,27 +85,30 @@ defmodule Firebird.ApiEdgeCasesTest do
 
   describe "Firebird.with_instance/3 edge cases" do
     test "return value is wrapped in {:ok, _}" do
-      assert {:ok, :custom_value} = Firebird.with_instance(@math_wasm, fn _instance ->
-        :custom_value
-      end)
+      assert {:ok, :custom_value} =
+               Firebird.with_instance(@math_wasm, fn _instance ->
+                 :custom_value
+               end)
     end
 
     test "returns complex data structures" do
-      assert {:ok, %{sum: 8, product: 15}} = Firebird.with_instance(@math_wasm, fn instance ->
-        {:ok, [sum]} = Firebird.call(instance, :add, [5, 3])
-        {:ok, [product]} = Firebird.call(instance, :multiply, [3, 5])
-        %{sum: sum, product: product}
-      end)
+      assert {:ok, %{sum: 8, product: 15}} =
+               Firebird.with_instance(@math_wasm, fn instance ->
+                 {:ok, [sum]} = Firebird.call(instance, :add, [5, 3])
+                 {:ok, [product]} = Firebird.call(instance, :multiply, [3, 5])
+                 %{sum: sum, product: product}
+               end)
     end
 
     test "instance is dead after with_instance returns" do
       ref = make_ref()
       test_pid = self()
 
-      {:ok, _} = Firebird.with_instance(@math_wasm, fn instance ->
-        send(test_pid, {ref, instance})
-        :ok
-      end)
+      {:ok, _} =
+        Firebird.with_instance(@math_wasm, fn instance ->
+          send(test_pid, {ref, instance})
+          :ok
+        end)
 
       assert_receive {^ref, instance_pid}
       Process.sleep(100)
@@ -114,18 +117,18 @@ defmodule Firebird.ApiEdgeCasesTest do
 
     test "cleans up on throw" do
       assert catch_throw(
-        Firebird.with_instance(@math_wasm, fn _instance ->
-          throw(:test_throw)
-        end)
-      ) == :test_throw
+               Firebird.with_instance(@math_wasm, fn _instance ->
+                 throw(:test_throw)
+               end)
+             ) == :test_throw
     end
 
     test "cleans up on exit" do
       assert catch_exit(
-        Firebird.with_instance(@math_wasm, fn _instance ->
-          exit(:test_exit)
-        end)
-      ) == :test_exit
+               Firebird.with_instance(@math_wasm, fn _instance ->
+                 exit(:test_exit)
+               end)
+             ) == :test_exit
     end
   end
 
@@ -139,18 +142,20 @@ defmodule Firebird.ApiEdgeCasesTest do
     end
 
     test "suggests similar function name", %{pid: pid} do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.Runtime.call!(pid, :ad, [1, 2])
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.Runtime.call!(pid, :ad, [1, 2])
+        end
 
       # Should mention "add" as suggestion since "ad" is close to "add"
       assert error.message =~ "add" or error.message =~ "Available functions"
     end
 
     test "includes available functions in error", %{pid: pid} do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.Runtime.call!(pid, :totally_unknown, [1])
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.Runtime.call!(pid, :totally_unknown, [1])
+        end
 
       assert error.message =~ "Available functions" or error.message =~ "failed"
     end
@@ -221,7 +226,8 @@ defmodule Firebird.ApiEdgeCasesTest do
       calls = [
         {:add, [1, 2]},
         {:nonexistent, [1]},
-        {:add, [3, 4]}  # this should never execute
+        # this should never execute
+        {:add, [3, 4]}
       ]
 
       assert {:error, _} = Firebird.Runtime.call_many(pid, calls)
@@ -240,6 +246,7 @@ defmodule Firebird.ApiEdgeCasesTest do
       {:ok, results} = Firebird.Runtime.call_many(pid, calls)
 
       assert length(results) == 50
+
       for {[result], i} <- Enum.with_index(results, 1) do
         assert result == i * 2
       end
@@ -336,6 +343,7 @@ defmodule Firebird.ApiEdgeCasesTest do
       {:ok, results} = Firebird.Batch.pmap(pool, :add, args_list)
 
       assert length(results) == 50
+
       for {[result], i} <- Enum.with_index(results, 1) do
         assert result == i * 2
       end
@@ -433,7 +441,9 @@ defmodule Firebird.ApiEdgeCasesTest do
     end
 
     test "compile with optimize + inline" do
-      {:ok, result} = Firebird.Compiler.compile_source(@inline_source, optimize: true, inline: true)
+      {:ok, result} =
+        Firebird.Compiler.compile_source(@inline_source, optimize: true, inline: true)
+
       assert is_binary(result.wasm)
 
       {:ok, inst} = Firebird.load(result.wasm)
@@ -453,7 +463,9 @@ defmodule Firebird.ApiEdgeCasesTest do
       end
       """
 
-      {:ok, result} = Firebird.Compiler.compile_source(source, optimize: true, tco: true, inline: true)
+      {:ok, result} =
+        Firebird.Compiler.compile_source(source, optimize: true, tco: true, inline: true)
+
       assert is_binary(result.wasm)
 
       {:ok, inst} = Firebird.load(result.wasm)
@@ -628,9 +640,10 @@ defmodule Firebird.ApiEdgeCasesTest do
     test "describes running instance with type info" do
       {:ok, wasm} = Firebird.load(@math_wasm)
 
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe(wasm)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe(wasm)
+        end)
 
       assert output =~ "WASM Instance"
       assert output =~ "alive"
@@ -644,9 +657,10 @@ defmodule Firebird.ApiEdgeCasesTest do
     end
 
     test "describes file path with function signatures" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe(@math_wasm)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe(@math_wasm)
+        end)
 
       assert output =~ "math.wasm"
       assert output =~ "Functions"
diff --git a/test/firebird_benchmark_test.exs b/test/firebird_benchmark_test.exs
index e85b5ff..9540aca 100644
--- a/test/firebird_benchmark_test.exs
+++ b/test/firebird_benchmark_test.exs
@@ -48,11 +48,12 @@ defmodule Firebird.BenchmarkTest do
       end
       """
 
-      result = Benchmark.compare(source, :mul, [[3, 4]],
-        beam_fun: fn a, b -> a * b end,
-        iterations: 5,
-        warmup: 2
-      )
+      result =
+        Benchmark.compare(source, :mul, [[3, 4]],
+          beam_fun: fn a, b -> a * b end,
+          iterations: 5,
+          warmup: 2
+        )
 
       assert is_map(result.wasm)
       assert is_map(result.beam)
@@ -156,16 +157,30 @@ defmodule Firebird.BenchmarkTest do
         name: "test_bench",
         function: :add,
         wasm: %{
-          function: :add, iterations: 10,
-          avg_us: 15.5, min_us: 10, max_us: 20,
-          median_us: 15, p50_us: 15.0, p95_us: 19.0, p99_us: 19.8,
-          stddev_us: 3.2, total_us: 155.0
+          function: :add,
+          iterations: 10,
+          avg_us: 15.5,
+          min_us: 10,
+          max_us: 20,
+          median_us: 15,
+          p50_us: 15.0,
+          p95_us: 19.0,
+          p99_us: 19.8,
+          stddev_us: 3.2,
+          total_us: 155.0
         },
         beam: %{
-          function: :add, iterations: 10,
-          avg_us: 5.5, min_us: 3, max_us: 8,
-          median_us: 5, p50_us: 5.0, p95_us: 7.5, p99_us: 7.9,
-          stddev_us: 1.5, total_us: 55.0
+          function: :add,
+          iterations: 10,
+          avg_us: 5.5,
+          min_us: 3,
+          max_us: 8,
+          median_us: 5,
+          p50_us: 5.0,
+          p95_us: 7.5,
+          p99_us: 7.9,
+          stddev_us: 1.5,
+          total_us: 55.0
         },
         speedup: 0.354,
         args_count: 1,
@@ -206,4 +221,3 @@ defmodule Firebird.BenchmarkTest do
     end
   end
 end
-
diff --git a/test/firebird_comprehensive_api_test.exs b/test/firebird_comprehensive_api_test.exs
index 4b71263..1ccd4ca 100644
--- a/test/firebird_comprehensive_api_test.exs
+++ b/test/firebird_comprehensive_api_test.exs
@@ -115,11 +115,13 @@ defmodule Firebird.ComprehensiveAPITest do
     end
 
     test "executes multiple calls in sequence", %{wasm: wasm} do
-      {:ok, results} = Firebird.call_many(wasm, [
-        {:add, [1, 2]},
-        {:multiply, [3, 4]},
-        {:fibonacci, [10]}
-      ])
+      {:ok, results} =
+        Firebird.call_many(wasm, [
+          {:add, [1, 2]},
+          {:multiply, [3, 4]},
+          {:fibonacci, [10]}
+        ])
+
       assert results == [[3], [12], [55]]
     end
 
@@ -128,11 +130,13 @@ defmodule Firebird.ComprehensiveAPITest do
     end
 
     test "stops on first error", %{wasm: wasm} do
-      result = Firebird.call_many(wasm, [
-        {:add, [1, 2]},
-        {:nonexistent, [1]},
-        {:add, [3, 4]}
-      ])
+      result =
+        Firebird.call_many(wasm, [
+          {:add, [1, 2]},
+          {:nonexistent, [1]},
+          {:add, [3, 4]}
+        ])
+
       assert {:error, _} = result
     end
 
@@ -268,10 +272,12 @@ defmodule Firebird.ComprehensiveAPITest do
   # ---------------------------------------------------------------------------
   describe "with_instance/3" do
     test "provides instance and cleans up" do
-      result = Firebird.with_instance(@math_wasm, fn wasm ->
-        {:ok, [8]} = Firebird.call(wasm, :add, [5, 3])
-        :my_result
-      end)
+      result =
+        Firebird.with_instance(@math_wasm, fn wasm ->
+          {:ok, [8]} = Firebird.call(wasm, :add, [5, 3])
+          :my_result
+        end)
+
       assert {:ok, :my_result} = result
     end
 
@@ -286,19 +292,23 @@ defmodule Firebird.ComprehensiveAPITest do
     end
 
     test "returns error for bad path" do
-      result = Firebird.with_instance("/nonexistent.wasm", fn _wasm ->
-        :unreachable
-      end)
+      result =
+        Firebird.with_instance("/nonexistent.wasm", fn _wasm ->
+          :unreachable
+        end)
+
       assert {:error, _} = result
     end
 
     test "multiple calls within block" do
-      {:ok, results} = Firebird.with_instance(@math_wasm, fn wasm ->
-        {:ok, [a]} = Firebird.call(wasm, :add, [5, 3])
-        {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 2])
-        {:ok, [c]} = Firebird.call(wasm, :fibonacci, [10])
-        {a, b, c}
-      end)
+      {:ok, results} =
+        Firebird.with_instance(@math_wasm, fn wasm ->
+          {:ok, [a]} = Firebird.call(wasm, :add, [5, 3])
+          {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 2])
+          {:ok, [c]} = Firebird.call(wasm, :fibonacci, [10])
+          {a, b, c}
+        end)
+
       assert {8, 16, 55} = results
     end
   end
@@ -393,11 +403,13 @@ defmodule Firebird.ComprehensiveAPITest do
   # ---------------------------------------------------------------------------
   describe "from_wat/2" do
     test "loads from WAT source" do
-      {:ok, wasm} = Firebird.from_wat("""
-      (module
-        (func (export "add") (param i32 i32) (result i32)
-          local.get 0 local.get 1 i32.add))
-      """)
+      {:ok, wasm} =
+        Firebird.from_wat("""
+        (module
+          (func (export "add") (param i32 i32) (result i32)
+            local.get 0 local.get 1 i32.add))
+        """)
+
       assert {:ok, [8]} = Firebird.call(wasm, :add, [5, 3])
       Firebird.stop(wasm)
     end
@@ -407,13 +419,15 @@ defmodule Firebird.ComprehensiveAPITest do
     end
 
     test "works with multiple functions" do
-      {:ok, wasm} = Firebird.from_wat("""
-      (module
-        (func (export "add") (param i32 i32) (result i32)
-          local.get 0 local.get 1 i32.add)
-        (func (export "sub") (param i32 i32) (result i32)
-          local.get 0 local.get 1 i32.sub))
-      """)
+      {:ok, wasm} =
+        Firebird.from_wat("""
+        (module
+          (func (export "add") (param i32 i32) (result i32)
+            local.get 0 local.get 1 i32.add)
+          (func (export "sub") (param i32 i32) (result i32)
+            local.get 0 local.get 1 i32.sub))
+        """)
+
       assert {:ok, [8]} = Firebird.call(wasm, :add, [5, 3])
       assert {:ok, [2]} = Firebird.call(wasm, :sub, [5, 3])
       Firebird.stop(wasm)
@@ -428,11 +442,13 @@ defmodule Firebird.ComprehensiveAPITest do
 
   describe "from_wat!/2" do
     test "returns pid directly" do
-      wasm = Firebird.from_wat!("""
-      (module
-        (func (export "double") (param i32) (result i32)
-          local.get 0 i32.const 2 i32.mul))
-      """)
+      wasm =
+        Firebird.from_wat!("""
+        (module
+          (func (export "double") (param i32) (result i32)
+            local.get 0 i32.const 2 i32.mul))
+        """)
+
       assert [10] = Firebird.call!(wasm, :double, [5])
       Firebird.stop(wasm)
     end
@@ -458,10 +474,12 @@ defmodule Firebird.ComprehensiveAPITest do
     end
 
     test "compiled bytes are valid WASM" do
-      {:ok, bytes} = Firebird.compile_wat("""
-      (module
-        (func (export "constant") (result i32) i32.const 42))
-      """)
+      {:ok, bytes} =
+        Firebird.compile_wat("""
+        (module
+          (func (export "constant") (result i32) i32.const 42))
+        """)
+
       {:ok, wasm} = Firebird.load(bytes)
       assert {:ok, [42]} = Firebird.call(wasm, :constant, [])
       Firebird.stop(wasm)
@@ -478,9 +496,13 @@ defmodule Firebird.ComprehensiveAPITest do
     end
 
     test "quick with inline WAT" do
-      result = Firebird.quick(
-        "(module (func (export \"answer\") (result i32) i32.const 42))",
-        :answer, [])
+      result =
+        Firebird.quick(
+          "(module (func (export \"answer\") (result i32) i32.const 42))",
+          :answer,
+          []
+        )
+
       assert result == 42
     end
 
@@ -686,9 +708,12 @@ defmodule Firebird.ComprehensiveAPITest do
   describe "describe/1" do
     test "describes a running instance" do
       wasm = Firebird.load!(@math_wasm)
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe(wasm)
-      end)
+
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe(wasm)
+        end)
+
       assert output =~ "WASM Instance"
       assert output =~ "alive"
       assert output =~ "Memory"
@@ -697,16 +722,20 @@ defmodule Firebird.ComprehensiveAPITest do
     end
 
     test "describes a file path" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe(@math_wasm)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe(@math_wasm)
+        end)
+
       assert output =~ "Functions"
     end
 
     test "handles nonexistent file gracefully" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe("/nonexistent/file.wasm")
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe("/nonexistent/file.wasm")
+        end)
+
       assert output =~ "Cannot inspect"
     end
   end
diff --git a/test/firebird_convenience_edge_cases_test.exs b/test/firebird_convenience_edge_cases_test.exs
index 9b00b76..9b1a6dd 100644
--- a/test/firebird_convenience_edge_cases_test.exs
+++ b/test/firebird_convenience_edge_cases_test.exs
@@ -59,9 +59,10 @@ defmodule Firebird.ConvenienceEdgeCasesTest do
     test "prints instance info without crashing" do
       {:ok, wasm} = Firebird.load(@math_wasm)
 
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe(wasm)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe(wasm)
+        end)
 
       assert output =~ "WASM Instance"
       assert output =~ "alive"
@@ -74,9 +75,10 @@ defmodule Firebird.ConvenienceEdgeCasesTest do
     test "prints function signatures" do
       {:ok, wasm} = Firebird.load(@math_wasm)
 
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Firebird.describe(wasm)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Firebird.describe(wasm)
+        end)
 
       assert output =~ "add"
 
@@ -86,26 +88,29 @@ defmodule Firebird.ConvenienceEdgeCasesTest do
 
   describe "describe/1 with path" do
     test "prints file info" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe(@math_wasm)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe(@math_wasm)
+        end)
 
       assert output =~ "math.wasm"
       assert output =~ "Functions"
     end
 
     test "handles nonexistent file gracefully" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        assert :ok = Firebird.describe("/nonexistent/path.wasm")
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          assert :ok = Firebird.describe("/nonexistent/path.wasm")
+        end)
 
       assert output =~ "Cannot inspect"
     end
 
     test "shows file size" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Firebird.describe(@math_wasm)
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Firebird.describe(@math_wasm)
+        end)
 
       # Should show some size (KB or B)
       assert output =~ ~r/\d/
@@ -186,11 +191,12 @@ defmodule Firebird.ConvenienceEdgeCasesTest do
     test "executes multiple calls in sequence" do
       {:ok, wasm} = Firebird.load(@math_wasm)
 
-      {:ok, results} = Firebird.call_many(wasm, [
-        {:add, [1, 2]},
-        {:multiply, [3, 4]},
-        {:fibonacci, [10]}
-      ])
+      {:ok, results} =
+        Firebird.call_many(wasm, [
+          {:add, [1, 2]},
+          {:multiply, [3, 4]},
+          {:fibonacci, [10]}
+        ])
 
       assert results == [[3], [12], [55]]
 
@@ -200,11 +206,12 @@ defmodule Firebird.ConvenienceEdgeCasesTest do
     test "returns error if any call fails" do
       {:ok, wasm} = Firebird.load(@math_wasm)
 
-      result = Firebird.call_many(wasm, [
-        {:add, [1, 2]},
-        {:nonexistent, [42]},
-        {:add, [3, 4]}
-      ])
+      result =
+        Firebird.call_many(wasm, [
+          {:add, [1, 2]},
+          {:nonexistent, [42]},
+          {:add, [3, 4]}
+        ])
 
       assert {:error, _} = result
 
@@ -226,10 +233,11 @@ defmodule Firebird.ConvenienceEdgeCasesTest do
     test "accepts string function names" do
       {:ok, wasm} = Firebird.load(@math_wasm)
 
-      {:ok, results} = Firebird.call_many(wasm, [
-        {"add", [1, 2]},
-        {"multiply", [5, 6]}
-      ])
+      {:ok, results} =
+        Firebird.call_many(wasm, [
+          {"add", [1, 2]},
+          {"multiply", [5, 6]}
+        ])
 
       assert results == [[3], [30]]
 
@@ -287,20 +295,22 @@ defmodule Firebird.ConvenienceEdgeCasesTest do
   # ---------------------------------------------------------------------------
   describe "with_instance/3" do
     test "loads, executes, and cleans up" do
-      {:ok, result} = Firebird.with_instance(@math_wasm, fn wasm ->
-        {:ok, [sum]} = Firebird.call(wasm, :add, [5, 3])
-        sum
-      end)
+      {:ok, result} =
+        Firebird.with_instance(@math_wasm, fn wasm ->
+          {:ok, [sum]} = Firebird.call(wasm, :add, [5, 3])
+          sum
+        end)
 
       assert result == 8
     end
 
     test "cleans up even on normal exit" do
       # We can verify cleanup by checking that the function receives a valid pid
-      {:ok, pid} = Firebird.with_instance(@math_wasm, fn wasm ->
-        assert Process.alive?(wasm)
-        wasm
-      end)
+      {:ok, pid} =
+        Firebird.with_instance(@math_wasm, fn wasm ->
+          assert Process.alive?(wasm)
+          wasm
+        end)
 
       # After with_instance returns, the instance should be stopped
       Process.sleep(50)
@@ -333,21 +343,27 @@ defmodule Firebird.ConvenienceEdgeCasesTest do
     test "supports options" do
       go_wasm = Path.join(__DIR__, "../fixtures/go_math.wasm")
 
-      {:ok, result} = Firebird.with_instance(go_wasm, fn wasm ->
-        {:ok, [sum]} = Firebird.call(wasm, :add, [10, 20])
-        sum
-      end, wasi: true)
+      {:ok, result} =
+        Firebird.with_instance(
+          go_wasm,
+          fn wasm ->
+            {:ok, [sum]} = Firebird.call(wasm, :add, [10, 20])
+            sum
+          end,
+          wasi: true
+        )
 
       assert result == 30
     end
 
     test "supports multiple calls within block" do
-      {:ok, result} = Firebird.with_instance(@math_wasm, fn wasm ->
-        {:ok, [a]} = Firebird.call(wasm, :add, [5, 3])
-        {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 2])
-        {:ok, [c]} = Firebird.call(wasm, :fibonacci, [10])
-        {a, b, c}
-      end)
+      {:ok, result} =
+        Firebird.with_instance(@math_wasm, fn wasm ->
+          {:ok, [a]} = Firebird.call(wasm, :add, [5, 3])
+          {:ok, [b]} = Firebird.call(wasm, :multiply, [a, 2])
+          {:ok, [c]} = Firebird.call(wasm, :fibonacci, [10])
+          {a, b, c}
+        end)
 
       assert result == {8, 16, 55}
     end
@@ -522,12 +538,14 @@ defmodule Firebird.ConvenienceEdgeCasesTest do
     test "suggests similar function name" do
       {:ok, wasm} = Firebird.load(@math_wasm)
 
-      error = assert_raise RuntimeError, fn ->
-        Firebird.call_one!(wasm, :addd, [1, 2])
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.call_one!(wasm, :addd, [1, 2])
+        end
 
       # Should suggest 'add'
-      assert error.message =~ "Did you mean" or error.message =~ "add" or error.message =~ "Available"
+      assert error.message =~ "Did you mean" or error.message =~ "add" or
+               error.message =~ "Available"
 
       Firebird.stop(wasm)
     end
@@ -535,9 +553,10 @@ defmodule Firebird.ConvenienceEdgeCasesTest do
     test "lists available functions for very different name" do
       {:ok, wasm} = Firebird.load(@math_wasm)
 
-      error = assert_raise RuntimeError, fn ->
-        Firebird.call_one!(wasm, :zzzzzzz, [1, 2])
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.call_one!(wasm, :zzzzzzz, [1, 2])
+        end
 
       assert error.message =~ "Available" or error.message =~ "not found"
 
@@ -550,9 +569,10 @@ defmodule Firebird.ConvenienceEdgeCasesTest do
   # ---------------------------------------------------------------------------
   describe "load!/2" do
     test "raises for nonexistent file with helpful message" do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.load!("/nonexistent/path/math.wasm")
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.load!("/nonexistent/path/math.wasm")
+        end
 
       assert error.message =~ "not found" or error.message =~ "Cannot read"
     end
@@ -579,11 +599,12 @@ defmodule Firebird.ConvenienceEdgeCasesTest do
     end
 
     test "compiles WAT with function" do
-      {:ok, bytes} = Firebird.compile_wat("""
-      (module
-        (func (export "answer") (result i32)
-          i32.const 42))
-      """)
+      {:ok, bytes} =
+        Firebird.compile_wat("""
+        (module
+          (func (export "answer") (result i32)
+            i32.const 42))
+        """)
 
       {:ok, wasm} = Firebird.load(bytes)
       {:ok, [42]} = Firebird.call(wasm, :answer, [])
@@ -596,11 +617,12 @@ defmodule Firebird.ConvenienceEdgeCasesTest do
   # ---------------------------------------------------------------------------
   describe "from_wat/2" do
     test "compiles and loads WAT" do
-      {:ok, wasm} = Firebird.from_wat("""
-      (module
-        (func (export "double") (param i32) (result i32)
-          local.get 0 i32.const 2 i32.mul))
-      """)
+      {:ok, wasm} =
+        Firebird.from_wat("""
+        (module
+          (func (export "double") (param i32) (result i32)
+            local.get 0 i32.const 2 i32.mul))
+        """)
 
       {:ok, [10]} = Firebird.call(wasm, :double, [5])
       Firebird.stop(wasm)
@@ -613,10 +635,11 @@ defmodule Firebird.ConvenienceEdgeCasesTest do
 
   describe "from_wat!/2" do
     test "compiles and loads, returning pid" do
-      wasm = Firebird.from_wat!("""
-      (module
-        (func (export "noop") (result i32) i32.const 0))
-      """)
+      wasm =
+        Firebird.from_wat!("""
+        (module
+          (func (export "noop") (result i32) i32.const 0))
+        """)
 
       assert Process.alive?(wasm)
       Firebird.stop(wasm)
diff --git a/test/firebird_convenience_test.exs b/test/firebird_convenience_test.exs
index b784dc7..8d27c59 100644
--- a/test/firebird_convenience_test.exs
+++ b/test/firebird_convenience_test.exs
@@ -76,11 +76,13 @@ defmodule Firebird.ConvenienceTest do
     end
 
     test "executes multiple calls in sequence", %{pid: pid} do
-      {:ok, results} = Firebird.call_many(pid, [
-        {:add, [1, 2]},
-        {:add, [3, 4]},
-        {:multiply, [5, 6]}
-      ])
+      {:ok, results} =
+        Firebird.call_many(pid, [
+          {:add, [1, 2]},
+          {:add, [3, 4]},
+          {:multiply, [5, 6]}
+        ])
+
       assert results == [[3], [7], [30]]
     end
 
@@ -90,10 +92,12 @@ defmodule Firebird.ConvenienceTest do
     end
 
     test "returns error if any call fails", %{pid: pid} do
-      result = Firebird.call_many(pid, [
-        {:add, [1, 2]},
-        {:nonexistent, [1]}
-      ])
+      result =
+        Firebird.call_many(pid, [
+          {:add, [1, 2]},
+          {:nonexistent, [1]}
+        ])
+
       assert {:error, _} = result
     end
   end
@@ -136,11 +140,13 @@ defmodule Firebird.ConvenienceTest do
 
   describe "with_instance/3" do
     test "provides instance to block and cleans up" do
-      {:ok, result} = Firebird.with_instance(@math_wasm, fn instance ->
-        {:ok, [sum]} = Firebird.call(instance, :add, [5, 3])
-        {:ok, [product]} = Firebird.call(instance, :multiply, [sum, 2])
-        product
-      end)
+      {:ok, result} =
+        Firebird.with_instance(@math_wasm, fn instance ->
+          {:ok, [sum]} = Firebird.call(instance, :add, [5, 3])
+          {:ok, [product]} = Firebird.call(instance, :multiply, [sum, 2])
+          product
+        end)
+
       assert result == 16
     end
 
@@ -152,13 +158,15 @@ defmodule Firebird.ConvenienceTest do
       rescue
         RuntimeError -> :ok
       end
+
       # No assertion needed - just verifying it doesn't crash/leak
     end
 
     test "returns error for invalid wasm source" do
-      assert {:error, _} = Firebird.with_instance("/nonexistent.wasm", fn _instance ->
-        :should_not_reach
-      end)
+      assert {:error, _} =
+               Firebird.with_instance("/nonexistent.wasm", fn _instance ->
+                 :should_not_reach
+               end)
     end
   end
 
@@ -331,10 +339,11 @@ defmodule Firebird.ConvenienceTest do
       # serialize may or may not be supported by the runtime
       case result do
         {:ok, bytes} -> assert is_binary(bytes)
-        {:error, _} -> :ok  # acceptable if not supported
+        # acceptable if not supported
+        {:error, _} -> :ok
       end
+
       Firebird.stop(pid)
     end
   end
-
 end
diff --git a/test/firebird_core_api_test.exs b/test/firebird_core_api_test.exs
index e27ef24..fee1c14 100644
--- a/test/firebird_core_api_test.exs
+++ b/test/firebird_core_api_test.exs
@@ -246,10 +246,11 @@ defmodule Firebird.CoreApiTest do
 
   describe "with_instance/3" do
     test "provides instance to callback and stops after" do
-      result = Firebird.with_instance(@math_wasm, fn pid ->
-        {:ok, [8]} = Firebird.call(pid, :add, [5, 3])
-        :done
-      end)
+      result =
+        Firebird.with_instance(@math_wasm, fn pid ->
+          {:ok, [8]} = Firebird.call(pid, :add, [5, 3])
+          :done
+        end)
 
       assert {:ok, :done} = result
     end
@@ -755,6 +756,7 @@ defmodule Firebird.CoreApiTest do
   describe "pool convenience APIs" do
     setup do
       {:ok, pool} = Firebird.start_pool(wasm_path: @math_wasm, pool_size: 2)
+
       on_exit(fn ->
         try do
           if Process.alive?(pool), do: Firebird.stop_pool(pool)
@@ -762,6 +764,7 @@ defmodule Firebird.CoreApiTest do
           :exit, _ -> :ok
         end
       end)
+
       %{pool: pool}
     end
 
@@ -843,10 +846,11 @@ defmodule Firebird.CoreApiTest do
     end
 
     test "multiple loads of same file" do
-      pids = for _ <- 1..3 do
-        {:ok, pid} = Firebird.load(@math_wasm)
-        pid
-      end
+      pids =
+        for _ <- 1..3 do
+          {:ok, pid} = Firebird.load(@math_wasm)
+          pid
+        end
 
       for pid <- pids do
         {:ok, [8]} = Firebird.call(pid, :add, [5, 3])
diff --git a/test/firebird_core_edge_cases_test.exs b/test/firebird_core_edge_cases_test.exs
index 0fafca4..425b319 100644
--- a/test/firebird_core_edge_cases_test.exs
+++ b/test/firebird_core_edge_cases_test.exs
@@ -45,10 +45,11 @@ defmodule Firebird.CoreEdgeCasesTest do
   # ===========================================================================
   describe "Firebird.with_instance/3" do
     test "loads, executes function, and cleans up" do
-      result = Firebird.with_instance(@math_wasm, fn pid ->
-        {:ok, [8]} = Firebird.call(pid, :add, [5, 3])
-        :done
-      end)
+      result =
+        Firebird.with_instance(@math_wasm, fn pid ->
+          {:ok, [8]} = Firebird.call(pid, :add, [5, 3])
+          :done
+        end)
 
       assert {:ok, :done} = result
     end
@@ -70,20 +71,22 @@ defmodule Firebird.CoreEdgeCasesTest do
     end
 
     test "returns error for non-existent file" do
-      result = Firebird.with_instance("nonexistent.wasm", fn _pid ->
-        :should_not_reach
-      end)
+      result =
+        Firebird.with_instance("nonexistent.wasm", fn _pid ->
+          :should_not_reach
+        end)
 
       assert {:error, _} = result
     end
 
     test "can perform multiple calls inside callback" do
-      {:ok, results} = Firebird.with_instance(@math_wasm, fn pid ->
-        {:ok, [a]} = Firebird.call(pid, :add, [10, 20])
-        {:ok, [b]} = Firebird.call(pid, :multiply, [a, 2])
-        {:ok, [c]} = Firebird.call(pid, :fibonacci, [10])
-        {a, b, c}
-      end)
+      {:ok, results} =
+        Firebird.with_instance(@math_wasm, fn pid ->
+          {:ok, [a]} = Firebird.call(pid, :add, [10, 20])
+          {:ok, [b]} = Firebird.call(pid, :multiply, [a, 2])
+          {:ok, [c]} = Firebird.call(pid, :fibonacci, [10])
+          {a, b, c}
+        end)
 
       assert results == {30, 60, 55}
     end
@@ -100,11 +103,12 @@ defmodule Firebird.CoreEdgeCasesTest do
     end
 
     test "executes multiple calls in sequence", %{wasm: pid} do
-      {:ok, results} = Firebird.call_many(pid, [
-        {:add, [1, 2]},
-        {:multiply, [3, 4]},
-        {:fibonacci, [10]}
-      ])
+      {:ok, results} =
+        Firebird.call_many(pid, [
+          {:add, [1, 2]},
+          {:multiply, [3, 4]},
+          {:fibonacci, [10]}
+        ])
 
       assert results == [[3], [12], [55]]
     end
@@ -119,11 +123,12 @@ defmodule Firebird.CoreEdgeCasesTest do
     end
 
     test "returns error on first failure", %{wasm: pid} do
-      result = Firebird.call_many(pid, [
-        {:add, [1, 2]},
-        {:nonexistent, [1]},
-        {:add, [3, 4]}
-      ])
+      result =
+        Firebird.call_many(pid, [
+          {:add, [1, 2]},
+          {:nonexistent, [1]},
+          {:add, [3, 4]}
+        ])
 
       assert {:error, _} = result
     end
@@ -253,11 +258,12 @@ defmodule Firebird.CoreEdgeCasesTest do
   # ===========================================================================
   describe "Firebird.from_wat/2" do
     test "compiles WAT and loads instance" do
-      {:ok, pid} = Firebird.from_wat("""
-      (module
-        (func (export "double") (param i32) (result i32)
-          local.get 0 i32.const 2 i32.mul))
-      """)
+      {:ok, pid} =
+        Firebird.from_wat("""
+        (module
+          (func (export "double") (param i32) (result i32)
+            local.get 0 i32.const 2 i32.mul))
+        """)
 
       {:ok, [10]} = Firebird.call(pid, :double, [5])
       Firebird.stop(pid)
@@ -277,11 +283,12 @@ defmodule Firebird.CoreEdgeCasesTest do
 
   describe "Firebird.from_wat!/2" do
     test "returns pid directly" do
-      pid = Firebird.from_wat!("""
-      (module
-        (func (export "inc") (param i32) (result i32)
-          local.get 0 i32.const 1 i32.add))
-      """)
+      pid =
+        Firebird.from_wat!("""
+        (module
+          (func (export "inc") (param i32) (result i32)
+            local.get 0 i32.const 1 i32.add))
+        """)
 
       assert [6] = Firebird.call!(pid, :inc, [5])
       Firebird.stop(pid)
@@ -340,9 +347,11 @@ defmodule Firebird.CoreEdgeCasesTest do
     end
 
     test "raises with suggestion for typo", %{wasm: pid} do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.call_one!(pid, :addd, [1, 2])
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.call_one!(pid, :addd, [1, 2])
+        end
+
       # Should contain "Did you mean" or "Available" or function name
       assert Exception.message(error) =~ "addd" or Exception.message(error) =~ "add"
     end
@@ -525,7 +534,7 @@ defmodule Firebird.CoreEdgeCasesTest do
       # Every function should have a signature
       for func <- desc.functions do
         assert Map.has_key?(desc.signatures, func),
-          "Missing signature for #{func}"
+               "Missing signature for #{func}"
       end
 
       Firebird.stop(pid)
@@ -539,40 +548,59 @@ defmodule Firebird.CoreEdgeCasesTest do
     test "runs fibonacci concurrently" do
       args_list = for n <- 1..20, do: [n]
 
-      {:ok, results} = Firebird.WasmRunner.run_concurrent(
-        @rust_wasm, :fibonacci, args_list, concurrency: 2
-      )
+      {:ok, results} =
+        Firebird.WasmRunner.run_concurrent(
+          @rust_wasm,
+          :fibonacci,
+          args_list,
+          concurrency: 2
+        )
 
       assert length(results) == 20
       # Verify specific known values
-      assert Enum.at(results, 0) == 1   # fib(1)
-      assert Enum.at(results, 4) == 5   # fib(5)
-      assert Enum.at(results, 9) == 55  # fib(10)
+      # fib(1)
+      assert Enum.at(results, 0) == 1
+      # fib(5)
+      assert Enum.at(results, 4) == 5
+      # fib(10)
+      assert Enum.at(results, 9) == 55
     end
 
     test "preserves order of results" do
       args_list = for n <- 1..10, do: [n, n]
 
-      {:ok, results} = Firebird.WasmRunner.run_concurrent(
-        @rust_wasm, :add, args_list, concurrency: 3
-      )
+      {:ok, results} =
+        Firebird.WasmRunner.run_concurrent(
+          @rust_wasm,
+          :add,
+          args_list,
+          concurrency: 3
+        )
 
       expected = for n <- 1..10, do: n * 2
       assert results == expected
     end
 
     test "handles single item" do
-      {:ok, [result]} = Firebird.WasmRunner.run_concurrent(
-        @rust_wasm, :add, [[5, 3]], concurrency: 1
-      )
+      {:ok, [result]} =
+        Firebird.WasmRunner.run_concurrent(
+          @rust_wasm,
+          :add,
+          [[5, 3]],
+          concurrency: 1
+        )
 
       assert result == 8
     end
 
     test "handles empty args list" do
-      {:ok, results} = Firebird.WasmRunner.run_concurrent(
-        @rust_wasm, :add, [], concurrency: 2
-      )
+      {:ok, results} =
+        Firebird.WasmRunner.run_concurrent(
+          @rust_wasm,
+          :add,
+          [],
+          concurrency: 2
+        )
 
       assert results == []
     end
@@ -580,13 +608,17 @@ defmodule Firebird.CoreEdgeCasesTest do
     test "throws for invalid module" do
       # run_concurrent throws {:start_error, reason} when instances fail to start
       # (the throw escapes the try/catch because it's in the for comprehension above it)
-      result = try do
-        Firebird.WasmRunner.run_concurrent(
-          "nonexistent.wasm", :add, [[1, 2]], concurrency: 1
-        )
-      catch
-        {:start_error, reason} -> {:caught, reason}
-      end
+      result =
+        try do
+          Firebird.WasmRunner.run_concurrent(
+            "nonexistent.wasm",
+            :add,
+            [[1, 2]],
+            concurrency: 1
+          )
+        catch
+          {:start_error, reason} -> {:caught, reason}
+        end
 
       assert {:caught, _reason} = result
     end
@@ -640,11 +672,12 @@ defmodule Firebird.CoreEdgeCasesTest do
     end
 
     test "compiles module with function" do
-      {:ok, bytes} = Firebird.compile_wat("""
-      (module
-        (func (export "id") (param i32) (result i32)
-          local.get 0))
-      """)
+      {:ok, bytes} =
+        Firebird.compile_wat("""
+        (module
+          (func (export "id") (param i32) (result i32)
+            local.get 0))
+        """)
 
       {:ok, pid} = Firebird.load(bytes)
       {:ok, [42]} = Firebird.call(pid, :id, [42])
diff --git a/test/firebird_full_api_coverage_test.exs b/test/firebird_full_api_coverage_test.exs
index 4437957..a300fd4 100644
--- a/test/firebird_full_api_coverage_test.exs
+++ b/test/firebird_full_api_coverage_test.exs
@@ -41,6 +41,7 @@ defmodule Firebird.FullApiCoverageTest do
       case result do
         {:ok, ref} when is_reference(ref) ->
           assert is_reference(ref)
+
         {:error, _} ->
           # FastNif not available, acceptable
           :ok
@@ -121,16 +122,18 @@ defmodule Firebird.FullApiCoverageTest do
     end
 
     test "executes multiple calls sequentially", %{pid: pid} do
-      result = Firebird.call_many(pid, [
-        {:add, [5, 3]},
-        {:multiply, [4, 6]},
-        {:fibonacci, [10]}
-      ])
+      result =
+        Firebird.call_many(pid, [
+          {:add, [5, 3]},
+          {:multiply, [4, 6]},
+          {:fibonacci, [10]}
+        ])
 
       # call_many returns {:ok, results_list} or a list of results
       case result do
         {:ok, results} ->
           assert [[8], [24], [55]] = results
+
         results when is_list(results) ->
           assert [{:ok, [8]}, {:ok, [24]}, {:ok, [55]}] = results
       end
@@ -138,6 +141,7 @@ defmodule Firebird.FullApiCoverageTest do
 
     test "empty call list returns empty list", %{pid: pid} do
       result = Firebird.call_many(pid, [])
+
       case result do
         {:ok, []} -> :ok
         [] -> :ok
@@ -145,18 +149,21 @@ defmodule Firebird.FullApiCoverageTest do
     end
 
     test "includes errors for invalid calls", %{pid: pid} do
-      result = Firebird.call_many(pid, [
-        {:add, [1, 2]},
-        {:nonexistent, [1]},
-        {:add, [3, 4]}
-      ])
+      result =
+        Firebird.call_many(pid, [
+          {:add, [1, 2]},
+          {:nonexistent, [1]},
+          {:add, [3, 4]}
+        ])
 
       case result do
         {:ok, results} ->
           assert length(results) == 3
+
         {:error, _} ->
           # call_many may fail on first error
           :ok
+
         results when is_list(results) ->
           assert length(results) == 3
       end
@@ -263,10 +270,11 @@ defmodule Firebird.FullApiCoverageTest do
 
   describe "with_instance/3" do
     test "provides instance to callback and cleans up" do
-      result = Firebird.with_instance(@math_wasm, fn instance ->
-        {:ok, [8]} = Firebird.call(instance, :add, [5, 3])
-        :done
-      end)
+      result =
+        Firebird.with_instance(@math_wasm, fn instance ->
+          {:ok, [8]} = Firebird.call(instance, :add, [5, 3])
+          :done
+        end)
 
       assert {:ok, :done} = result
     end
@@ -280,18 +288,24 @@ defmodule Firebird.FullApiCoverageTest do
     end
 
     test "passes options through" do
-      result = Firebird.with_instance(@go_wasm, fn instance ->
-        {:ok, [8]} = Firebird.call(instance, :add, [5, 3])
-        :ok
-      end, wasi: true)
+      result =
+        Firebird.with_instance(
+          @go_wasm,
+          fn instance ->
+            {:ok, [8]} = Firebird.call(instance, :add, [5, 3])
+            :ok
+          end,
+          wasi: true
+        )
 
       assert {:ok, :ok} = result
     end
 
     test "returns error for invalid path" do
-      result = Firebird.with_instance("/nonexistent.wasm", fn _instance ->
-        :should_not_reach
-      end)
+      result =
+        Firebird.with_instance("/nonexistent.wasm", fn _instance ->
+          :should_not_reach
+        end)
 
       assert {:error, _} = result
     end
@@ -370,14 +384,17 @@ defmodule Firebird.FullApiCoverageTest do
 
     test "returns type signature for existing function", %{pid: pid} do
       result = Firebird.function_type(pid, "add")
+
       case result do
         {:ok, {params, results}} ->
           assert is_list(params)
           assert is_list(results)
           assert length(params) == 2
           assert length(results) == 1
+
         {:ok, _other} ->
           :ok
+
         {:error, _} ->
           :ok
       end
@@ -400,12 +417,14 @@ defmodule Firebird.FullApiCoverageTest do
 
     test "returns memory size in bytes", %{pid: pid} do
       result = Firebird.memory_size(pid)
+
       case result do
         {:ok, size} ->
           assert is_integer(size)
           assert size > 0
           # WASM pages are 64KB
           assert rem(size, 65536) == 0
+
         {:error, _} ->
           :ok
       end
@@ -427,6 +446,7 @@ defmodule Firebird.FullApiCoverageTest do
         {:ok, _} ->
           {:ok, new_size} = Firebird.memory_size(pid)
           assert new_size == initial_size + 65536
+
         {:error, _} ->
           :ok
       end
@@ -441,8 +461,10 @@ defmodule Firebird.FullApiCoverageTest do
     end
 
     test "write then read round-trips data", %{pid: pid} do
-      data = <<72, 101, 108, 108, 111>>  # "Hello"
-      offset = 1024  # Safe offset past WASM internals
+      # "Hello"
+      data = <<72, 101, 108, 108, 111>>
+      # Safe offset past WASM internals
+      offset = 1024
 
       :ok = Firebird.write_memory(pid, offset, data)
       {:ok, read_back} = Firebird.read_memory(pid, offset, byte_size(data))
@@ -483,6 +505,7 @@ defmodule Firebird.FullApiCoverageTest do
         {:ok, bytes} ->
           assert is_binary(bytes)
           assert byte_size(bytes) > 0
+
         {:error, _} ->
           :ok
       end
@@ -704,9 +727,10 @@ defmodule Firebird.FullApiCoverageTest do
     test "describes a live instance (prints to stdout, returns :ok)" do
       {:ok, pid} = Firebird.load(@math_wasm)
 
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        send(self(), {:result, Firebird.describe(pid)})
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          send(self(), {:result, Firebird.describe(pid)})
+        end)
 
       assert output =~ "WASM Instance"
       assert output =~ "add"
@@ -715,9 +739,10 @@ defmodule Firebird.FullApiCoverageTest do
     end
 
     test "describes a WASM file path (prints to stdout, returns :ok)" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        send(self(), {:result, Firebird.describe(@math_wasm)})
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          send(self(), {:result, Firebird.describe(@math_wasm)})
+        end)
 
       assert output =~ "add"
       assert output =~ "math"
@@ -797,8 +822,10 @@ defmodule Firebird.FullApiCoverageTest do
       case result do
         funcs when is_list(funcs) ->
           assert length(funcs) > 0
+
         funcs when is_map(funcs) ->
           assert map_size(funcs) > 0
+
         {:error, _} ->
           flunk("Expected function list but got error")
       end
@@ -814,9 +841,10 @@ defmodule Firebird.FullApiCoverageTest do
 
   describe "status/0" do
     test "prints system status to stdout" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Firebird.status()
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Firebird.status()
+        end)
 
       assert output =~ "Firebird"
       assert output =~ "Runtime"
@@ -974,6 +1002,7 @@ defmodule Firebird.FullApiCoverageTest do
         {:ok, _} -> :ok
         {:error, {:already_started, _}} -> :ok
       end
+
       Firebird.Metrics.reset()
 
       {:ok, pid} = Firebird.load(@math_wasm)
@@ -1042,14 +1071,14 @@ defmodule Firebird.FullApiCoverageTest do
 
     test "type_mismatch with all value types" do
       for {val, expected_type} <- [
-        {42, "integer"},
-        {3.14, "float"},
-        {"hello", "string"},
-        {:atom, "atom"},
-        {[1,2], "list"},
-        {{1,2}, "tuple"},
-        {%{a: 1}, "map"}
-      ] do
+            {42, "integer"},
+            {3.14, "float"},
+            {"hello", "string"},
+            {:atom, "atom"},
+            {[1, 2], "list"},
+            {{1, 2}, "tuple"},
+            {%{a: 1}, "map"}
+          ] do
         error = Firebird.WasmError.type_mismatch(:func, 0, :i32, val)
         assert error.message =~ expected_type, "Expected #{expected_type} for #{inspect(val)}"
       end
diff --git a/test/go_algorithms_test.exs b/test/go_algorithms_test.exs
index 6be0a65..0a099fd 100644
--- a/test/go_algorithms_test.exs
+++ b/test/go_algorithms_test.exs
@@ -36,7 +36,7 @@ defmodule GoAlgorithmsTest do
     test "basic sums", %{wasm: w} do
       {:ok, [0]} = Firebird.call(w, :digit_sum, [0])
       {:ok, [6]} = Firebird.call(w, :digit_sum, [123])
-      {:ok, [45]} = Firebird.call(w, :digit_sum, [123456789])
+      {:ok, [45]} = Firebird.call(w, :digit_sum, [123_456_789])
     end
   end
 
@@ -52,6 +52,7 @@ defmodule GoAlgorithmsTest do
   describe "nth_prime/1" do
     test "first primes", %{wasm: w} do
       expected = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
+
       for {prime, i} <- Enum.with_index(expected, 1) do
         {:ok, [^prime]} = Firebird.call(w, :nth_prime, [i])
       end
diff --git a/test/go_bitwise_test.exs b/test/go_bitwise_test.exs
index 76fdcef..7fcd4a5 100644
--- a/test/go_bitwise_test.exs
+++ b/test/go_bitwise_test.exs
@@ -5,9 +5,11 @@ defmodule Firebird.GoBitwiseTest do
 
   setup do
     {:ok, instance} = Firebird.load(@wasm_path, wasi: true)
+
     on_exit(fn ->
       if Process.alive?(instance), do: Firebird.stop(instance)
     end)
+
     %{wasm: instance}
   end
 
@@ -210,29 +212,40 @@ defmodule Firebird.GoBitwiseTest do
     end
 
     test "batch execution works" do
-      {:ok, results} = Firebird.WasmRunner.run_batch(@wasm_path, [
-        {:bit_and, [7, 3]},
-        {:bit_or, [5, 3]},
-        {:bit_xor, [5, 3]},
-        {:popcount, [255]},
-        {:is_power_of_two, [16]}
-      ], wasi: true)
+      {:ok, results} =
+        Firebird.WasmRunner.run_batch(
+          @wasm_path,
+          [
+            {:bit_and, [7, 3]},
+            {:bit_or, [5, 3]},
+            {:bit_xor, [5, 3]},
+            {:popcount, [255]},
+            {:is_power_of_two, [16]}
+          ],
+          wasi: true
+        )
 
       assert results == [3, 7, 6, 8, 1]
     end
 
     test "concurrent execution" do
       args_list = for n <- [1, 2, 4, 8, 16, 32, 64, 128], do: [n]
-      {:ok, results} = Firebird.WasmRunner.run_concurrent(
-        @wasm_path, :popcount, args_list,
-        concurrency: 2, wasi: true
-      )
-
-      expected = Enum.map(args_list, fn [n] ->
-        n
-        |> Integer.digits(2)
-        |> Enum.sum()
-      end)
+
+      {:ok, results} =
+        Firebird.WasmRunner.run_concurrent(
+          @wasm_path,
+          :popcount,
+          args_list,
+          concurrency: 2,
+          wasi: true
+        )
+
+      expected =
+        Enum.map(args_list, fn [n] ->
+          n
+          |> Integer.digits(2)
+          |> Enum.sum()
+        end)
 
       assert results == expected
     end
diff --git a/test/go_sorting_test.exs b/test/go_sorting_test.exs
index 9623341..a614531 100644
--- a/test/go_sorting_test.exs
+++ b/test/go_sorting_test.exs
@@ -163,9 +163,22 @@ defmodule Firebird.GoSortingTest do
   describe "exports" do
     test "all expected functions are exported", %{wasm: w} do
       exports = Firebird.exports(w)
-      expected = [:array_set, :array_get, :array_sum, :array_min, :array_max,
-                  :bubble_sort, :insertion_sort, :linear_search, :binary_search,
-                  :matrix_det_2x2, :dot_product, :count_inversions, :buffer_ptr]
+
+      expected = [
+        :array_set,
+        :array_get,
+        :array_sum,
+        :array_min,
+        :array_max,
+        :bubble_sort,
+        :insertion_sort,
+        :linear_search,
+        :binary_search,
+        :matrix_det_2x2,
+        :dot_product,
+        :count_inversions,
+        :buffer_ptr
+      ]
 
       for func <- expected do
         assert func in exports, "Expected #{func} to be exported, got: #{inspect(exports)}"
@@ -189,13 +202,15 @@ defmodule Firebird.GoSortingTest do
       values = Enum.shuffle(1..100)
       set_array(w, values)
 
-      {time, {:ok, [0]}} = :timer.tc(fn ->
-        Firebird.call(w, :insertion_sort, [100])
-      end)
+      {time, {:ok, [0]}} =
+        :timer.tc(fn ->
+          Firebird.call(w, :insertion_sort, [100])
+        end)
 
       result = get_array(w, 100)
       assert result == Enum.to_list(1..100)
-      assert time < 100_000  # Should complete in < 100ms
+      # Should complete in < 100ms
+      assert time < 100_000
     end
   end
 end
diff --git a/test/go_wasm_test.exs b/test/go_wasm_test.exs
index a30af75..8e7aee0 100644
--- a/test/go_wasm_test.exs
+++ b/test/go_wasm_test.exs
@@ -78,11 +78,12 @@ defmodule Firebird.GoWasmTest do
     end
 
     test "call_many with Go WASM", %{instance: pid} do
-      assert {:ok, [[3], [12], [55]]} = Firebird.call_many(pid, [
-        {:add, [1, 2]},
-        {:multiply, [3, 4]},
-        {:fibonacci, [10]}
-      ])
+      assert {:ok, [[3], [12], [55]]} =
+               Firebird.call_many(pid, [
+                 {:add, [1, 2]},
+                 {:multiply, [3, 4]},
+                 {:fibonacci, [10]}
+               ])
     end
 
     test "memory operations with Go WASM", %{instance: pid} do
@@ -100,18 +101,20 @@ defmodule Firebird.GoWasmTest do
 
       # Compare results across implementations
       for {func, args} <- [
-        {:add, [42, 58]},
-        {:multiply, [7, 8]},
-        {:fibonacci, [10]},
-        {:factorial, [5]},
-        {:gcd, [48, 18]},
-        {:power, [2, 10]},
-        {:is_prime, [97]},
-        {:sum_range, [1, 100]}
-      ] do
+            {:add, [42, 58]},
+            {:multiply, [7, 8]},
+            {:fibonacci, [10]},
+            {:factorial, [5]},
+            {:gcd, [48, 18]},
+            {:power, [2, 10]},
+            {:is_prime, [97]},
+            {:sum_range, [1, 100]}
+          ] do
         {:ok, go_result} = Firebird.call(go, func, args)
         {:ok, rust_result} = Firebird.call(rust, func, args)
-        assert go_result == rust_result, "#{func}(#{inspect(args)}): Go=#{inspect(go_result)} Rust=#{inspect(rust_result)}"
+
+        assert go_result == rust_result,
+               "#{func}(#{inspect(args)}): Go=#{inspect(go_result)} Rust=#{inspect(rust_result)}"
       end
 
       Firebird.stop(go)
diff --git a/test/hot_reload_edge_cases_test.exs b/test/hot_reload_edge_cases_test.exs
index b1bf4ba..fdc5e9e 100644
--- a/test/hot_reload_edge_cases_test.exs
+++ b/test/hot_reload_edge_cases_test.exs
@@ -7,7 +7,12 @@ defmodule Firebird.HotReloadEdgeCasesTest do
   describe "file change detection" do
     setup do
       # Create a temporary copy of the WASM file
-      tmp_dir = Path.join(System.tmp_dir!(), "firebird_hot_reload_test_#{:erlang.unique_integer([:positive])}")
+      tmp_dir =
+        Path.join(
+          System.tmp_dir!(),
+          "firebird_hot_reload_test_#{:erlang.unique_integer([:positive])}"
+        )
+
       File.mkdir_p!(tmp_dir)
       tmp_path = Path.join(tmp_dir, "math.wasm")
       fixture = Path.expand("../fixtures/math.wasm", __DIR__)
@@ -21,18 +26,20 @@ defmodule Firebird.HotReloadEdgeCasesTest do
     test "detects file changes and reloads", %{tmp_path: tmp_path, fixture: fixture} do
       test_pid = self()
 
-      {:ok, watcher} = Firebird.HotReload.start_link(
-        path: tmp_path,
-        interval: 100,
-        callback: fn new_pid ->
-          send(test_pid, {:reloaded, new_pid})
-        end
-      )
+      {:ok, watcher} =
+        Firebird.HotReload.start_link(
+          path: tmp_path,
+          interval: 100,
+          callback: fn new_pid ->
+            send(test_pid, {:reloaded, new_pid})
+          end
+        )
 
       {:ok, old_pid} = Firebird.HotReload.instance(watcher)
 
       # "Modify" the file by re-copying it (changes mtime)
-      Process.sleep(1100)  # Ensure mtime is different (1s granularity on some FS)
+      # Ensure mtime is different (1s granularity on some FS)
+      Process.sleep(1100)
       File.cp!(fixture, tmp_path)
 
       # Wait for the check interval to trigger reload
@@ -46,13 +53,14 @@ defmodule Firebird.HotReloadEdgeCasesTest do
     test "does not reload when file unchanged", %{tmp_path: tmp_path} do
       test_pid = self()
 
-      {:ok, watcher} = Firebird.HotReload.start_link(
-        path: tmp_path,
-        interval: 100,
-        callback: fn _new_pid ->
-          send(test_pid, :reloaded)
-        end
-      )
+      {:ok, watcher} =
+        Firebird.HotReload.start_link(
+          path: tmp_path,
+          interval: 100,
+          callback: fn _new_pid ->
+            send(test_pid, :reloaded)
+          end
+        )
 
       # Wait several check intervals
       Process.sleep(500)
@@ -64,10 +72,11 @@ defmodule Firebird.HotReloadEdgeCasesTest do
     end
 
     test "handles deleted file gracefully during check", %{tmp_path: tmp_path} do
-      {:ok, watcher} = Firebird.HotReload.start_link(
-        path: tmp_path,
-        interval: 100
-      )
+      {:ok, watcher} =
+        Firebird.HotReload.start_link(
+          path: tmp_path,
+          interval: 100
+        )
 
       # Verify initial state works
       assert {:ok, [8]} = Firebird.HotReload.call(watcher, :add, [5, 3])
@@ -100,11 +109,12 @@ defmodule Firebird.HotReloadEdgeCasesTest do
     test "handles multiple concurrent calls" do
       {:ok, watcher} = Firebird.HotReload.start_link(path: @fixture_path, interval: 60_000)
 
-      tasks = for i <- 1..10 do
-        Task.async(fn ->
-          Firebird.HotReload.call(watcher, :add, [i, i])
-        end)
-      end
+      tasks =
+        for i <- 1..10 do
+          Task.async(fn ->
+            Firebird.HotReload.call(watcher, :add, [i, i])
+          end)
+        end
 
       results = Task.await_many(tasks)
       expected = for i <- 1..10, do: {:ok, [i * 2]}
@@ -134,10 +144,11 @@ defmodule Firebird.HotReloadEdgeCasesTest do
 
   describe "stats/1 edge cases" do
     test "stats reflect correct path and interval" do
-      {:ok, watcher} = Firebird.HotReload.start_link(
-        path: @fixture_path,
-        interval: 5_000
-      )
+      {:ok, watcher} =
+        Firebird.HotReload.start_link(
+          path: @fixture_path,
+          interval: 5_000
+        )
 
       stats = Firebird.HotReload.stats(watcher)
       assert stats.path == @fixture_path
@@ -170,11 +181,12 @@ defmodule Firebird.HotReloadEdgeCasesTest do
     test "multiple rapid reloads" do
       {:ok, watcher} = Firebird.HotReload.start_link(path: @fixture_path, interval: 60_000)
 
-      pids = for _ <- 1..5 do
-        :ok = Firebird.HotReload.reload(watcher)
-        {:ok, pid} = Firebird.HotReload.instance(watcher)
-        pid
-      end
+      pids =
+        for _ <- 1..5 do
+          :ok = Firebird.HotReload.reload(watcher)
+          {:ok, pid} = Firebird.HotReload.instance(watcher)
+          pid
+        end
 
       # Each reload should produce a new instance
       pairs = Enum.zip(pids, tl(pids))
@@ -189,13 +201,14 @@ defmodule Firebird.HotReloadEdgeCasesTest do
     test "reload with callback invocation" do
       test_pid = self()
 
-      {:ok, watcher} = Firebird.HotReload.start_link(
-        path: @fixture_path,
-        interval: 60_000,
-        callback: fn new_pid ->
-          send(test_pid, {:reloaded, new_pid})
-        end
-      )
+      {:ok, watcher} =
+        Firebird.HotReload.start_link(
+          path: @fixture_path,
+          interval: 60_000,
+          callback: fn new_pid ->
+            send(test_pid, {:reloaded, new_pid})
+          end
+        )
 
       Firebird.HotReload.reload(watcher)
       assert_receive {:reloaded, pid}
@@ -315,16 +328,18 @@ defmodule Firebird.HotReloadEdgeCasesTest do
     test "uses default interval when not specified" do
       {:ok, watcher} = Firebird.HotReload.start_link(path: @fixture_path)
       stats = Firebird.HotReload.stats(watcher)
-      assert stats.interval == 2_000  # default interval
+      # default interval
+      assert stats.interval == 2_000
       Firebird.HotReload.stop(watcher)
     end
 
     test "accepts custom load opts for WASI" do
-      {:ok, watcher} = Firebird.HotReload.start_link(
-        path: @go_fixture_path,
-        opts: [wasi: true],
-        interval: 60_000
-      )
+      {:ok, watcher} =
+        Firebird.HotReload.start_link(
+          path: @go_fixture_path,
+          opts: [wasi: true],
+          interval: 60_000
+        )
 
       assert {:ok, [8]} = Firebird.HotReload.call(watcher, :add, [5, 3])
       Firebird.HotReload.stop(watcher)
@@ -333,11 +348,12 @@ defmodule Firebird.HotReloadEdgeCasesTest do
     test "starts with name option and is accessible by name" do
       name = :"hot_reload_edge_test_#{:erlang.unique_integer([:positive])}"
 
-      {:ok, _} = Firebird.HotReload.start_link(
-        path: @fixture_path,
-        name: name,
-        interval: 60_000
-      )
+      {:ok, _} =
+        Firebird.HotReload.start_link(
+          path: @fixture_path,
+          name: name,
+          interval: 60_000
+        )
 
       assert Process.whereis(name) != nil
       assert {:ok, [8]} = Firebird.HotReload.call(name, :add, [5, 3])
@@ -346,11 +362,12 @@ defmodule Firebird.HotReloadEdgeCasesTest do
     end
 
     test "no callback option means no crash on reload" do
-      {:ok, watcher} = Firebird.HotReload.start_link(
-        path: @fixture_path,
-        interval: 60_000
-        # No callback
-      )
+      {:ok, watcher} =
+        Firebird.HotReload.start_link(
+          path: @fixture_path,
+          interval: 60_000
+          # No callback
+        )
 
       :ok = Firebird.HotReload.reload(watcher)
 
diff --git a/test/hot_reload_test.exs b/test/hot_reload_test.exs
index e8e0ed4..4d249bc 100644
--- a/test/hot_reload_test.exs
+++ b/test/hot_reload_test.exs
@@ -17,11 +17,13 @@ defmodule Firebird.HotReloadTest do
     end
 
     test "starts with name option" do
-      {:ok, _} = Firebird.HotReload.start_link(
-        path: @fixture_path,
-        name: :test_hot_reload,
-        interval: 60_000
-      )
+      {:ok, _} =
+        Firebird.HotReload.start_link(
+          path: @fixture_path,
+          name: :test_hot_reload,
+          interval: 60_000
+        )
+
       assert Process.whereis(:test_hot_reload) != nil
       Firebird.HotReload.stop(:test_hot_reload)
     end
@@ -79,13 +81,14 @@ defmodule Firebird.HotReloadTest do
     test "callback is invoked on reload" do
       test_pid = self()
 
-      {:ok, watcher} = Firebird.HotReload.start_link(
-        path: @fixture_path,
-        interval: 60_000,
-        callback: fn new_pid ->
-          send(test_pid, {:reloaded, new_pid})
-        end
-      )
+      {:ok, watcher} =
+        Firebird.HotReload.start_link(
+          path: @fixture_path,
+          interval: 60_000,
+          callback: fn new_pid ->
+            send(test_pid, {:reloaded, new_pid})
+          end
+        )
 
       Firebird.HotReload.reload(watcher)
 
@@ -100,11 +103,12 @@ defmodule Firebird.HotReloadTest do
     @go_path Path.join(__DIR__, "../fixtures/go_math.wasm")
 
     test "works with Go WASM" do
-      {:ok, watcher} = Firebird.HotReload.start_link(
-        path: @go_path,
-        opts: [wasi: true],
-        interval: 60_000
-      )
+      {:ok, watcher} =
+        Firebird.HotReload.start_link(
+          path: @go_path,
+          opts: [wasi: true],
+          interval: 60_000
+        )
 
       assert {:ok, [8]} = Firebird.HotReload.call(watcher, :add, [5, 3])
       Firebird.HotReload.stop(watcher)
diff --git a/test/inspector_test.exs b/test/inspector_test.exs
index 26cd8d2..565aebe 100644
--- a/test/inspector_test.exs
+++ b/test/inspector_test.exs
@@ -79,7 +79,7 @@ defmodule Firebird.InspectorTest do
 
     test "returns error for invalid WASM bytes" do
       # Create a temp file with invalid content
-      tmp = Path.join(System.tmp_dir!(), "invalid_#{:rand.uniform(100000)}.wasm")
+      tmp = Path.join(System.tmp_dir!(), "invalid_#{:rand.uniform(100_000)}.wasm")
       File.write!(tmp, "not valid wasm bytes")
 
       result = Inspector.inspect_file(tmp)
@@ -89,7 +89,7 @@ defmodule Firebird.InspectorTest do
     end
 
     test "returns error for empty file" do
-      tmp = Path.join(System.tmp_dir!(), "empty_#{:rand.uniform(100000)}.wasm")
+      tmp = Path.join(System.tmp_dir!(), "empty_#{:rand.uniform(100_000)}.wasm")
       File.write!(tmp, "")
 
       result = Inspector.inspect_file(tmp)
@@ -127,11 +127,12 @@ defmodule Firebird.InspectorTest do
     end
 
     test "works with compiled WAT bytes" do
-      {:ok, bytes} = Firebird.compile_wat("""
-      (module
-        (func (export "get42") (result i32)
-          i32.const 42))
-      """)
+      {:ok, bytes} =
+        Firebird.compile_wat("""
+        (module
+          (func (export "get42") (result i32)
+            i32.const 42))
+        """)
 
       {:ok, info} = Inspector.inspect_bytes(bytes)
       func_names = Enum.map(info.functions, & &1.name)
@@ -139,13 +140,14 @@ defmodule Firebird.InspectorTest do
     end
 
     test "correctly identifies parameter and return types" do
-      {:ok, bytes} = Firebird.compile_wat("""
-      (module
-        (func (export "add") (param i32 i32) (result i32)
-          local.get 0
-          local.get 1
-          i32.add))
-      """)
+      {:ok, bytes} =
+        Firebird.compile_wat("""
+        (module
+          (func (export "add") (param i32 i32) (result i32)
+            local.get 0
+            local.get 1
+            i32.add))
+        """)
 
       {:ok, info} = Inspector.inspect_bytes(bytes)
       add_fn = Enum.find(info.functions, &(&1.name == "add"))
diff --git a/test/integration_test.exs b/test/integration_test.exs
index 5814338..1dd6578 100644
--- a/test/integration_test.exs
+++ b/test/integration_test.exs
@@ -8,10 +8,12 @@ defmodule Firebird.IntegrationTest do
     setup do
       {:ok, rust} = Firebird.load(@rust_path)
       {:ok, go} = Firebird.load(@go_path, wasi: true)
+
       on_exit(fn ->
         catch_exit(Firebird.stop(rust))
         catch_exit(Firebird.stop(go))
       end)
+
       {:ok, rust: rust, go: go}
     end
 
@@ -82,17 +84,19 @@ defmodule Firebird.IntegrationTest do
 
   describe "concurrent multi-instance execution" do
     test "parallel WASM calls across multiple instances" do
-      instances = for _ <- 1..4 do
-        {:ok, pid} = Firebird.load(@rust_path)
-        pid
-      end
-
-      tasks = for {inst, i} <- Enum.with_index(instances) do
-        Task.async(fn ->
-          {:ok, [result]} = Firebird.call(inst, :add, [i, i])
-          result
-        end)
-      end
+      instances =
+        for _ <- 1..4 do
+          {:ok, pid} = Firebird.load(@rust_path)
+          pid
+        end
+
+      tasks =
+        for {inst, i} <- Enum.with_index(instances) do
+          Task.async(fn ->
+            {:ok, [result]} = Firebird.call(inst, :add, [i, i])
+            result
+          end)
+        end
 
       results = Task.await_many(tasks)
       expected = for i <- 0..3, do: i * 2
@@ -104,12 +108,13 @@ defmodule Firebird.IntegrationTest do
     test "pool handles burst of concurrent requests" do
       {:ok, pool} = Firebird.start_pool(wasm_path: @rust_path, pool_size: 4)
 
-      tasks = for i <- 1..50 do
-        Task.async(fn ->
-          {:ok, [result]} = Firebird.pool_call(pool, :add, [i, i])
-          result
-        end)
-      end
+      tasks =
+        for i <- 1..50 do
+          Task.async(fn ->
+            {:ok, [result]} = Firebird.pool_call(pool, :add, [i, i])
+            result
+          end)
+        end
 
       results = Task.await_many(tasks)
       expected = for i <- 1..50, do: i * 2
@@ -225,12 +230,13 @@ defmodule Firebird.IntegrationTest do
     test "concurrent pool calls with Go WASM" do
       {:ok, pool} = Firebird.start_pool(wasm_path: @go_path, pool_size: 4, wasi: true)
 
-      tasks = for i <- 1..20 do
-        Task.async(fn ->
-          {:ok, [result]} = Firebird.pool_call(pool, :add, [i, i])
-          result
-        end)
-      end
+      tasks =
+        for i <- 1..20 do
+          Task.async(fn ->
+            {:ok, [result]} = Firebird.pool_call(pool, :add, [i, i])
+            result
+          end)
+        end
 
       results = Task.await_many(tasks)
       expected = for i <- 1..20, do: i * 2
@@ -246,6 +252,7 @@ defmodule Firebird.IntegrationTest do
         {:ok, _pid} -> :ok
         {:error, {:already_started, _pid}} -> :ok
       end
+
       Firebird.ModuleCache.clear()
       :ok
     end
diff --git a/test/lazy_call_one_test.exs b/test/lazy_call_one_test.exs
index 1a72397..837e7af 100644
--- a/test/lazy_call_one_test.exs
+++ b/test/lazy_call_one_test.exs
@@ -5,9 +5,11 @@ defmodule Firebird.LazyCallOneTest do
 
   setup do
     {:ok, lazy} = Firebird.Lazy.start_link(wasm: @sample)
+
     on_exit(fn ->
       if Process.alive?(lazy), do: Firebird.Lazy.stop(lazy)
     end)
+
     {:ok, lazy: lazy}
   end
 
diff --git a/test/lazy_comprehensive_test.exs b/test/lazy_comprehensive_test.exs
index 7138c04..4b93e13 100644
--- a/test/lazy_comprehensive_test.exs
+++ b/test/lazy_comprehensive_test.exs
@@ -47,9 +47,11 @@ defmodule Firebird.LazyComprehensiveTest do
 
     test "raises on error" do
       {:ok, lazy} = Firebird.Lazy.start_link(wasm: @math_wasm)
+
       assert_raise RuntimeError, ~r/Lazy WASM call failed/, fn ->
         Firebird.Lazy.call_one!(lazy, :nonexistent, [1])
       end
+
       Firebird.Lazy.stop(lazy)
     end
   end
@@ -78,9 +80,11 @@ defmodule Firebird.LazyComprehensiveTest do
 
     test "call! raises when wasm source is invalid" do
       {:ok, lazy} = Firebird.Lazy.start_link(wasm: "nonexistent.wasm")
+
       assert_raise RuntimeError, ~r/Lazy WASM call failed/, fn ->
         Firebird.Lazy.call!(lazy, :add, [1, 2])
       end
+
       Firebird.Lazy.stop(lazy)
     end
 
@@ -92,9 +96,11 @@ defmodule Firebird.LazyComprehensiveTest do
 
     test "call_one! raises when wasm source is invalid" do
       {:ok, lazy} = Firebird.Lazy.start_link(wasm: "nonexistent.wasm")
+
       assert_raise RuntimeError, ~r/Lazy WASM call failed/, fn ->
         Firebird.Lazy.call_one!(lazy, :add, [1, 2])
       end
+
       Firebird.Lazy.stop(lazy)
     end
   end
@@ -119,10 +125,11 @@ defmodule Firebird.LazyComprehensiveTest do
     test "state persists across calls" do
       {:ok, lazy} = Firebird.Lazy.start_link(wasm: @math_wasm)
 
-      results = for i <- 1..10 do
-        {:ok, result} = Firebird.Lazy.call_one(lazy, :add, [i, i])
-        result
-      end
+      results =
+        for i <- 1..10 do
+          {:ok, result} = Firebird.Lazy.call_one(lazy, :add, [i, i])
+          result
+        end
 
       assert results == Enum.map(1..10, &(&1 * 2))
       Firebird.Lazy.stop(lazy)
@@ -242,9 +249,14 @@ defmodule Firebird.LazyComprehensiveTest do
   describe "wasm_runner run_concurrent" do
     test "runs concurrent calls across multiple instances" do
       args_list = for n <- 1..20, do: [n, n]
-      {:ok, results} = Firebird.WasmRunner.run_concurrent(
-        @math_wasm, :add, args_list, concurrency: 2
-      )
+
+      {:ok, results} =
+        Firebird.WasmRunner.run_concurrent(
+          @math_wasm,
+          :add,
+          args_list,
+          concurrency: 2
+        )
 
       assert length(results) == 20
       expected = for n <- 1..20, do: n * 2
@@ -253,9 +265,14 @@ defmodule Firebird.LazyComprehensiveTest do
 
     test "runs concurrent fibonacci" do
       args_list = for n <- 0..10, do: [n]
-      {:ok, results} = Firebird.WasmRunner.run_concurrent(
-        @math_wasm, :fibonacci, args_list, concurrency: 2
-      )
+
+      {:ok, results} =
+        Firebird.WasmRunner.run_concurrent(
+          @math_wasm,
+          :fibonacci,
+          args_list,
+          concurrency: 2
+        )
 
       assert length(results) == 11
       assert Enum.at(results, 0) == 0
@@ -265,16 +282,24 @@ defmodule Firebird.LazyComprehensiveTest do
 
     test "throws for nonexistent file" do
       assert catch_throw(
-        Firebird.WasmRunner.run_concurrent(
-          "nonexistent.wasm", :add, [[1, 2]], concurrency: 1
-        )
-      ) == {:start_error, {:file_error, :enoent, "nonexistent.wasm"}}
+               Firebird.WasmRunner.run_concurrent(
+                 "nonexistent.wasm",
+                 :add,
+                 [[1, 2]],
+                 concurrency: 1
+               )
+             ) == {:start_error, {:file_error, :enoent, "nonexistent.wasm"}}
     end
 
     test "empty args list returns empty results" do
-      {:ok, results} = Firebird.WasmRunner.run_concurrent(
-        @math_wasm, :add, [], concurrency: 2
-      )
+      {:ok, results} =
+        Firebird.WasmRunner.run_concurrent(
+          @math_wasm,
+          :add,
+          [],
+          concurrency: 2
+        )
+
       assert results == []
     end
   end
diff --git a/test/lazy_edge_cases_test.exs b/test/lazy_edge_cases_test.exs
index c50c4c3..ac98728 100644
--- a/test/lazy_edge_cases_test.exs
+++ b/test/lazy_edge_cases_test.exs
@@ -47,9 +47,11 @@ defmodule Firebird.LazyEdgeCasesTest do
 
     test "raises on error" do
       {:ok, lazy} = Firebird.Lazy.start_link(wasm: @math_wasm)
+
       assert_raise RuntimeError, ~r/Lazy WASM call failed/, fn ->
         Firebird.Lazy.call_one!(lazy, :nonexistent, [1])
       end
+
       Firebird.Lazy.stop(lazy)
     end
   end
diff --git a/test/lazy_test.exs b/test/lazy_test.exs
index a124896..486968e 100644
--- a/test/lazy_test.exs
+++ b/test/lazy_test.exs
@@ -60,9 +60,11 @@ defmodule Firebird.LazyTest do
 
     test "raises on error" do
       {:ok, lazy} = Firebird.Lazy.start_link(wasm: @math_wasm)
+
       assert_raise RuntimeError, fn ->
         Firebird.Lazy.call!(lazy, :nonexistent, [1])
       end
+
       Firebird.Lazy.stop(lazy)
     end
   end
diff --git a/test/memory_allocator_test.exs b/test/memory_allocator_test.exs
index 9385b53..5ea071b 100644
--- a/test/memory_allocator_test.exs
+++ b/test/memory_allocator_test.exs
@@ -33,7 +33,8 @@ defmodule Firebird.MemoryAllocatorTest do
 
     test "aligns base_offset up when needed", %{wasm: pid} do
       alloc = Memory.new(pid, base_offset: 1025, alignment: 8)
-      assert alloc.base_offset == 1032  # next 8-aligned offset after 1025
+      # next 8-aligned offset after 1025
+      assert alloc.base_offset == 1032
     end
 
     test "respects custom base_offset", %{wasm: pid} do
@@ -56,7 +57,8 @@ defmodule Firebird.MemoryAllocatorTest do
     test "allocates at base offset first", %{alloc: alloc} do
       {alloc, offset} = Memory.alloc(alloc, 16)
       assert offset == 1024
-      assert alloc.cursor == 1024 + 16  # 16 is already 8-aligned
+      # 16 is already 8-aligned
+      assert alloc.cursor == 1024 + 16
     end
 
     test "sequential allocations don't overlap", %{alloc: alloc} do
@@ -65,7 +67,8 @@ defmodule Firebird.MemoryAllocatorTest do
       {_alloc, off3} = Memory.alloc(alloc, 10)
 
       assert off1 == 1024
-      assert off2 == 1024 + 16  # 10 bytes, aligned up to 16
+      # 10 bytes, aligned up to 16
+      assert off2 == 1024 + 16
       assert off3 == 1024 + 32
     end
 
@@ -73,7 +76,8 @@ defmodule Firebird.MemoryAllocatorTest do
       {alloc, off1} = Memory.alloc(alloc, 0)
       {_alloc, off2} = Memory.alloc(alloc, 8)
       assert off1 == 1024
-      assert off2 == 1024  # zero alloc doesn't advance cursor
+      # zero alloc doesn't advance cursor
+      assert off2 == 1024
     end
 
     test "tracks allocations", %{alloc: alloc} do
@@ -150,7 +154,8 @@ defmodule Firebird.MemoryAllocatorTest do
 
     test "null-terminated string", %{alloc: alloc} do
       {alloc, ptr, len} = Memory.write_string(alloc, "hello", null_terminated: true)
-      assert len == 5  # logical length excludes NUL
+      # logical length excludes NUL
+      assert len == 5
       # Read 6 bytes to verify NUL is there
       {:ok, raw} = Memory.read_bytes(alloc, ptr, 6)
       assert raw == "hello\0"
@@ -252,7 +257,9 @@ defmodule Firebird.MemoryAllocatorTest do
       {alloc, ptr, count} = Memory.write_f32_array(alloc, values)
       {:ok, result} = Memory.read_f32_array(alloc, ptr, count)
       assert length(result) == 4
-      Enum.zip(values, result) |> Enum.each(fn {expected, actual} ->
+
+      Enum.zip(values, result)
+      |> Enum.each(fn {expected, actual} ->
         assert_in_delta actual, expected, 0.001
       end)
     end
@@ -272,7 +279,9 @@ defmodule Firebird.MemoryAllocatorTest do
       {alloc, ptr, count} = Memory.write_f64_array(alloc, values)
       assert count == 4
       {:ok, result} = Memory.read_f64_array(alloc, ptr, count)
-      Enum.zip(values, result) |> Enum.each(fn {expected, actual} ->
+
+      Enum.zip(values, result)
+      |> Enum.each(fn {expected, actual} ->
         assert_in_delta actual, expected, 1.0e-10
       end)
     end
@@ -281,7 +290,9 @@ defmodule Firebird.MemoryAllocatorTest do
       values = for i <- 1..100, do: i * 1.1
       {alloc, ptr, count} = Memory.write_f64_array(alloc, values)
       {:ok, result} = Memory.read_f64_array(alloc, ptr, count)
-      Enum.zip(values, result) |> Enum.each(fn {expected, actual} ->
+
+      Enum.zip(values, result)
+      |> Enum.each(fn {expected, actual} ->
         assert_in_delta actual, expected, 1.0e-10
       end)
     end
@@ -408,11 +419,12 @@ defmodule Firebird.MemoryAllocatorTest do
       {alloc, _outer_ptr, _} = Memory.write_string(alloc, "permanent")
       bytes_before = Memory.allocated_bytes(alloc)
 
-      {result, alloc} = Memory.with_arena(alloc, fn alloc ->
-        {alloc, ptr, len} = Memory.write_string(alloc, "temporary")
-        {:ok, str} = Memory.read_string(alloc, ptr, len)
-        {str, alloc}
-      end)
+      {result, alloc} =
+        Memory.with_arena(alloc, fn alloc ->
+          {alloc, ptr, len} = Memory.write_string(alloc, "temporary")
+          {:ok, str} = Memory.read_string(alloc, ptr, len)
+          {str, alloc}
+        end)
 
       assert result == "temporary"
       # Cursor should be back to where it was before the arena
@@ -420,18 +432,20 @@ defmodule Firebird.MemoryAllocatorTest do
     end
 
     test "nested arenas", %{alloc: alloc} do
-      {result, alloc} = Memory.with_arena(alloc, fn alloc ->
-        {alloc, _, _} = Memory.write_string(alloc, "outer")
-
-        {inner_result, alloc} = Memory.with_arena(alloc, fn alloc ->
-          {alloc, ptr, len} = Memory.write_string(alloc, "inner")
-          {:ok, str} = Memory.read_string(alloc, ptr, len)
-          {str, alloc}
+      {result, alloc} =
+        Memory.with_arena(alloc, fn alloc ->
+          {alloc, _, _} = Memory.write_string(alloc, "outer")
+
+          {inner_result, alloc} =
+            Memory.with_arena(alloc, fn alloc ->
+              {alloc, ptr, len} = Memory.write_string(alloc, "inner")
+              {:ok, str} = Memory.read_string(alloc, ptr, len)
+              {str, alloc}
+            end)
+
+          {inner_result, alloc}
         end)
 
-        {inner_result, alloc}
-      end)
-
       assert result == "inner"
       assert Memory.allocated_bytes(alloc) == 0
     end
@@ -500,14 +514,17 @@ defmodule Firebird.MemoryAllocatorTest do
     test "arena pattern for batch processing", %{alloc: alloc, wasm: pid} do
       strings = ["alpha", "beta", "gamma", "delta"]
 
-      hashes = Enum.map(strings, fn s ->
-        {hash, _alloc} = Memory.with_arena(alloc, fn alloc ->
-          {alloc, ptr, len} = Memory.write_string(alloc, s)
-          {:ok, [h]} = Firebird.call(pid, :hash_djb2, [ptr, len])
-          {h, alloc}
+      hashes =
+        Enum.map(strings, fn s ->
+          {hash, _alloc} =
+            Memory.with_arena(alloc, fn alloc ->
+              {alloc, ptr, len} = Memory.write_string(alloc, s)
+              {:ok, [h]} = Firebird.call(pid, :hash_djb2, [ptr, len])
+              {h, alloc}
+            end)
+
+          hash
         end)
-        hash
-      end)
 
       # All hashes should be different
       assert length(Enum.uniq(hashes)) == length(strings)
@@ -535,16 +552,19 @@ defmodule Firebird.MemoryAllocatorTest do
       assert off2 == 1032
     end
 
-    test "1-byte alignment means no padding", do: (
-      {:ok, pid} = Firebird.load(@math_wasm)
-      alloc = Memory.new(pid, alignment: 1)
+    test "1-byte alignment means no padding",
+      do:
+        (
+          {:ok, pid} = Firebird.load(@math_wasm)
+          alloc = Memory.new(pid, alignment: 1)
 
-      {alloc, off1} = Memory.alloc(alloc, 3)
-      {_alloc, off2} = Memory.alloc(alloc, 1)
-      assert off2 == off1 + 3  # No padding
+          {alloc, off1} = Memory.alloc(alloc, 3)
+          {_alloc, off2} = Memory.alloc(alloc, 1)
+          # No padding
+          assert off2 == off1 + 3
 
-      Firebird.stop(pid)
-    )
+          Firebird.stop(pid)
+        )
 
     test "allocations list is most-recent-first", %{alloc: alloc} do
       {alloc, _, _} = Memory.write_bytes(alloc, <<1>>)
diff --git a/test/memory_layout_unit_test.exs b/test/memory_layout_unit_test.exs
index c0d1670..711e7e5 100644
--- a/test/memory_layout_unit_test.exs
+++ b/test/memory_layout_unit_test.exs
@@ -97,7 +97,8 @@ defmodule Firebird.MemoryLayoutUnitTest do
 
       assert layout.offsets[:a] == 0
       assert layout.offsets[:b] == 1
-      assert layout.offsets[:c] == 4  # aligned to 4
+      # aligned to 4
+      assert layout.offsets[:c] == 4
       assert layout.size == 8
     end
 
@@ -105,7 +106,8 @@ defmodule Firebird.MemoryLayoutUnitTest do
       layout = Memory.define_layout([{:short, :i16}, {:long, :i64}])
 
       assert layout.offsets[:short] == 0
-      assert layout.offsets[:long] == 8  # aligned to 8
+      # aligned to 8
+      assert layout.offsets[:long] == 8
       assert layout.size == 16
     end
 
@@ -120,12 +122,13 @@ defmodule Firebird.MemoryLayoutUnitTest do
 
     test "complex C-like struct: {f64, f64, i32, u8}" do
       # Mimics a typical Point struct: x, y, id, flags
-      layout = Memory.define_layout([
-        {:x, :f64},
-        {:y, :f64},
-        {:id, :i32},
-        {:flags, :u8}
-      ])
+      layout =
+        Memory.define_layout([
+          {:x, :f64},
+          {:y, :f64},
+          {:id, :i32},
+          {:flags, :u8}
+        ])
 
       assert layout.offsets[:x] == 0
       assert layout.offsets[:y] == 8
@@ -137,20 +140,32 @@ defmodule Firebird.MemoryLayoutUnitTest do
 
     test "all integer types have correct sizes" do
       for {type, expected_size} <- [
-        {:i8, 1}, {:u8, 1}, {:i16, 2}, {:u16, 2},
-        {:i32, 4}, {:u32, 4}, {:i64, 8}, {:u64, 8},
-        {:f32, 4}, {:f64, 8}
-      ] do
+            {:i8, 1},
+            {:u8, 1},
+            {:i16, 2},
+            {:u16, 2},
+            {:i32, 4},
+            {:u32, 4},
+            {:i64, 8},
+            {:u64, 8},
+            {:f32, 4},
+            {:f64, 8}
+          ] do
         layout = Memory.define_layout([{:val, type}])
+
         assert layout.size == expected_size,
-          "Expected #{type} layout size to be #{expected_size}, got #{layout.size}"
+               "Expected #{type} layout size to be #{expected_size}, got #{layout.size}"
       end
     end
 
     test "homogeneous struct — no padding between same-type fields" do
-      layout = Memory.define_layout([
-        {:a, :i32}, {:b, :i32}, {:c, :i32}, {:d, :i32}
-      ])
+      layout =
+        Memory.define_layout([
+          {:a, :i32},
+          {:b, :i32},
+          {:c, :i32},
+          {:d, :i32}
+        ])
 
       assert layout.offsets == %{a: 0, b: 4, c: 8, d: 12}
       assert layout.size == 16
@@ -168,7 +183,8 @@ defmodule Firebird.MemoryLayoutUnitTest do
       layout = Memory.define_layout([{:a, :u8}, {:b, :i16}, {:c, :u8}])
 
       assert layout.offsets[:a] == 0
-      assert layout.offsets[:b] == 2   # aligned to 2
+      # aligned to 2
+      assert layout.offsets[:b] == 2
       assert layout.offsets[:c] == 4
       # cursor = 5, max_align = 2 → padded to 6
       assert layout.size == 6
@@ -279,7 +295,8 @@ defmodule Firebird.MemoryLayoutUnitTest do
 
       # Allocate 1 byte — cursor advances by 1, then aligned to 8 → 8 bytes consumed
       {alloc, _ptr} = Memory.alloc(alloc, 1)
-      assert Memory.allocated_bytes(alloc) == 8  # 1 byte + 7 padding
+      # 1 byte + 7 padding
+      assert Memory.allocated_bytes(alloc) == 8
 
       cleanup(pid)
     end
@@ -422,10 +439,11 @@ defmodule Firebird.MemoryLayoutUnitTest do
 
       cursor_before = alloc.cursor
 
-      {result, alloc} = Memory.with_arena(alloc, fn a ->
-        {a, _ptr, _len} = Memory.write_string(a, "temporary data")
-        {"done", a}
-      end)
+      {result, alloc} =
+        Memory.with_arena(alloc, fn a ->
+          {a, _ptr, _len} = Memory.write_string(a, "temporary data")
+          {"done", a}
+        end)
 
       assert result == "done"
       assert alloc.cursor == cursor_before
@@ -440,10 +458,11 @@ defmodule Firebird.MemoryLayoutUnitTest do
       {alloc, _ptr} = Memory.alloc(alloc, 64)
       count_before = Memory.allocation_count(alloc)
 
-      {_result, alloc} = Memory.with_arena(alloc, fn a ->
-        {a, _} = Memory.alloc(a, 128)
-        {:ok, a}
-      end)
+      {_result, alloc} =
+        Memory.with_arena(alloc, fn a ->
+          {a, _} = Memory.alloc(a, 128)
+          {:ok, a}
+        end)
 
       assert Memory.allocation_count(alloc) == count_before
 
@@ -455,16 +474,18 @@ defmodule Firebird.MemoryLayoutUnitTest do
 
       cursor_start = alloc.cursor
 
-      {_result, alloc} = Memory.with_arena(alloc, fn a1 ->
-        {a1, _} = Memory.alloc(a1, 100)
+      {_result, alloc} =
+        Memory.with_arena(alloc, fn a1 ->
+          {a1, _} = Memory.alloc(a1, 100)
 
-        {_inner, a1} = Memory.with_arena(a1, fn a2 ->
-          {a2, _} = Memory.alloc(a2, 200)
-          {:inner_done, a2}
-        end)
+          {_inner, a1} =
+            Memory.with_arena(a1, fn a2 ->
+              {a2, _} = Memory.alloc(a2, 200)
+              {:inner_done, a2}
+            end)
 
-        {:outer_done, a1}
-      end)
+          {:outer_done, a1}
+        end)
 
       assert alloc.cursor == cursor_start
 
@@ -627,9 +648,9 @@ defmodule Firebird.MemoryLayoutUnitTest do
     test "basic values" do
       {alloc, pid} = new_alloc()
 
-      {alloc, ptr, count} = Memory.write_u32_array(alloc, [0, 255, 65535, 4294967295])
+      {alloc, ptr, count} = Memory.write_u32_array(alloc, [0, 255, 65535, 4_294_967_295])
       {:ok, values} = Memory.read_u32_array(alloc, ptr, count)
-      assert values == [0, 255, 65535, 4294967295]
+      assert values == [0, 255, 65535, 4_294_967_295]
 
       cleanup(pid)
     end
@@ -805,12 +826,28 @@ defmodule Firebird.MemoryLayoutUnitTest do
     test "struct with all integer types" do
       {alloc, pid} = new_alloc()
 
-      layout = Memory.define_layout([
-        {:a, :i8}, {:b, :u8}, {:c, :i16}, {:d, :u16},
-        {:e, :i32}, {:f, :u32}, {:g, :i64}, {:h, :u64}
-      ])
-
-      values = %{a: -1, b: 255, c: -1000, d: 60000, e: -100000, f: 3000000000, g: -9999999, h: 18446744073709551615}
+      layout =
+        Memory.define_layout([
+          {:a, :i8},
+          {:b, :u8},
+          {:c, :i16},
+          {:d, :u16},
+          {:e, :i32},
+          {:f, :u32},
+          {:g, :i64},
+          {:h, :u64}
+        ])
+
+      values = %{
+        a: -1,
+        b: 255,
+        c: -1000,
+        d: 60000,
+        e: -100_000,
+        f: 3_000_000_000,
+        g: -9_999_999,
+        h: 18_446_744_073_709_551_615
+      }
 
       {alloc, ptr} = Memory.write_struct(alloc, layout, values)
       {:ok, result} = Memory.read_struct(alloc, layout, ptr)
@@ -819,10 +856,10 @@ defmodule Firebird.MemoryLayoutUnitTest do
       assert result.b == 255
       assert result.c == -1000
       assert result.d == 60000
-      assert result.e == -100000
-      assert result.f == 3000000000
-      assert result.g == -9999999
-      assert result.h == 18446744073709551615
+      assert result.e == -100_000
+      assert result.f == 3_000_000_000
+      assert result.g == -9_999_999
+      assert result.h == 18_446_744_073_709_551_615
 
       cleanup(pid)
     end
@@ -836,7 +873,8 @@ defmodule Firebird.MemoryLayoutUnitTest do
       {alloc, ptr} = Memory.write_struct(alloc, layout, values)
       {:ok, result} = Memory.read_struct(alloc, layout, ptr)
 
-      assert_in_delta result.a, 3.14, 0.01  # f32 has less precision
+      # f32 has less precision
+      assert_in_delta result.a, 3.14, 0.01
       assert_in_delta result.b, 2.718281828, 0.00000001
 
       cleanup(pid)
@@ -860,6 +898,7 @@ defmodule Firebird.MemoryLayoutUnitTest do
       {alloc, pid} = new_alloc()
 
       layout = Memory.define_layout([{:x, :f64}, {:y, :f64}])
+
       points = [
         %{x: 1.0, y: 2.0},
         %{x: 3.0, y: 4.0},
@@ -954,7 +993,8 @@ defmodule Firebird.MemoryLayoutUnitTest do
       {alloc, pid} = new_alloc()
 
       {alloc, ptr} = Memory.alloc(alloc, 10_000)
-      assert ptr == 1024  # first allocation at base
+      # first allocation at base
+      assert ptr == 1024
       assert Memory.allocated_bytes(alloc) >= 10_000
 
       cleanup(pid)
diff --git a/test/memory_operations_test.exs b/test/memory_operations_test.exs
index 73b848f..ae571a3 100644
--- a/test/memory_operations_test.exs
+++ b/test/memory_operations_test.exs
@@ -6,9 +6,11 @@ defmodule MemoryOperationsTest do
 
   setup do
     {:ok, instance} = Firebird.load(@wasm_path)
+
     on_exit(fn ->
       if Process.alive?(instance), do: Firebird.stop(instance)
     end)
+
     %{wasm: instance}
   end
 
diff --git a/test/memory_struct_layout_test.exs b/test/memory_struct_layout_test.exs
index f081952..840ac2e 100644
--- a/test/memory_struct_layout_test.exs
+++ b/test/memory_struct_layout_test.exs
@@ -23,11 +23,12 @@ defmodule Firebird.MemoryStructLayoutTest do
     end
 
     test "mixed types with natural alignment" do
-      layout = Memory.define_layout([
-        {:flags, :u8},
-        {:id, :i32},
-        {:value, :f64}
-      ])
+      layout =
+        Memory.define_layout([
+          {:flags, :u8},
+          {:id, :i32},
+          {:value, :f64}
+        ])
 
       # u8 at 0, then padding to align i32 at 4, then i32 at 4, then f64 at 8
       assert layout.offsets[:flags] == 0
@@ -44,27 +45,44 @@ defmodule Firebird.MemoryStructLayoutTest do
     end
 
     test "all integer types" do
-      layout = Memory.define_layout([
-        {:a, :i8}, {:b, :u8}, {:c, :i16}, {:d, :u16},
-        {:e, :i32}, {:f, :u32}, {:g, :i64}, {:h, :u64}
-      ])
-
-      assert layout.offsets[:a] == 0    # 1 byte
-      assert layout.offsets[:b] == 1    # 1 byte
-      assert layout.offsets[:c] == 2    # 2 bytes, aligned to 2
-      assert layout.offsets[:d] == 4    # 2 bytes, aligned to 2
-      assert layout.offsets[:e] == 8    # 4 bytes, aligned to 4 -> next 4-boundary after 6
-      assert layout.offsets[:f] == 12   # 4 bytes
-      assert layout.offsets[:g] == 16   # 8 bytes, aligned to 8
-      assert layout.offsets[:h] == 24   # 8 bytes
-      assert layout.size == 32          # padded to max alignment (8)
+      layout =
+        Memory.define_layout([
+          {:a, :i8},
+          {:b, :u8},
+          {:c, :i16},
+          {:d, :u16},
+          {:e, :i32},
+          {:f, :u32},
+          {:g, :i64},
+          {:h, :u64}
+        ])
+
+      # 1 byte
+      assert layout.offsets[:a] == 0
+      # 1 byte
+      assert layout.offsets[:b] == 1
+      # 2 bytes, aligned to 2
+      assert layout.offsets[:c] == 2
+      # 2 bytes, aligned to 2
+      assert layout.offsets[:d] == 4
+      # 4 bytes, aligned to 4 -> next 4-boundary after 6
+      assert layout.offsets[:e] == 8
+      # 4 bytes
+      assert layout.offsets[:f] == 12
+      # 8 bytes, aligned to 8
+      assert layout.offsets[:g] == 16
+      # 8 bytes
+      assert layout.offsets[:h] == 24
+      # padded to max alignment (8)
+      assert layout.size == 32
     end
 
     test "float types" do
       layout = Memory.define_layout([{:a, :f32}, {:b, :f64}])
 
       assert layout.offsets[:a] == 0
-      assert layout.offsets[:b] == 8    # aligned to 8
+      # aligned to 8
+      assert layout.offsets[:b] == 8
       assert layout.size == 16
     end
 
@@ -103,12 +121,13 @@ defmodule Firebird.MemoryStructLayoutTest do
     end
 
     test "round-trip mixed-type struct", %{alloc: alloc} do
-      layout = Memory.define_layout([
-        {:id, :i32},
-        {:x, :f64},
-        {:y, :f64},
-        {:flags, :u8}
-      ])
+      layout =
+        Memory.define_layout([
+          {:id, :i32},
+          {:x, :f64},
+          {:y, :f64},
+          {:flags, :u8}
+        ])
 
       data = %{id: 42, x: 1.5, y: -2.5, flags: 255}
       {alloc, ptr} = Memory.write_struct(alloc, layout, data)
@@ -121,14 +140,28 @@ defmodule Firebird.MemoryStructLayoutTest do
     end
 
     test "round-trip all integer types", %{alloc: alloc} do
-      layout = Memory.define_layout([
-        {:a, :i8}, {:b, :u8}, {:c, :i16}, {:d, :u16},
-        {:e, :i32}, {:f, :u32}, {:g, :i64}, {:h, :u64}
-      ])
-
-      data = %{a: -128, b: 255, c: -32768, d: 65535,
-               e: -2_147_483_648, f: 4_294_967_295,
-               g: -9_223_372_036_854_775_808, h: 18_446_744_073_709_551_615}
+      layout =
+        Memory.define_layout([
+          {:a, :i8},
+          {:b, :u8},
+          {:c, :i16},
+          {:d, :u16},
+          {:e, :i32},
+          {:f, :u32},
+          {:g, :i64},
+          {:h, :u64}
+        ])
+
+      data = %{
+        a: -128,
+        b: 255,
+        c: -32768,
+        d: 65535,
+        e: -2_147_483_648,
+        f: 4_294_967_295,
+        g: -9_223_372_036_854_775_808,
+        h: 18_446_744_073_709_551_615
+      }
 
       {alloc, ptr} = Memory.write_struct(alloc, layout, data)
       {:ok, result} = Memory.read_struct(alloc, layout, ptr)
@@ -193,7 +226,8 @@ defmodule Firebird.MemoryStructLayoutTest do
       {:ok, result} = Memory.read_struct_array(alloc, layout, ptr, count)
       assert length(result) == 3
 
-      Enum.zip(points, result) |> Enum.each(fn {expected, actual} ->
+      Enum.zip(points, result)
+      |> Enum.each(fn {expected, actual} ->
         assert_in_delta actual.x, expected.x, 1.0e-10
         assert_in_delta actual.y, expected.y, 1.0e-10
       end)
@@ -211,7 +245,8 @@ defmodule Firebird.MemoryStructLayoutTest do
       {alloc, ptr, 3} = Memory.write_struct_array(alloc, layout, items)
       {:ok, result} = Memory.read_struct_array(alloc, layout, ptr, 3)
 
-      Enum.zip(items, result) |> Enum.each(fn {expected, actual} ->
+      Enum.zip(items, result)
+      |> Enum.each(fn {expected, actual} ->
         assert actual.id == expected.id
         assert_in_delta actual.value, expected.value, 1.0e-10
         assert actual.active == expected.active
@@ -233,15 +268,18 @@ defmodule Firebird.MemoryStructLayoutTest do
     test "large struct array", %{alloc: alloc} do
       layout = Memory.define_layout([{:id, :i32}, {:x, :f64}, {:y, :f64}])
 
-      items = for i <- 1..100 do
-        %{id: i, x: i * 1.1, y: i * 2.2}
-      end
+      items =
+        for i <- 1..100 do
+          %{id: i, x: i * 1.1, y: i * 2.2}
+        end
 
       {alloc, ptr, 100} = Memory.write_struct_array(alloc, layout, items)
       {:ok, result} = Memory.read_struct_array(alloc, layout, ptr, 100)
 
       assert length(result) == 100
-      Enum.zip(items, result) |> Enum.each(fn {expected, actual} ->
+
+      Enum.zip(items, result)
+      |> Enum.each(fn {expected, actual} ->
         assert actual.id == expected.id
         assert_in_delta actual.x, expected.x, 1.0e-6
         assert_in_delta actual.y, expected.y, 1.0e-6
@@ -255,11 +293,12 @@ defmodule Firebird.MemoryStructLayoutTest do
     test "structs work within arena scope", %{alloc: alloc} do
       layout = Memory.define_layout([{:x, :i32}, {:y, :i32}])
 
-      {result, alloc} = Memory.with_arena(alloc, fn alloc ->
-        {alloc, ptr} = Memory.write_struct(alloc, layout, %{x: 10, y: 20})
-        {:ok, point} = Memory.read_struct(alloc, layout, ptr)
-        {point, alloc}
-      end)
+      {result, alloc} =
+        Memory.with_arena(alloc, fn alloc ->
+          {alloc, ptr} = Memory.write_struct(alloc, layout, %{x: 10, y: 20})
+          {:ok, point} = Memory.read_struct(alloc, layout, ptr)
+          {point, alloc}
+        end)
 
       assert result == %{x: 10, y: 20}
       assert Memory.allocated_bytes(alloc) == 0
@@ -269,11 +308,12 @@ defmodule Firebird.MemoryStructLayoutTest do
       layout = Memory.define_layout([{:val, :f64}])
       items = for i <- 1..10, do: %{val: i * 0.5}
 
-      {result, alloc} = Memory.with_arena(alloc, fn alloc ->
-        {alloc, ptr, count} = Memory.write_struct_array(alloc, layout, items)
-        {:ok, read_back} = Memory.read_struct_array(alloc, layout, ptr, count)
-        {read_back, alloc}
-      end)
+      {result, alloc} =
+        Memory.with_arena(alloc, fn alloc ->
+          {alloc, ptr, count} = Memory.write_struct_array(alloc, layout, items)
+          {:ok, read_back} = Memory.read_struct_array(alloc, layout, ptr, count)
+          {read_back, alloc}
+        end)
 
       assert length(result) == 10
       assert Memory.allocated_bytes(alloc) == 0
@@ -299,7 +339,8 @@ defmodule Firebird.MemoryStructLayoutTest do
       # We model this directly with alignment handling
       layout = Memory.define_layout([{:tag, :u8}, {:value, :f64}])
       assert layout.offsets[:tag] == 0
-      assert layout.offsets[:value] == 8  # naturally aligned to 8
+      # naturally aligned to 8
+      assert layout.offsets[:value] == 8
 
       {alloc, ptr} = Memory.write_struct(alloc, layout, %{tag: 1, value: 42.5})
       {:ok, result} = Memory.read_struct(alloc, layout, ptr)
@@ -309,38 +350,48 @@ defmodule Firebird.MemoryStructLayoutTest do
 
     test "Go TinyGo-style slice header", %{alloc: alloc} do
       # Go slice: struct { ptr i32; len i32; cap i32 }
-      slice_layout = Memory.define_layout([
-        {:ptr, :i32},
-        {:len, :i32},
-        {:cap, :i32}
-      ])
+      slice_layout =
+        Memory.define_layout([
+          {:ptr, :i32},
+          {:len, :i32},
+          {:cap, :i32}
+        ])
+
       assert slice_layout.size == 12
 
-      {alloc, header_ptr} = Memory.write_struct(
-        alloc, slice_layout, %{ptr: 2048, len: 10, cap: 20}
-      )
+      {alloc, header_ptr} =
+        Memory.write_struct(
+          alloc,
+          slice_layout,
+          %{ptr: 2048, len: 10, cap: 20}
+        )
+
       {:ok, header} = Memory.read_struct(alloc, slice_layout, header_ptr)
       assert header == %{ptr: 2048, len: 10, cap: 20}
     end
 
     test "particle system batch write", %{alloc: alloc} do
-      particle_layout = Memory.define_layout([
-        {:x, :f32},
-        {:y, :f32},
-        {:vx, :f32},
-        {:vy, :f32},
-        {:mass, :f32},
-        {:active, :u8}
-      ])
-
-      particles = for i <- 1..50 do
-        %{
-          x: i * 1.0, y: i * 2.0,
-          vx: i * 0.1, vy: i * -0.1,
-          mass: 1.0 + i * 0.01,
-          active: if(rem(i, 3) == 0, do: 0, else: 1)
-        }
-      end
+      particle_layout =
+        Memory.define_layout([
+          {:x, :f32},
+          {:y, :f32},
+          {:vx, :f32},
+          {:vy, :f32},
+          {:mass, :f32},
+          {:active, :u8}
+        ])
+
+      particles =
+        for i <- 1..50 do
+          %{
+            x: i * 1.0,
+            y: i * 2.0,
+            vx: i * 0.1,
+            vy: i * -0.1,
+            mass: 1.0 + i * 0.01,
+            active: if(rem(i, 3) == 0, do: 0, else: 1)
+          }
+        end
 
       {alloc, ptr, 50} = Memory.write_struct_array(alloc, particle_layout, particles)
       {:ok, result} = Memory.read_struct_array(alloc, particle_layout, ptr, 50)
diff --git a/test/metrics_comprehensive_test.exs b/test/metrics_comprehensive_test.exs
index 797ef28..d8d2574 100644
--- a/test/metrics_comprehensive_test.exs
+++ b/test/metrics_comprehensive_test.exs
@@ -245,11 +245,13 @@ defmodule Firebird.MetricsComprehensiveTest do
 
     test "report reflects all function calls", %{pid: pid} do
       functions = [:add, :multiply, :fibonacci, :subtract, :is_prime]
+
       for func <- functions do
         Firebird.Metrics.timed_call(pid, func, [5, 3])
       end
 
       report = Firebird.Metrics.report()
+
       for func <- functions do
         assert Map.has_key?(report, to_string(func)),
                "Expected #{func} in report"
diff --git a/test/metrics_test.exs b/test/metrics_test.exs
index d786397..05c5fdf 100644
--- a/test/metrics_test.exs
+++ b/test/metrics_test.exs
@@ -8,6 +8,7 @@ defmodule Firebird.MetricsTest do
       {:ok, _pid} -> :ok
       {:error, {:already_started, _pid}} -> :ok
     end
+
     Firebird.Metrics.reset()
 
     {:ok, pid} = Firebird.load(@fixture_path)
diff --git a/test/mix/compilers/firebird_wasm_comprehensive_test.exs b/test/mix/compilers/firebird_wasm_comprehensive_test.exs
index 41f525c..ff8e5a2 100644
--- a/test/mix/compilers/firebird_wasm_comprehensive_test.exs
+++ b/test/mix/compilers/firebird_wasm_comprehensive_test.exs
@@ -137,4 +137,3 @@ defmodule Mix.Compilers.FirebirdWasmComprehensiveTest do
     end
   end
 end
-
diff --git a/test/mix/compilers/firebird_wasm_test.exs b/test/mix/compilers/firebird_wasm_test.exs
index fc38fa3..7bd62a0 100644
--- a/test/mix/compilers/firebird_wasm_test.exs
+++ b/test/mix/compilers/firebird_wasm_test.exs
@@ -14,6 +14,7 @@ defmodule Mix.Compilers.FirebirdWasmTest do
   describe "find_wasm_sources/1" do
     test "finds files with @wasm annotations", %{tmp: tmp} do
       wasm_file = Path.join(tmp, "wasm_mod.ex")
+
       File.write!(wasm_file, """
       defmodule WasmMod do
         @wasm true
@@ -22,6 +23,7 @@ defmodule Mix.Compilers.FirebirdWasmTest do
       """)
 
       plain_file = Path.join(tmp, "plain.ex")
+
       File.write!(plain_file, """
       defmodule Plain do
         def hello, do: "world"
@@ -38,6 +40,7 @@ defmodule Mix.Compilers.FirebirdWasmTest do
       File.mkdir_p!(nested)
 
       file = Path.join(nested, "deep_mod.ex")
+
       File.write!(file, """
       defmodule Deep do
         @wasm true
@@ -62,6 +65,7 @@ defmodule Mix.Compilers.FirebirdWasmTest do
   describe "has_wasm_annotation?/1" do
     test "returns true for files with @wasm true", %{tmp: tmp} do
       file = Path.join(tmp, "annotated.ex")
+
       File.write!(file, """
       defmodule Annotated do
         @wasm true
@@ -74,6 +78,7 @@ defmodule Mix.Compilers.FirebirdWasmTest do
 
     test "returns false for files without @wasm true", %{tmp: tmp} do
       file = Path.join(tmp, "plain.ex")
+
       File.write!(file, """
       defmodule Plain do
         def add(a, b), do: a + b
diff --git a/test/mix/tasks/firebird_analyze_test.exs b/test/mix/tasks/firebird_analyze_test.exs
index 1d6662b..c2d63bc 100644
--- a/test/mix/tasks/firebird_analyze_test.exs
+++ b/test/mix/tasks/firebird_analyze_test.exs
@@ -11,6 +11,7 @@ defmodule Mix.Tasks.Firebird.AnalyzeTest do
 
   test "analyze task runs without crashing", %{dir: dir} do
     path = Path.join(dir, "test.ex")
+
     File.write!(path, """
     defmodule AnalyzeTaskTest do
       @wasm true
diff --git a/test/mix/tasks/firebird_bench_test.exs b/test/mix/tasks/firebird_bench_test.exs
index 793b200..cb0f746 100644
--- a/test/mix/tasks/firebird_bench_test.exs
+++ b/test/mix/tasks/firebird_bench_test.exs
@@ -265,4 +265,3 @@ defmodule Mix.Tasks.Firebird.BenchTest do
   defp bench_fact(0), do: 1
   defp bench_fact(n), do: n * bench_fact(n - 1)
 end
-
diff --git a/test/mix/tasks/firebird_compile_test.exs b/test/mix/tasks/firebird_compile_test.exs
index 9fba339..3d5d3a8 100644
--- a/test/mix/tasks/firebird_compile_test.exs
+++ b/test/mix/tasks/firebird_compile_test.exs
@@ -20,12 +20,13 @@ defmodule Mix.Tasks.Firebird.CompileTest do
 
   describe "run/1" do
     test "compiles a single file", %{tmp: tmp} do
-      src = write_file(tmp, "add.ex", """
-      defmodule CompAdd do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      src =
+        write_file(tmp, "add.ex", """
+        defmodule CompAdd do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
       out = Path.join(tmp, "out")
       Compile.run([src, "--output", out])
@@ -51,12 +52,13 @@ defmodule Mix.Tasks.Firebird.CompileTest do
     end
 
     test "generates wat only when --wat-only flag used", %{tmp: tmp} do
-      src = write_file(tmp, "wat.ex", """
-      defmodule CompWat do
-        @wasm true
-        def id(a), do: a
-      end
-      """)
+      src =
+        write_file(tmp, "wat.ex", """
+        defmodule CompWat do
+          @wasm true
+          def id(a), do: a
+        end
+        """)
 
       out = Path.join(tmp, "out")
       Compile.run([src, "--output", out, "--wat-only"])
@@ -66,19 +68,21 @@ defmodule Mix.Tasks.Firebird.CompileTest do
     end
 
     test "compiles multiple files", %{tmp: tmp} do
-      f1 = write_file(tmp, "a.ex", """
-      defmodule CompA do
-        @wasm true
-        def a(x), do: x + 1
-      end
-      """)
-
-      f2 = write_file(tmp, "b.ex", """
-      defmodule CompB do
-        @wasm true
-        def b(x), do: x * 2
-      end
-      """)
+      f1 =
+        write_file(tmp, "a.ex", """
+        defmodule CompA do
+          @wasm true
+          def a(x), do: x + 1
+        end
+        """)
+
+      f2 =
+        write_file(tmp, "b.ex", """
+        defmodule CompB do
+          @wasm true
+          def b(x), do: x * 2
+        end
+        """)
 
       out = Path.join(tmp, "out")
       Compile.run([f1, f2, "--output", out])
@@ -100,15 +104,16 @@ defmodule Mix.Tasks.Firebird.CompileTest do
     end
 
     test "compiled WASM executes correctly", %{tmp: tmp} do
-      src = write_file(tmp, "exec.ex", """
-      defmodule CompExec do
-        @wasm true
-        def double(a), do: a * 2
+      src =
+        write_file(tmp, "exec.ex", """
+        defmodule CompExec do
+          @wasm true
+          def double(a), do: a * 2
 
-        @wasm true
-        def square(a), do: a * a
-      end
-      """)
+          @wasm true
+          def square(a), do: a * a
+        end
+        """)
 
       out = Path.join(tmp, "out")
       Compile.run([src, "--output", out])
@@ -123,12 +128,13 @@ defmodule Mix.Tasks.Firebird.CompileTest do
     end
 
     test "supports verbose output", %{tmp: tmp} do
-      src = write_file(tmp, "verbose.ex", """
-      defmodule CompVerbose do
-        @wasm true
-        def id(a), do: a
-      end
-      """)
+      src =
+        write_file(tmp, "verbose.ex", """
+        defmodule CompVerbose do
+          @wasm true
+          def id(a), do: a
+        end
+        """)
 
       out = Path.join(tmp, "out")
       # Should not crash with verbose flag
@@ -138,12 +144,13 @@ defmodule Mix.Tasks.Firebird.CompileTest do
     end
 
     test "supports verify flag", %{tmp: tmp} do
-      src = write_file(tmp, "verify.ex", """
-      defmodule CompVerify do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      src =
+        write_file(tmp, "verify.ex", """
+        defmodule CompVerify do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
       out = Path.join(tmp, "out")
       Compile.run([src, "--output", out, "--verify"])
diff --git a/test/mix/tasks/firebird_doctor_test.exs b/test/mix/tasks/firebird_doctor_test.exs
index 946e996..18080b3 100644
--- a/test/mix/tasks/firebird_doctor_test.exs
+++ b/test/mix/tasks/firebird_doctor_test.exs
@@ -3,9 +3,10 @@ defmodule Mix.Tasks.Firebird.DoctorTest do
 
   describe "mix firebird.doctor" do
     test "runs without error" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Mix.Tasks.Firebird.Doctor.run([])
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Mix.Tasks.Firebird.Doctor.run([])
+        end)
 
       assert output =~ "Firebird Doctor"
       assert output =~ "Wasmex dependency"
@@ -16,9 +17,10 @@ defmodule Mix.Tasks.Firebird.DoctorTest do
     end
 
     test "reports all checks passed" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Mix.Tasks.Firebird.Doctor.run([])
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Mix.Tasks.Firebird.Doctor.run([])
+        end)
 
       assert output =~ "All" and output =~ "passed"
     end
diff --git a/test/mix/tasks/firebird_gen_test.exs b/test/mix/tasks/firebird_gen_test.exs
index b41776b..b4250a8 100644
--- a/test/mix/tasks/firebird_gen_test.exs
+++ b/test/mix/tasks/firebird_gen_test.exs
@@ -29,7 +29,16 @@ defmodule Mix.Tasks.Firebird.GenTest do
 
     test "generates pool-style wrapper", %{tmp_dir: tmp_dir} do
       out = Path.join(tmp_dir, "math_pool.ex")
-      Mix.Tasks.Firebird.Gen.run([@math_wasm, "--module", "TestGen.MathPool", "--out", out, "--style", "pool"])
+
+      Mix.Tasks.Firebird.Gen.run([
+        @math_wasm,
+        "--module",
+        "TestGen.MathPool",
+        "--out",
+        out,
+        "--style",
+        "pool"
+      ])
 
       content = File.read!(out)
       assert content =~ "defmodule TestGen.MathPool"
@@ -40,7 +49,16 @@ defmodule Mix.Tasks.Firebird.GenTest do
 
     test "generates basic-style wrapper", %{tmp_dir: tmp_dir} do
       out = Path.join(tmp_dir, "math_basic.ex")
-      Mix.Tasks.Firebird.Gen.run([@math_wasm, "--module", "TestGen.MathBasic", "--out", out, "--style", "basic"])
+
+      Mix.Tasks.Firebird.Gen.run([
+        @math_wasm,
+        "--module",
+        "TestGen.MathBasic",
+        "--out",
+        out,
+        "--style",
+        "basic"
+      ])
 
       content = File.read!(out)
       assert content =~ "defmodule TestGen.MathBasic"
@@ -78,7 +96,14 @@ defmodule Mix.Tasks.Firebird.GenTest do
       out = Path.join(tmp_dir, "existing.ex")
       File.write!(out, "old content")
 
-      Mix.Tasks.Firebird.Gen.run([@math_wasm, "--module", "TestGen.Forced", "--out", out, "--force"])
+      Mix.Tasks.Firebird.Gen.run([
+        @math_wasm,
+        "--module",
+        "TestGen.Forced",
+        "--out",
+        out,
+        "--force"
+      ])
 
       content = File.read!(out)
       assert content =~ "defmodule TestGen.Forced"
@@ -105,7 +130,16 @@ defmodule Mix.Tasks.Firebird.GenTest do
 
     test "generated pool code is valid Elixir", %{tmp_dir: tmp_dir} do
       out = Path.join(tmp_dir, "valid_pool.ex")
-      Mix.Tasks.Firebird.Gen.run([@math_wasm, "--module", "TestGen.ValidPool", "--out", out, "--style", "pool"])
+
+      Mix.Tasks.Firebird.Gen.run([
+        @math_wasm,
+        "--module",
+        "TestGen.ValidPool",
+        "--out",
+        out,
+        "--style",
+        "pool"
+      ])
 
       content = File.read!(out)
       assert {:ok, _} = Code.string_to_quoted(content)
@@ -113,7 +147,16 @@ defmodule Mix.Tasks.Firebird.GenTest do
 
     test "generated basic code is valid Elixir", %{tmp_dir: tmp_dir} do
       out = Path.join(tmp_dir, "valid_basic.ex")
-      Mix.Tasks.Firebird.Gen.run([@math_wasm, "--module", "TestGen.ValidBasic", "--out", out, "--style", "basic"])
+
+      Mix.Tasks.Firebird.Gen.run([
+        @math_wasm,
+        "--module",
+        "TestGen.ValidBasic",
+        "--out",
+        out,
+        "--style",
+        "basic"
+      ])
 
       content = File.read!(out)
       assert {:ok, _} = Code.string_to_quoted(content)
diff --git a/test/mix/tasks/firebird_init_extended_test.exs b/test/mix/tasks/firebird_init_extended_test.exs
index fe8ad26..6aa15b5 100644
--- a/test/mix/tasks/firebird_init_extended_test.exs
+++ b/test/mix/tasks/firebird_init_extended_test.exs
@@ -9,7 +9,7 @@ defmodule Mix.Tasks.Firebird.InitExtendedTest do
 
       # Verify sample WASM was copied
       assert File.exists?("wasm/sample_math.wasm"),
-        "Expected sample_math.wasm to be copied to wasm/"
+             "Expected sample_math.wasm to be copied to wasm/"
 
       # Verify it's a valid WASM file
       {:ok, bytes} = File.read("wasm/sample_math.wasm")
@@ -23,7 +23,7 @@ defmodule Mix.Tasks.Firebird.InitExtendedTest do
       Mix.Tasks.Firebird.Init.run([])
 
       assert File.exists?("test/wasm_test.exs"),
-        "Expected test/wasm_test.exs to be created"
+             "Expected test/wasm_test.exs to be created"
 
       content = File.read!("test/wasm_test.exs")
       assert content =~ "setup_wasm"
diff --git a/test/mix/tasks/firebird_inspect_test.exs b/test/mix/tasks/firebird_inspect_test.exs
index 97041c7..891e24f 100644
--- a/test/mix/tasks/firebird_inspect_test.exs
+++ b/test/mix/tasks/firebird_inspect_test.exs
@@ -6,9 +6,10 @@ defmodule Mix.Tasks.Firebird.InspectTest do
 
   describe "run/1 with no arguments" do
     test "prints usage info" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Mix.Tasks.Firebird.Inspect.run([])
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Mix.Tasks.Firebird.Inspect.run([])
+        end)
 
       assert output =~ "Inspect a WASM module"
       assert output =~ "--wasi"
@@ -18,9 +19,10 @@ defmodule Mix.Tasks.Firebird.InspectTest do
 
   describe "run/1 with valid WASM file" do
     test "displays module info for Rust WASM" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Mix.Tasks.Firebird.Inspect.run([@math_wasm])
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Mix.Tasks.Firebird.Inspect.run([@math_wasm])
+        end)
 
       assert output =~ "WASM Module"
       assert output =~ @math_wasm
@@ -35,9 +37,10 @@ defmodule Mix.Tasks.Firebird.InspectTest do
     end
 
     test "displays memory info" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Mix.Tasks.Firebird.Inspect.run([@math_wasm])
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Mix.Tasks.Firebird.Inspect.run([@math_wasm])
+        end)
 
       assert output =~ "Memories:"
       assert output =~ "memory"
@@ -45,9 +48,10 @@ defmodule Mix.Tasks.Firebird.InspectTest do
     end
 
     test "displays module info for Go WASM with --wasi" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Mix.Tasks.Firebird.Inspect.run([@go_wasm, "--wasi"])
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Mix.Tasks.Firebird.Inspect.run([@go_wasm, "--wasi"])
+        end)
 
       assert output =~ "WASM Module"
       assert output =~ "add"
@@ -57,9 +61,10 @@ defmodule Mix.Tasks.Firebird.InspectTest do
 
   describe "run/1 with --generate flag" do
     test "generates Elixir module code (default style)" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Mix.Tasks.Firebird.Inspect.run([@math_wasm, "--generate", "MyApp.Math"])
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Mix.Tasks.Firebird.Inspect.run([@math_wasm, "--generate", "MyApp.Math"])
+        end)
 
       assert output =~ "defmodule MyApp.Math"
       assert output =~ "use Firebird"
@@ -69,13 +74,16 @@ defmodule Mix.Tasks.Firebird.InspectTest do
     end
 
     test "generates wasm_module style code" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Mix.Tasks.Firebird.Inspect.run([
-          @math_wasm,
-          "--generate", "MyApp.Math",
-          "--style", "wasm_module"
-        ])
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Mix.Tasks.Firebird.Inspect.run([
+            @math_wasm,
+            "--generate",
+            "MyApp.Math",
+            "--style",
+            "wasm_module"
+          ])
+        end)
 
       assert output =~ "defmodule MyApp.Math"
       assert output =~ "use Firebird.WasmModule"
@@ -83,13 +91,15 @@ defmodule Mix.Tasks.Firebird.InspectTest do
     end
 
     test "generates module with wasi flag" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Mix.Tasks.Firebird.Inspect.run([
-          @go_wasm,
-          "--wasi",
-          "--generate", "MyApp.GoMath"
-        ])
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Mix.Tasks.Firebird.Inspect.run([
+            @go_wasm,
+            "--wasi",
+            "--generate",
+            "MyApp.GoMath"
+          ])
+        end)
 
       assert output =~ "defmodule MyApp.GoMath"
       assert output =~ "wasi"
@@ -98,24 +108,26 @@ defmodule Mix.Tasks.Firebird.InspectTest do
 
   describe "run/1 with invalid input" do
     test "displays error for nonexistent file" do
-      output = ExUnit.CaptureIO.capture_io(:stderr, fn ->
-        ExUnit.CaptureIO.capture_io(fn ->
-          Mix.Tasks.Firebird.Inspect.run(["/nonexistent/file.wasm"])
+      output =
+        ExUnit.CaptureIO.capture_io(:stderr, fn ->
+          ExUnit.CaptureIO.capture_io(fn ->
+            Mix.Tasks.Firebird.Inspect.run(["/nonexistent/file.wasm"])
+          end)
         end)
-      end)
 
       assert output =~ "Error:"
     end
 
     test "displays error for invalid WASM file" do
-      tmp = Path.join(System.tmp_dir!(), "firebird_inspect_test_#{:rand.uniform(100000)}.wasm")
+      tmp = Path.join(System.tmp_dir!(), "firebird_inspect_test_#{:rand.uniform(100_000)}.wasm")
       File.write!(tmp, "not wasm content")
 
-      output = ExUnit.CaptureIO.capture_io(:stderr, fn ->
-        ExUnit.CaptureIO.capture_io(fn ->
-          Mix.Tasks.Firebird.Inspect.run([tmp])
+      output =
+        ExUnit.CaptureIO.capture_io(:stderr, fn ->
+          ExUnit.CaptureIO.capture_io(fn ->
+            Mix.Tasks.Firebird.Inspect.run([tmp])
+          end)
         end)
-      end)
 
       assert output =~ "Error:"
       File.rm!(tmp)
@@ -124,9 +136,10 @@ defmodule Mix.Tasks.Firebird.InspectTest do
 
   describe "run/1 with multiple files (only first used)" do
     test "uses only the first path argument" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Mix.Tasks.Firebird.Inspect.run([@math_wasm, "extra_arg"])
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Mix.Tasks.Firebird.Inspect.run([@math_wasm, "extra_arg"])
+        end)
 
       # With 2 positional args, it falls through to usage display
       assert output =~ "Inspect a WASM module" or output =~ "WASM Module"
@@ -135,9 +148,10 @@ defmodule Mix.Tasks.Firebird.InspectTest do
 
   describe "function signature display" do
     test "shows correct parameter types for 2-arg function" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Mix.Tasks.Firebird.Inspect.run([@math_wasm])
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Mix.Tasks.Firebird.Inspect.run([@math_wasm])
+        end)
 
       # add takes (i32, i32) -> i32
       assert output =~ "add"
@@ -145,9 +159,10 @@ defmodule Mix.Tasks.Firebird.InspectTest do
     end
 
     test "shows correct parameter types for 1-arg function" do
-      output = ExUnit.CaptureIO.capture_io(fn ->
-        Mix.Tasks.Firebird.Inspect.run([@math_wasm])
-      end)
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Mix.Tasks.Firebird.Inspect.run([@math_wasm])
+        end)
 
       # fibonacci takes (i32) -> i32
       assert output =~ "fibonacci"
@@ -157,10 +172,12 @@ defmodule Mix.Tasks.Firebird.InspectTest do
   describe "WAT WASM inspection" do
     test "inspects WAT-compiled WASM" do
       wat_wasm = "fixtures/wat_math.wasm"
+
       if File.exists?(wat_wasm) do
-        output = ExUnit.CaptureIO.capture_io(fn ->
-          Mix.Tasks.Firebird.Inspect.run([wat_wasm])
-        end)
+        output =
+          ExUnit.CaptureIO.capture_io(fn ->
+            Mix.Tasks.Firebird.Inspect.run([wat_wasm])
+          end)
 
         assert output =~ "WASM Module"
         assert output =~ "Functions:"
diff --git a/test/mix/tasks/firebird_new_test.exs b/test/mix/tasks/firebird_new_test.exs
index c350237..39b542e 100644
--- a/test/mix/tasks/firebird_new_test.exs
+++ b/test/mix/tasks/firebird_new_test.exs
@@ -7,10 +7,12 @@ defmodule Mix.Tasks.Firebird.NewTest do
     # Change to temp dir so project is created there
     old_dir = File.cwd!()
     File.cd!(tmp_dir)
+
     on_exit(fn ->
       File.cd!(old_dir)
       File.rm_rf!(tmp_dir)
     end)
+
     {:ok, tmp_dir: tmp_dir}
   end
 
@@ -77,6 +79,7 @@ defmodule Mix.Tasks.Firebird.NewTest do
 
     test "raises if directory exists" do
       File.mkdir_p!("existing_app")
+
       assert_raise Mix.Error, ~r/already exists/, fn ->
         Mix.Tasks.Firebird.New.run(["existing_app"])
       end
@@ -92,14 +95,14 @@ defmodule Mix.Tasks.Firebird.NewTest do
       Mix.Tasks.Firebird.New.run(["check_app", "--sup"])
 
       for file <- [
-        "check_app/mix.exs",
-        "check_app/lib/check_app.ex",
-        "check_app/lib/check_app/math.ex",
-        "check_app/lib/check_app/application.ex",
-        "check_app/test/test_helper.exs",
-        "check_app/test/check_app_test.exs",
-        "check_app/config/config.exs"
-      ] do
+            "check_app/mix.exs",
+            "check_app/lib/check_app.ex",
+            "check_app/lib/check_app/math.ex",
+            "check_app/lib/check_app/application.ex",
+            "check_app/test/test_helper.exs",
+            "check_app/test/check_app_test.exs",
+            "check_app/config/config.exs"
+          ] do
         content = File.read!(file)
         assert {:ok, _} = Code.string_to_quoted(content), "Invalid Elixir in #{file}"
       end
diff --git a/test/mix/tasks/firebird_target_check_test.exs b/test/mix/tasks/firebird_target_check_test.exs
index 447edaa..11cd10b 100644
--- a/test/mix/tasks/firebird_target_check_test.exs
+++ b/test/mix/tasks/firebird_target_check_test.exs
@@ -9,6 +9,7 @@ defmodule Mix.Tasks.Firebird.Target.CheckTest do
     File.mkdir_p!(tmp_dir)
 
     path = Path.join(tmp_dir, "math.ex")
+
     File.write!(path, """
     defmodule CheckTaskTestMath do
       @wasm true
@@ -37,6 +38,10 @@ defmodule Mix.Tasks.Firebird.Target.CheckTest do
   end
 
   test "handles no files gracefully" do
-    assert :ok = Mix.Tasks.Firebird.Target.Check.run(["--dirs", "/tmp/nonexistent_#{System.unique_integer([:positive])}"])
+    assert :ok =
+             Mix.Tasks.Firebird.Target.Check.run([
+               "--dirs",
+               "/tmp/nonexistent_#{System.unique_integer([:positive])}"
+             ])
   end
 end
diff --git a/test/mix/tasks/firebird_target_clean_test.exs b/test/mix/tasks/firebird_target_clean_test.exs
index 0003a86..0eeb3f1 100644
--- a/test/mix/tasks/firebird_target_clean_test.exs
+++ b/test/mix/tasks/firebird_target_clean_test.exs
@@ -54,7 +54,8 @@ defmodule Mix.Tasks.Firebird.Target.CleanTest do
       types = %{wat: false, wasm: false, manifests: true}
       count = Mix.Tasks.Firebird.Target.Clean.clean_artifacts(out, types, false, true)
 
-      assert count == 2  # manifest + source_map
+      # manifest + source_map
+      assert count == 2
       assert File.exists?(Path.join(out, "MyMath.wat"))
       assert File.exists?(Path.join(out, "MyMath.wasm"))
       refute File.exists?(Path.join(out, "firebird_manifest.json"))
@@ -105,7 +106,8 @@ defmodule Mix.Tasks.Firebird.Target.CleanTest do
     test "handles nonexistent directory", %{tmp_dir: tmp} do
       nonexistent = Path.join(tmp, "nonexistent")
       # Should not raise
-      assert :ok = Mix.Tasks.Firebird.Target.Clean.clean_entire_directory(nonexistent, false, true)
+      assert :ok =
+               Mix.Tasks.Firebird.Target.Clean.clean_entire_directory(nonexistent, false, true)
     end
   end
 
diff --git a/test/mix/tasks/firebird_target_comprehensive_test.exs b/test/mix/tasks/firebird_target_comprehensive_test.exs
index be6cde4..25ca02e 100644
--- a/test/mix/tasks/firebird_target_comprehensive_test.exs
+++ b/test/mix/tasks/firebird_target_comprehensive_test.exs
@@ -329,6 +329,3 @@ defmodule Mix.Tasks.Firebird.TargetComprehensiveTest do
     end
   end
 end
-
-
-
diff --git a/test/mix/tasks/firebird_target_extended_test.exs b/test/mix/tasks/firebird_target_extended_test.exs
index 5fba372..f01bff2 100644
--- a/test/mix/tasks/firebird_target_extended_test.exs
+++ b/test/mix/tasks/firebird_target_extended_test.exs
@@ -267,6 +267,7 @@ defmodule Mix.Tasks.Firebird.TargetExtendedTest do
       # Files in wasm_modules dir are auto-discovered
       wasm_dir = Path.join(src, "wasm_modules")
       File.mkdir_p!(wasm_dir)
+
       write_source(wasm_dir, "all.ex", """
       defmodule TargetAll do
         def add(a, b), do: a + b
@@ -311,7 +312,8 @@ defmodule Mix.Tasks.Firebird.TargetExtendedTest do
       {:ok, inst} = Firebird.load(wasm)
 
       # Test with large (but within i64) numbers
-      assert {:ok, [2_000_000_000]} = Firebird.call(inst, "big_add", [1_000_000_000, 1_000_000_000])
+      assert {:ok, [2_000_000_000]} =
+               Firebird.call(inst, "big_add", [1_000_000_000, 1_000_000_000])
 
       Firebird.stop(inst)
     end
diff --git a/test/mix/tasks/firebird_target_inspect_test.exs b/test/mix/tasks/firebird_target_inspect_test.exs
index 3443d73..388512c 100644
--- a/test/mix/tasks/firebird_target_inspect_test.exs
+++ b/test/mix/tasks/firebird_target_inspect_test.exs
@@ -9,6 +9,7 @@ defmodule Mix.Tasks.Firebird.Target.InspectTest do
     File.mkdir_p!(tmp_dir)
 
     path = Path.join(tmp_dir, "math.ex")
+
     File.write!(path, """
     defmodule InspectTaskTestMath do
       @wasm true
diff --git a/test/mix/tasks/firebird_target_link_test.exs b/test/mix/tasks/firebird_target_link_test.exs
index fcb8d7a..d3e772d 100644
--- a/test/mix/tasks/firebird_target_link_test.exs
+++ b/test/mix/tasks/firebird_target_link_test.exs
@@ -23,19 +23,21 @@ defmodule Mix.Tasks.Firebird.Target.LinkTest do
 
   describe "link/1" do
     test "links two modules into one WASM", %{src: src, out: out} do
-      a = write_source(src, "add.ex", """
-      defmodule LinkTestAdd do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
-
-      b = write_source(src, "mul.ex", """
-      defmodule LinkTestMul do
-        @wasm true
-        def mul(a, b), do: a * b
-      end
-      """)
+      a =
+        write_source(src, "add.ex", """
+        defmodule LinkTestAdd do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
+
+      b =
+        write_source(src, "mul.ex", """
+        defmodule LinkTestMul do
+          @wasm true
+          def mul(a, b), do: a * b
+        end
+        """)
 
       assert :ok = Link.link(files: "#{a},#{b}", output: out, name: "LinkTest")
       assert File.exists?(Path.join(out, "LinkTest.wasm"))
@@ -48,19 +50,21 @@ defmodule Mix.Tasks.Firebird.Target.LinkTest do
     end
 
     test "links with prefix option", %{src: src, out: out} do
-      a = write_source(src, "pa.ex", """
-      defmodule LinkPrefA do
-        @wasm true
-        def compute(a), do: a + 1
-      end
-      """)
-
-      b = write_source(src, "pb.ex", """
-      defmodule LinkPrefB do
-        @wasm true
-        def compute(a), do: a * 2
-      end
-      """)
+      a =
+        write_source(src, "pa.ex", """
+        defmodule LinkPrefA do
+          @wasm true
+          def compute(a), do: a + 1
+        end
+        """)
+
+      b =
+        write_source(src, "pb.ex", """
+        defmodule LinkPrefB do
+          @wasm true
+          def compute(a), do: a * 2
+        end
+        """)
 
       assert :ok = Link.link(files: "#{a},#{b}", output: out, name: "Prefixed", prefix: true)
 
@@ -72,12 +76,13 @@ defmodule Mix.Tasks.Firebird.Target.LinkTest do
     end
 
     test "generates WAT only", %{src: src, out: out} do
-      a = write_source(src, "wat.ex", """
-      defmodule LinkWatOnly do
-        @wasm true
-        def id(a), do: a
-      end
-      """)
+      a =
+        write_source(src, "wat.ex", """
+        defmodule LinkWatOnly do
+          @wasm true
+          def id(a), do: a
+        end
+        """)
 
       assert :ok = Link.link(files: a, output: out, name: "WatLink", wat_only: true)
       assert File.exists?(Path.join(out, "WatLink.wat"))
@@ -127,4 +132,3 @@ defmodule Mix.Tasks.Firebird.Target.LinkTest do
     end
   end
 end
-
diff --git a/test/mix/tasks/firebird_target_new_test.exs b/test/mix/tasks/firebird_target_new_test.exs
index 5cef083..bce93c0 100644
--- a/test/mix/tasks/firebird_target_new_test.exs
+++ b/test/mix/tasks/firebird_target_new_test.exs
@@ -26,9 +26,15 @@ defmodule Mix.Tasks.Firebird.Target.NewTest do
 
   test "creates module with custom functions", %{dir: dir} do
     output_dir = Path.join(dir, "lib/wasm")
-    assert :ok = Mix.Tasks.Firebird.Target.New.run([
-      "MyApp.Utils", "--dir", output_dir, "--functions", "add,sub,mul"
-    ])
+
+    assert :ok =
+             Mix.Tasks.Firebird.Target.New.run([
+               "MyApp.Utils",
+               "--dir",
+               output_dir,
+               "--functions",
+               "add,sub,mul"
+             ])
 
     content = File.read!(Path.join(output_dir, "utils.ex"))
     assert String.contains?(content, "def add")
@@ -41,9 +47,14 @@ defmodule Mix.Tasks.Firebird.Target.NewTest do
     # The task strips "lib/" prefix from dir for the test path, so we use
     # a tmp dir that doesn't start with "lib/"
     output_dir = Path.join(dir, "lib/wasm_mods_test")
-    assert :ok = Mix.Tasks.Firebird.Target.New.run([
-      "MyApp.Calc", "--dir", output_dir, "--with-test"
-    ])
+
+    assert :ok =
+             Mix.Tasks.Firebird.Target.New.run([
+               "MyApp.Calc",
+               "--dir",
+               output_dir,
+               "--with-test"
+             ])
 
     # Module file should exist
     assert File.exists?(Path.join(output_dir, "calc.ex"))
@@ -56,6 +67,7 @@ defmodule Mix.Tasks.Firebird.Target.NewTest do
     for p <- [test_path, alt_test_dir] do
       if File.exists?(p), do: File.rm(p)
       parent = Path.dirname(p)
+
       if File.dir?(parent) do
         case File.ls(parent) do
           {:ok, []} -> File.rmdir(parent)
@@ -66,6 +78,7 @@ defmodule Mix.Tasks.Firebird.Target.NewTest do
 
     # Also clean up test/tmp if it was created
     test_tmp = Path.join("test", "tmp")
+
     if File.dir?(test_tmp) do
       File.rm_rf!(test_tmp)
     end
diff --git a/test/mix/tasks/firebird_target_profile_test.exs b/test/mix/tasks/firebird_target_profile_test.exs
index 0f38a77..46a1aa2 100644
--- a/test/mix/tasks/firebird_target_profile_test.exs
+++ b/test/mix/tasks/firebird_target_profile_test.exs
@@ -9,6 +9,7 @@ defmodule Mix.Tasks.Firebird.Target.ProfileTest do
     File.mkdir_p!(tmp_dir)
 
     path = Path.join(tmp_dir, "math.ex")
+
     File.write!(path, """
     defmodule ProfileTaskTestMath do
       @wasm true
diff --git a/test/mix/tasks/firebird_target_source_map_test.exs b/test/mix/tasks/firebird_target_source_map_test.exs
index 5b430a5..4192ced 100644
--- a/test/mix/tasks/firebird_target_source_map_test.exs
+++ b/test/mix/tasks/firebird_target_source_map_test.exs
@@ -77,4 +77,3 @@ defmodule Mix.Tasks.Firebird.TargetSourceMapTest do
     assert ternary["arity"] == 3
   end
 end
-
diff --git a/test/mix/tasks/firebird_target_status_test.exs b/test/mix/tasks/firebird_target_status_test.exs
index 9f53a8c..b018f16 100644
--- a/test/mix/tasks/firebird_target_status_test.exs
+++ b/test/mix/tasks/firebird_target_status_test.exs
@@ -10,7 +10,8 @@ defmodule Mix.Tasks.Firebird.Target.StatusTest do
   end
 
   test "runs with custom output directory" do
-    assert :ok = Mix.Tasks.Firebird.Target.Status.run(["--output", "/tmp/nonexistent_status_test"])
+    assert :ok =
+             Mix.Tasks.Firebird.Target.Status.run(["--output", "/tmp/nonexistent_status_test"])
   end
 
   test "runs with custom dirs" do
diff --git a/test/mix/tasks/firebird_target_test.exs b/test/mix/tasks/firebird_target_test.exs
index 75aa8ac..c138551 100644
--- a/test/mix/tasks/firebird_target_test.exs
+++ b/test/mix/tasks/firebird_target_test.exs
@@ -71,12 +71,13 @@ defmodule Mix.Tasks.Firebird.TargetTest do
     end
 
     test "compiles with specific files option", %{source_dir: src, output_dir: out} do
-      path = write_source(src, "specific.ex", """
-      defmodule Specific do
-        @wasm true
-        def double(a), do: a * 2
-      end
-      """)
+      path =
+        write_source(src, "specific.ex", """
+        defmodule Specific do
+          @wasm true
+          def double(a), do: a * 2
+        end
+        """)
 
       # also write a file that should NOT be compiled
       write_source(src, "other.ex", """
diff --git a/test/mix/tasks/firebird_target_verify_test.exs b/test/mix/tasks/firebird_target_verify_test.exs
index e1fa126..17a80c3 100644
--- a/test/mix/tasks/firebird_target_verify_test.exs
+++ b/test/mix/tasks/firebird_target_verify_test.exs
@@ -9,12 +9,13 @@ defmodule Mix.Tasks.Firebird.Target.VerifyTest do
     File.mkdir_p!(tmp_dir)
 
     # Compile a module and write artifacts
-    {:ok, result} = Firebird.Compiler.compile_source("""
-    defmodule VerifyTaskTestMath do
-      @wasm true
-      def add(a, b), do: a + b
-    end
-    """)
+    {:ok, result} =
+      Firebird.Compiler.compile_source("""
+      defmodule VerifyTaskTestMath do
+        @wasm true
+        def add(a, b), do: a + b
+      end
+      """)
 
     File.write!(Path.join(tmp_dir, "VerifyTaskTestMath.wasm"), result.wasm)
 
@@ -39,7 +40,11 @@ defmodule Mix.Tasks.Firebird.Target.VerifyTest do
   end
 
   test "handles nonexistent directory" do
-    assert :ok = Mix.Tasks.Firebird.Target.Verify.run(["--dir", "/tmp/nonexistent_verify_#{System.unique_integer([:positive])}"])
+    assert :ok =
+             Mix.Tasks.Firebird.Target.Verify.run([
+               "--dir",
+               "/tmp/nonexistent_verify_#{System.unique_integer([:positive])}"
+             ])
   end
 
   test "handles empty directory" do
diff --git a/test/module_cache_comprehensive_test.exs b/test/module_cache_comprehensive_test.exs
index c8aa73f..e7e2bd5 100644
--- a/test/module_cache_comprehensive_test.exs
+++ b/test/module_cache_comprehensive_test.exs
@@ -22,6 +22,7 @@ defmodule Firebird.ModuleCacheComprehensiveTest do
     case ModuleCache.start_link(name: :"cache_test_#{System.unique_integer([:positive])}") do
       {:ok, pid} ->
         on_exit(fn -> if Process.alive?(pid), do: GenServer.stop(pid) end)
+
       {:error, {:already_started, _pid}} ->
         :ok
     end
diff --git a/test/module_cache_edge_cases_test.exs b/test/module_cache_edge_cases_test.exs
index f198f22..f6b0292 100644
--- a/test/module_cache_edge_cases_test.exs
+++ b/test/module_cache_edge_cases_test.exs
@@ -152,12 +152,13 @@ defmodule Firebird.ModuleCacheEdgeCasesTest do
 
     test "cached instances are fully functional" do
       # Load 5 instances from cache - all should work correctly
-      pids = for _ <- 1..5 do
-        {:ok, pid} = Firebird.ModuleCache.load(@fixture_path)
-        assert {:ok, [8]} = Firebird.Runtime.call(pid, :add, [5, 3])
-        assert {:ok, [55]} = Firebird.Runtime.call(pid, :fibonacci, [10])
-        pid
-      end
+      pids =
+        for _ <- 1..5 do
+          {:ok, pid} = Firebird.ModuleCache.load(@fixture_path)
+          assert {:ok, [8]} = Firebird.Runtime.call(pid, :add, [5, 3])
+          assert {:ok, [55]} = Firebird.Runtime.call(pid, :fibonacci, [10])
+          pid
+        end
 
       # Should have only 1 cache entry since it's the same file
       assert %{entries: 1} = Firebird.ModuleCache.stats()
@@ -260,13 +261,14 @@ defmodule Firebird.ModuleCacheEdgeCasesTest do
 
   describe "concurrent access" do
     test "concurrent loads of same file" do
-      tasks = for _ <- 1..10 do
-        Task.async(fn ->
-          {:ok, pid} = Firebird.ModuleCache.load(@fixture_path)
-          assert {:ok, [8]} = Firebird.Runtime.call(pid, :add, [5, 3])
-          pid
-        end)
-      end
+      tasks =
+        for _ <- 1..10 do
+          Task.async(fn ->
+            {:ok, pid} = Firebird.ModuleCache.load(@fixture_path)
+            assert {:ok, [8]} = Firebird.Runtime.call(pid, :add, [5, 3])
+            pid
+          end)
+        end
 
       pids = Task.await_many(tasks, 10_000)
       assert length(pids) == 10
@@ -278,13 +280,15 @@ defmodule Firebird.ModuleCacheEdgeCasesTest do
     test "concurrent loads of different files" do
       files = [@fixture_path, @crypto_fixture_path]
 
-      tasks = for i <- 1..6 do
-        file = Enum.at(files, rem(i, length(files)))
-        Task.async(fn ->
-          {:ok, pid} = Firebird.ModuleCache.load(file)
-          pid
-        end)
-      end
+      tasks =
+        for i <- 1..6 do
+          file = Enum.at(files, rem(i, length(files)))
+
+          Task.async(fn ->
+            {:ok, pid} = Firebird.ModuleCache.load(file)
+            pid
+          end)
+        end
 
       pids = Task.await_many(tasks, 10_000)
       assert length(pids) == 6
@@ -299,22 +303,24 @@ defmodule Firebird.ModuleCacheEdgeCasesTest do
       Firebird.Runtime.stop(initial_pid)
 
       # Concurrently load and clear - should not crash
-      tasks = for i <- 1..10 do
-        Task.async(fn ->
-          if rem(i, 3) == 0 do
-            Firebird.ModuleCache.clear()
-            :cleared
-          else
-            case Firebird.ModuleCache.load(@fixture_path) do
-              {:ok, pid} ->
-                Firebird.Runtime.stop(pid)
-                :loaded
-              {:error, _} ->
-                :error
+      tasks =
+        for i <- 1..10 do
+          Task.async(fn ->
+            if rem(i, 3) == 0 do
+              Firebird.ModuleCache.clear()
+              :cleared
+            else
+              case Firebird.ModuleCache.load(@fixture_path) do
+                {:ok, pid} ->
+                  Firebird.Runtime.stop(pid)
+                  :loaded
+
+                {:error, _} ->
+                  :error
+              end
             end
-          end
-        end)
-      end
+          end)
+        end
 
       results = Task.await_many(tasks, 10_000)
       # All should complete without crashing
diff --git a/test/module_cache_test.exs b/test/module_cache_test.exs
index d8a1168..9584a19 100644
--- a/test/module_cache_test.exs
+++ b/test/module_cache_test.exs
@@ -12,6 +12,7 @@ defmodule Firebird.ModuleCacheTest do
         on_exit(fn ->
           if Process.alive?(pid), do: GenServer.stop(pid)
         end)
+
         {:ok, cache_pid: pid, name: name}
 
       {:error, {:already_started, pid}} ->
@@ -49,6 +50,7 @@ defmodule Firebird.ModuleCacheTest do
     test "stats returns zeros when table doesn't exist" do
       # Delete the table if it exists to test fallback
       table = :firebird_module_cache
+
       if :ets.whereis(table) != :undefined do
         # Table exists from setup - stats should have real values
         stats = ModuleCache.stats()
diff --git a/test/module_call_one_test.exs b/test/module_call_one_test.exs
index 99dcf73..a6d11f0 100644
--- a/test/module_call_one_test.exs
+++ b/test/module_call_one_test.exs
@@ -9,6 +9,7 @@ defmodule Firebird.ModuleCallOneTest do
 
   setup do
     {:ok, _pid} = TestMath.start_link(name: :module_call_one_test)
+
     on_exit(fn ->
       try do
         TestMath.stop(name: :module_call_one_test)
@@ -16,6 +17,7 @@ defmodule Firebird.ModuleCallOneTest do
         :exit, _ -> :ok
       end
     end)
+
     :ok
   end
 
diff --git a/test/module_test.exs b/test/module_test.exs
index bc43e2e..4d24774 100644
--- a/test/module_test.exs
+++ b/test/module_test.exs
@@ -148,7 +148,9 @@ defmodule Firebird.ModuleTest do
 
   describe "GenServer lifecycle" do
     test "start_link starts the WASM instance" do
-      assert {:ok, pid} = TestMath.start_link(name: :"test_math_#{:erlang.unique_integer([:positive])}")
+      assert {:ok, pid} =
+               TestMath.start_link(name: :"test_math_#{:erlang.unique_integer([:positive])}")
+
       assert Process.alive?(pid)
       GenServer.stop(pid)
     end
@@ -287,10 +289,12 @@ defmodule Firebird.ModuleTest do
     end
 
     test "multiple rapid calls", %{name: name} do
-      results = for i <- 1..50 do
-        {:ok, [result]} = TestMath.call("add", [i, i], name: name)
-        result
-      end
+      results =
+        for i <- 1..50 do
+          {:ok, [result]} = TestMath.call("add", [i, i], name: name)
+          result
+        end
+
       assert results == Enum.map(1..50, &(&1 * 2))
     end
   end
@@ -359,12 +363,13 @@ defmodule Firebird.ModuleTest do
       {:ok, pid} = TestMath.start_link(name: name)
       on_exit(fn -> catch_exit(GenServer.stop(pid)) end)
 
-      tasks = for i <- 1..20 do
-        Task.async(fn ->
-          {:ok, [result]} = TestMath.call("add", [i, i], name: name)
-          result
-        end)
-      end
+      tasks =
+        for i <- 1..20 do
+          Task.async(fn ->
+            {:ok, [result]} = TestMath.call("add", [i, i], name: name)
+            result
+          end)
+        end
 
       results = Task.await_many(tasks, 5000)
       assert results == Enum.map(1..20, &(&1 * 2))
diff --git a/test/phoenix/api_completeness_test.exs b/test/phoenix/api_completeness_test.exs
index 7113b3d..6e60e76 100644
--- a/test/phoenix/api_completeness_test.exs
+++ b/test/phoenix/api_completeness_test.exs
@@ -13,7 +13,18 @@ defmodule Firebird.Phoenix.ApiCompletenessTest do
 
   describe "Firebird.Phoenix top-level API" do
     test "start/0 returns all 10 components", %{c: c} do
-      for key <- [:router, :template, :plug, :endpoint, :view, :controller, :channel, :json, :session, :live] do
+      for key <- [
+            :router,
+            :template,
+            :plug,
+            :endpoint,
+            :view,
+            :controller,
+            :channel,
+            :json,
+            :session,
+            :live
+          ] do
         assert Map.has_key?(c, key), "Missing component: #{key}"
         assert is_pid(c[key]), "#{key} should be a pid"
       end
@@ -30,13 +41,15 @@ defmodule Firebird.Phoenix.ApiCompletenessTest do
     end
 
     test "process_request/2 with full options", %{c: c} do
-      {:ok, resp} = Firebird.Phoenix.process_request(c,
-        method: "GET",
-        path: "/api/items/1",
-        headers: %{"accept" => "application/json"},
-        routes: [{"GET", "/api/items/:id", "ItemController.show"}],
-        actions: %{"ItemController.show" => {200, "application/json", ~s({"id":"{{id}}"})}}
-      )
+      {:ok, resp} =
+        Firebird.Phoenix.process_request(c,
+          method: "GET",
+          path: "/api/items/1",
+          headers: %{"accept" => "application/json"},
+          routes: [{"GET", "/api/items/:id", "ItemController.show"}],
+          actions: %{"ItemController.show" => {200, "application/json", ~s({"id":"{{id}}"})}}
+        )
+
       assert resp.status == 200
       assert resp.body =~ "1"
     end
@@ -44,32 +57,40 @@ defmodule Firebird.Phoenix.ApiCompletenessTest do
 
   describe "Firebird.Phoenix.Router API" do
     test "match/4 with GET route", %{c: c} do
-      {:ok, match} = Firebird.Phoenix.Router.match(c.router, "GET", "/users/1", [
-        {"GET", "/users/:id", "UserController.show"}
-      ])
+      {:ok, match} =
+        Firebird.Phoenix.Router.match(c.router, "GET", "/users/1", [
+          {"GET", "/users/:id", "UserController.show"}
+        ])
+
       assert match.handler == "UserController.show"
       assert match.params["id"] == "1"
     end
 
     test "match/4 with POST route", %{c: c} do
-      {:ok, match} = Firebird.Phoenix.Router.match(c.router, "POST", "/users", [
-        {"POST", "/users", "UserController.create"}
-      ])
+      {:ok, match} =
+        Firebird.Phoenix.Router.match(c.router, "POST", "/users", [
+          {"POST", "/users", "UserController.create"}
+        ])
+
       assert match.handler == "UserController.create"
     end
 
     test "match/4 returns not_found", %{c: c} do
-      {:ok, result} = Firebird.Phoenix.Router.match(c.router, "GET", "/nonexistent", [
-        {"GET", "/users", "UserController.index"}
-      ])
+      {:ok, result} =
+        Firebird.Phoenix.Router.match(c.router, "GET", "/nonexistent", [
+          {"GET", "/users", "UserController.index"}
+        ])
+
       assert result == :not_found
     end
 
     test "compile/2 and match_compiled/3", %{c: c} do
-      {:ok, count} = Firebird.Phoenix.Router.compile(c.router, [
-        {"GET", "/posts/:id", "PostController.show"},
-        {"GET", "/posts", "PostController.index"}
-      ])
+      {:ok, count} =
+        Firebird.Phoenix.Router.compile(c.router, [
+          {"GET", "/posts/:id", "PostController.show"},
+          {"GET", "/posts", "PostController.index"}
+        ])
+
       assert count == 2
 
       {:ok, match} = Firebird.Phoenix.Router.match_compiled(c.router, "GET", "/posts/42")
@@ -78,15 +99,18 @@ defmodule Firebird.Phoenix.ApiCompletenessTest do
     end
 
     test "match_batch/2 processes multiple requests", %{c: c} do
-      {:ok, _} = Firebird.Phoenix.Router.compile(c.router, [
-        {"GET", "/a/:id", "A.show"},
-        {"GET", "/b/:id", "B.show"}
-      ])
-
-      {:ok, results} = Firebird.Phoenix.Router.match_batch(c.router, [
-        {"GET", "/a/1"},
-        {"GET", "/b/2"}
-      ])
+      {:ok, _} =
+        Firebird.Phoenix.Router.compile(c.router, [
+          {"GET", "/a/:id", "A.show"},
+          {"GET", "/b/:id", "B.show"}
+        ])
+
+      {:ok, results} =
+        Firebird.Phoenix.Router.match_batch(c.router, [
+          {"GET", "/a/1"},
+          {"GET", "/b/2"}
+        ])
+
       assert length(results) == 2
     end
 
@@ -104,20 +128,24 @@ defmodule Firebird.Phoenix.ApiCompletenessTest do
 
   describe "Firebird.Phoenix.Template API" do
     test "render/3 with variable substitution", %{c: c} do
-      {:ok, html} = Firebird.Phoenix.Template.render(c.template,
-        "<h1>{{title}}</h1>", %{"title" => "Hello"})
+      {:ok, html} =
+        Firebird.Phoenix.Template.render(c.template, "<h1>{{title}}</h1>", %{"title" => "Hello"})
+
       assert html =~ "Hello"
     end
 
     test "render/3 with multiple variables", %{c: c} do
-      {:ok, html} = Firebird.Phoenix.Template.render(c.template,
-        "{{a}} and {{b}}", %{"a" => "X", "b" => "Y"})
+      {:ok, html} =
+        Firebird.Phoenix.Template.render(c.template, "{{a}} and {{b}}", %{"a" => "X", "b" => "Y"})
+
       assert html =~ "X"
       assert html =~ "Y"
     end
 
     test "html_escape", %{c: c} do
-      {:ok, escaped} = Firebird.Phoenix.Template.html_escape(c.template, "<script>alert('xss')</script>")
+      {:ok, escaped} =
+        Firebird.Phoenix.Template.html_escape(c.template, "<script>alert('xss')</script>")
+
       assert escaped =~ "&lt;script&gt;"
       refute escaped =~ "<script>"
     end
@@ -132,7 +160,9 @@ defmodule Firebird.Phoenix.ApiCompletenessTest do
     end
 
     test "build_response/4 builds HTTP response", %{c: c} do
-      {:ok, response} = Firebird.Phoenix.Plug.build_response(c.plug, 200, "text/html", "<h1>OK</h1>")
+      {:ok, response} =
+        Firebird.Phoenix.Plug.build_response(c.plug, 200, "text/html", "<h1>OK</h1>")
+
       assert response =~ "200" or is_binary(response)
     end
   end
@@ -155,9 +185,12 @@ defmodule Firebird.Phoenix.ApiCompletenessTest do
     end
 
     test "encode_array/2 encodes a list", %{c: c} do
-      {:ok, json} = Firebird.Phoenix.JSON.encode_array(c.json, [
-        %{"id" => "1"}, %{"id" => "2"}
-      ])
+      {:ok, json} =
+        Firebird.Phoenix.JSON.encode_array(c.json, [
+          %{"id" => "1"},
+          %{"id" => "2"}
+        ])
+
       assert json =~ "1"
       assert json =~ "2"
     end
@@ -184,16 +217,20 @@ defmodule Firebird.Phoenix.ApiCompletenessTest do
 
   describe "Firebird.Phoenix.Channel API" do
     test "match_topic/3 matches channel topic", %{c: c} do
-      {:ok, match} = Firebird.Phoenix.Channel.match_topic(c.channel, "room:lobby", [
-        {"room:*", "RoomChannel"}
-      ])
+      {:ok, match} =
+        Firebird.Phoenix.Channel.match_topic(c.channel, "room:lobby", [
+          {"room:*", "RoomChannel"}
+        ])
+
       assert is_map(match) or is_binary(match)
     end
 
     test "serialize_message/5 creates message", %{c: c} do
-      {:ok, msg} = Firebird.Phoenix.Channel.serialize_message(c.channel, "room:lobby", "new_msg", %{
-        "text" => "hello"
-      })
+      {:ok, msg} =
+        Firebird.Phoenix.Channel.serialize_message(c.channel, "room:lobby", "new_msg", %{
+          "text" => "hello"
+        })
+
       assert is_binary(msg)
     end
   end
@@ -208,7 +245,9 @@ defmodule Firebird.Phoenix.ApiCompletenessTest do
     end
 
     test "render_partial/3 renders partial template", %{c: c} do
-      {:ok, html} = Firebird.Phoenix.View.render_partial(c.view, "<li>{{item}}</li>", %{"item" => "Apple"})
+      {:ok, html} =
+        Firebird.Phoenix.View.render_partial(c.view, "<li>{{item}}</li>", %{"item" => "Apple"})
+
       assert html =~ "Apple"
     end
   end
@@ -221,11 +260,12 @@ defmodule Firebird.Phoenix.ApiCompletenessTest do
     end
 
     test "full conn lifecycle" do
-      conn = Firebird.Phoenix.Conn.new("POST", "/api/items?sort=name")
-      |> Firebird.Phoenix.Conn.put_req_header("content-type", "application/json")
-      |> Firebird.Phoenix.Conn.assign(:user, "alice")
-      |> Firebird.Phoenix.Conn.merge_params(%{"name" => "Widget"})
-      |> Firebird.Phoenix.Conn.send_resp(201, ~s({"created":true}))
+      conn =
+        Firebird.Phoenix.Conn.new("POST", "/api/items?sort=name")
+        |> Firebird.Phoenix.Conn.put_req_header("content-type", "application/json")
+        |> Firebird.Phoenix.Conn.assign(:user, "alice")
+        |> Firebird.Phoenix.Conn.merge_params(%{"name" => "Widget"})
+        |> Firebird.Phoenix.Conn.send_resp(201, ~s({"created":true}))
 
       assert conn.method == "POST"
       assert conn.path == "/api/items"
@@ -241,11 +281,14 @@ defmodule Firebird.Phoenix.ApiCompletenessTest do
 
   describe "Firebird.Phoenix.Middleware API" do
     test "full middleware chain" do
-      chain = Firebird.Phoenix.Middleware.new()
-      |> Firebird.Phoenix.Middleware.use(Firebird.Phoenix.Middleware.request_id())
-      |> Firebird.Phoenix.Middleware.use(Firebird.Phoenix.Middleware.timer())
-      |> Firebird.Phoenix.Middleware.use(Firebird.Phoenix.Middleware.logger())
-      |> Firebird.Phoenix.Middleware.use(Firebird.Phoenix.Middleware.default_header("x-powered-by", "Firebird"))
+      chain =
+        Firebird.Phoenix.Middleware.new()
+        |> Firebird.Phoenix.Middleware.use(Firebird.Phoenix.Middleware.request_id())
+        |> Firebird.Phoenix.Middleware.use(Firebird.Phoenix.Middleware.timer())
+        |> Firebird.Phoenix.Middleware.use(Firebird.Phoenix.Middleware.logger())
+        |> Firebird.Phoenix.Middleware.use(
+          Firebird.Phoenix.Middleware.default_header("x-powered-by", "Firebird")
+        )
 
       assert Firebird.Phoenix.Middleware.count(chain) == 4
 
@@ -259,11 +302,13 @@ defmodule Firebird.Phoenix.ApiCompletenessTest do
     end
 
     test "halting middleware" do
-      chain = Firebird.Phoenix.Middleware.new()
-      |> Firebird.Phoenix.Middleware.use(Firebird.Phoenix.Middleware.accept("application/json"))
+      chain =
+        Firebird.Phoenix.Middleware.new()
+        |> Firebird.Phoenix.Middleware.use(Firebird.Phoenix.Middleware.accept("application/json"))
 
-      conn = Firebird.Phoenix.Conn.new("GET", "/api")
-      |> Firebird.Phoenix.Conn.put_req_header("accept", "text/xml")
+      conn =
+        Firebird.Phoenix.Conn.new("GET", "/api")
+        |> Firebird.Phoenix.Conn.put_req_header("accept", "text/xml")
 
       {:halted, conn} = Firebird.Phoenix.Middleware.run(chain, conn)
       assert conn.status == 406
@@ -277,9 +322,9 @@ defmodule Firebird.Phoenix.ApiCompletenessTest do
     end
 
     test "extract_variables/1 finds template variables" do
-      vars = Firebird.Phoenix.EExCompiler.extract_variables(
-        "<%= @name %> is <%= @age %> years old"
-      )
+      vars =
+        Firebird.Phoenix.EExCompiler.extract_variables("<%= @name %> is <%= @age %> years old")
+
       assert "name" in vars
       assert "age" in vars
     end
@@ -307,10 +352,11 @@ defmodule Firebird.Phoenix.ApiCompletenessTest do
 
   describe "Firebird.Phoenix.Config API" do
     test "full config lifecycle" do
-      config = Firebird.Phoenix.Config.new(secret_key_base: "test-secret")
-      |> Firebird.Phoenix.Config.put(:port, 8080)
-      |> Firebird.Phoenix.Config.put_pipeline(:api, ["accept:application/json"])
-      |> Firebird.Phoenix.Config.put_route("GET", "/", "PageController.index")
+      config =
+        Firebird.Phoenix.Config.new(secret_key_base: "test-secret")
+        |> Firebird.Phoenix.Config.put(:port, 8080)
+        |> Firebird.Phoenix.Config.put_pipeline(:api, ["accept:application/json"])
+        |> Firebird.Phoenix.Config.put_route("GET", "/", "PageController.index")
 
       assert Firebird.Phoenix.Config.get(config, :port) == 8080
       assert Firebird.Phoenix.Config.pipeline(config, :api) == ["accept:application/json"]
@@ -321,9 +367,10 @@ defmodule Firebird.Phoenix.ApiCompletenessTest do
 
   describe "Firebird.Phoenix.Pipeline API" do
     test "defines and retrieves pipelines" do
-      pipeline = Firebird.Phoenix.Pipeline.new()
-      |> Firebird.Phoenix.Pipeline.plug(:api, ["accept:json", "cors:*"])
-      |> Firebird.Phoenix.Pipeline.plug(:browser, ["accept:html"])
+      pipeline =
+        Firebird.Phoenix.Pipeline.new()
+        |> Firebird.Phoenix.Pipeline.plug(:api, ["accept:json", "cors:*"])
+        |> Firebird.Phoenix.Pipeline.plug(:browser, ["accept:html"])
 
       assert Firebird.Phoenix.Pipeline.get(pipeline, :api) == ["accept:json", "cors:*"]
       assert :api in Firebird.Phoenix.Pipeline.names(pipeline)
@@ -372,12 +419,12 @@ defmodule Firebird.Phoenix.ApiCompletenessTest do
         use Firebird.Phoenix.RouterDSL
 
         pipeline :api do
-          plug "accept:application/json"
+          plug("accept:application/json")
         end
 
         scope "/api" do
-          get "/status", "StatusController.index"
-          resources "/items", "ItemController"
+          get("/status", "StatusController.index")
+          resources("/items", "ItemController")
         end
       end
 
@@ -394,9 +441,15 @@ defmodule Firebird.Phoenix.ApiCompletenessTest do
     test "handles requests with templates" do
       {:ok, handler} = Firebird.Phoenix.RequestHandler.new()
 
-      handler = handler
-      |> Firebird.Phoenix.RequestHandler.route("GET", "/greet/:name", "Greeter.hello")
-      |> Firebird.Phoenix.RequestHandler.template("Greeter.hello", 200, "text/plain", "Hello, {{name}}!")
+      handler =
+        handler
+        |> Firebird.Phoenix.RequestHandler.route("GET", "/greet/:name", "Greeter.hello")
+        |> Firebird.Phoenix.RequestHandler.template(
+          "Greeter.hello",
+          200,
+          "text/plain",
+          "Hello, {{name}}!"
+        )
 
       {:ok, conn} = Firebird.Phoenix.RequestHandler.handle(handler, "GET", "/greet/World")
       assert conn.status == 200
@@ -404,9 +457,3 @@ defmodule Firebird.Phoenix.ApiCompletenessTest do
     end
   end
 end
-
-
-
-
-
-
diff --git a/test/phoenix/app_dsl_test.exs b/test/phoenix/app_dsl_test.exs
index 70b7fe0..e3c6551 100644
--- a/test/phoenix/app_dsl_test.exs
+++ b/test/phoenix/app_dsl_test.exs
@@ -6,34 +6,38 @@ defmodule Firebird.Phoenix.AppDslTest do
     use Firebird.Phoenix.App
 
     routes do
-      get "/", "PageController.index"
-      get "/posts", "PostController.index"
-      get "/posts/:id", "PostController.show"
-      post "/posts", "PostController.create"
-      put "/posts/:id", "PostController.update"
-      delete "/posts/:id", "PostController.delete"
-      get "/health", "HealthController.check"
+      get("/", "PageController.index")
+      get("/posts", "PostController.index")
+      get("/posts/:id", "PostController.show")
+      post("/posts", "PostController.create")
+      put("/posts/:id", "PostController.update")
+      delete("/posts/:id", "PostController.delete")
+      get("/health", "HealthController.check")
     end
 
-    action "PageController.index", 200, "text/html",
-      "<h1>My Blog</h1>"
+    action("PageController.index", 200, "text/html", "<h1>My Blog</h1>")
 
-    action "PostController.index", 200, "application/json",
-      ~s([{"id":1,"title":"Hello"}])
+    action("PostController.index", 200, "application/json", ~s([{"id":1,"title":"Hello"}]))
 
-    action "PostController.show", 200, "application/json",
+    action(
+      "PostController.show",
+      200,
+      "application/json",
       ~s({"id":"{{id}}","title":"Post {{id}}"})
+    )
 
-    action "PostController.create", 201, "application/json",
-      ~s({"status":"created"})
+    action("PostController.create", 201, "application/json", ~s({"status":"created"}))
 
-    action "PostController.update", 200, "application/json",
+    action(
+      "PostController.update",
+      200,
+      "application/json",
       ~s({"id":"{{id}}","status":"updated"})
+    )
 
-    action "PostController.delete", 204, "application/json", ""
+    action("PostController.delete", 204, "application/json", "")
 
-    action "HealthController.check", 200, "application/json",
-      ~s({"ok":true})
+    action("HealthController.check", 200, "application/json", ~s({"ok":true}))
   end
 
   describe "app DSL" do
diff --git a/test/phoenix/application_test.exs b/test/phoenix/application_test.exs
index de5a68c..9fc13f1 100644
--- a/test/phoenix/application_test.exs
+++ b/test/phoenix/application_test.exs
@@ -14,10 +14,12 @@ defmodule Firebird.Phoenix.ApplicationTest do
     end
 
     test "starts with specific components only" do
-      {:ok, pid} = PhoenixApp.start_link(
-        name: :test_phoenix_app_2,
-        components: [:router, :template]
-      )
+      {:ok, pid} =
+        PhoenixApp.start_link(
+          name: :test_phoenix_app_2,
+          components: [:router, :template]
+        )
+
       comps = PhoenixApp.components(:test_phoenix_app_2)
       assert Map.has_key?(comps, :router)
       assert Map.has_key?(comps, :template)
@@ -28,20 +30,24 @@ defmodule Firebird.Phoenix.ApplicationTest do
 
   describe "get/2" do
     test "returns component pid" do
-      {:ok, pid} = PhoenixApp.start_link(
-        name: :test_phoenix_app_3,
-        components: [:router]
-      )
+      {:ok, pid} =
+        PhoenixApp.start_link(
+          name: :test_phoenix_app_3,
+          components: [:router]
+        )
+
       router = PhoenixApp.get(:test_phoenix_app_3, :router)
       assert is_pid(router)
       GenServer.stop(pid)
     end
 
     test "returns nil for unloaded component" do
-      {:ok, pid} = PhoenixApp.start_link(
-        name: :test_phoenix_app_4,
-        components: [:router]
-      )
+      {:ok, pid} =
+        PhoenixApp.start_link(
+          name: :test_phoenix_app_4,
+          components: [:router]
+        )
+
       assert PhoenixApp.get(:test_phoenix_app_4, :plug) == nil
       GenServer.stop(pid)
     end
@@ -49,10 +55,12 @@ defmodule Firebird.Phoenix.ApplicationTest do
 
   describe "healthy?/1" do
     test "returns true when all components alive" do
-      {:ok, pid} = PhoenixApp.start_link(
-        name: :test_phoenix_app_5,
-        components: [:router, :template]
-      )
+      {:ok, pid} =
+        PhoenixApp.start_link(
+          name: :test_phoenix_app_5,
+          components: [:router, :template]
+        )
+
       assert PhoenixApp.healthy?(:test_phoenix_app_5)
       GenServer.stop(pid)
     end
@@ -60,10 +68,12 @@ defmodule Firebird.Phoenix.ApplicationTest do
 
   describe "info/1" do
     test "returns component status" do
-      {:ok, pid} = PhoenixApp.start_link(
-        name: :test_phoenix_app_6,
-        components: [:router, :template]
-      )
+      {:ok, pid} =
+        PhoenixApp.start_link(
+          name: :test_phoenix_app_6,
+          components: [:router, :template]
+        )
+
       info = PhoenixApp.info(:test_phoenix_app_6)
       assert info.router == :running
       assert info.template == :running
@@ -73,18 +83,20 @@ defmodule Firebird.Phoenix.ApplicationTest do
 
   describe "process_request/2" do
     test "processes request through supervised pipeline" do
-      {:ok, pid} = PhoenixApp.start_link(
-        name: :test_phoenix_app_7,
-        components: [:router, :endpoint]
-      )
-
-      {:ok, resp} = PhoenixApp.process_request(:test_phoenix_app_7,
-        method: "GET",
-        path: "/users/42",
-        headers: %{"host" => "localhost"},
-        routes: [{"GET", "/users/:id", "UserController.show"}],
-        actions: %{"UserController.show" => {200, "application/json", ~s({"id":"{{id}}"})}}
-      )
+      {:ok, pid} =
+        PhoenixApp.start_link(
+          name: :test_phoenix_app_7,
+          components: [:router, :endpoint]
+        )
+
+      {:ok, resp} =
+        PhoenixApp.process_request(:test_phoenix_app_7,
+          method: "GET",
+          path: "/users/42",
+          headers: %{"host" => "localhost"},
+          routes: [{"GET", "/users/:id", "UserController.show"}],
+          actions: %{"UserController.show" => {200, "application/json", ~s({"id":"{{id}}"})}}
+        )
 
       assert resp.status == 200
       assert resp.body =~ "42"
diff --git a/test/phoenix/auth_test.exs b/test/phoenix/auth_test.exs
index 7df8119..8c3dd1a 100644
--- a/test/phoenix/auth_test.exs
+++ b/test/phoenix/auth_test.exs
@@ -5,10 +5,13 @@ defmodule Firebird.Phoenix.AuthTest do
 
   describe "bearer_token/1" do
     test "authenticates valid bearer token" do
-      chain = Middleware.new()
-      |> Middleware.use(Auth.bearer_token(fn token ->
-        if token == "valid-token", do: {:ok, %{id: 1, name: "Alice"}}, else: :unauthorized
-      end))
+      chain =
+        Middleware.new()
+        |> Middleware.use(
+          Auth.bearer_token(fn token ->
+            if token == "valid-token", do: {:ok, %{id: 1, name: "Alice"}}, else: :unauthorized
+          end)
+        )
 
       conn = Conn.new("GET", "/", headers: %{"authorization" => "Bearer valid-token"})
       {:ok, result} = Middleware.run(chain, conn)
@@ -17,8 +20,9 @@ defmodule Firebird.Phoenix.AuthTest do
     end
 
     test "rejects invalid bearer token" do
-      chain = Middleware.new()
-      |> Middleware.use(Auth.bearer_token(fn _token -> :unauthorized end))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Auth.bearer_token(fn _token -> :unauthorized end))
 
       conn = Conn.new("GET", "/", headers: %{"authorization" => "Bearer bad-token"})
       {:halted, result} = Middleware.run(chain, conn)
@@ -28,16 +32,18 @@ defmodule Firebird.Phoenix.AuthTest do
     end
 
     test "rejects missing authorization header" do
-      chain = Middleware.new()
-      |> Middleware.use(Auth.bearer_token(fn _token -> {:ok, %{}} end))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Auth.bearer_token(fn _token -> {:ok, %{}} end))
 
       {:halted, result} = Middleware.run(chain, Conn.new("GET", "/"))
       assert result.status == 401
     end
 
     test "rejects non-bearer authorization" do
-      chain = Middleware.new()
-      |> Middleware.use(Auth.bearer_token(fn _token -> {:ok, %{}} end))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Auth.bearer_token(fn _token -> {:ok, %{}} end))
 
       conn = Conn.new("GET", "/", headers: %{"authorization" => "Basic abc123"})
       {:halted, result} = Middleware.run(chain, conn)
@@ -47,18 +53,22 @@ defmodule Firebird.Phoenix.AuthTest do
 
   describe "api_key/2" do
     test "authenticates valid API key" do
-      chain = Middleware.new()
-      |> Middleware.use(Auth.api_key("x-api-key", fn key ->
-        if key == "secret-key", do: :ok, else: :unauthorized
-      end))
+      chain =
+        Middleware.new()
+        |> Middleware.use(
+          Auth.api_key("x-api-key", fn key ->
+            if key == "secret-key", do: :ok, else: :unauthorized
+          end)
+        )
 
       conn = Conn.new("GET", "/", headers: %{"x-api-key" => "secret-key"})
       {:ok, _result} = Middleware.run(chain, conn)
     end
 
     test "rejects invalid API key" do
-      chain = Middleware.new()
-      |> Middleware.use(Auth.api_key("x-api-key", fn _key -> :unauthorized end))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Auth.api_key("x-api-key", fn _key -> :unauthorized end))
 
       conn = Conn.new("GET", "/", headers: %{"x-api-key" => "wrong"})
       {:halted, result} = Middleware.run(chain, conn)
@@ -66,8 +76,9 @@ defmodule Firebird.Phoenix.AuthTest do
     end
 
     test "rejects missing API key header" do
-      chain = Middleware.new()
-      |> Middleware.use(Auth.api_key("x-api-key", fn _key -> :ok end))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Auth.api_key("x-api-key", fn _key -> :ok end))
 
       {:halted, result} = Middleware.run(chain, Conn.new("GET", "/"))
       assert result.status == 401
@@ -76,10 +87,13 @@ defmodule Firebird.Phoenix.AuthTest do
 
   describe "basic_auth/1" do
     test "authenticates valid credentials" do
-      chain = Middleware.new()
-      |> Middleware.use(Auth.basic_auth(fn user, pass ->
-        if user == "admin" && pass == "secret", do: :ok, else: :unauthorized
-      end))
+      chain =
+        Middleware.new()
+        |> Middleware.use(
+          Auth.basic_auth(fn user, pass ->
+            if user == "admin" && pass == "secret", do: :ok, else: :unauthorized
+          end)
+        )
 
       encoded = Base.encode64("admin:secret")
       conn = Conn.new("GET", "/", headers: %{"authorization" => "Basic #{encoded}"})
@@ -88,8 +102,9 @@ defmodule Firebird.Phoenix.AuthTest do
     end
 
     test "rejects invalid credentials" do
-      chain = Middleware.new()
-      |> Middleware.use(Auth.basic_auth(fn _user, _pass -> :unauthorized end))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Auth.basic_auth(fn _user, _pass -> :unauthorized end))
 
       encoded = Base.encode64("user:wrong")
       conn = Conn.new("GET", "/", headers: %{"authorization" => "Basic #{encoded}"})
@@ -98,8 +113,9 @@ defmodule Firebird.Phoenix.AuthTest do
     end
 
     test "rejects malformed basic auth" do
-      chain = Middleware.new()
-      |> Middleware.use(Auth.basic_auth(fn _user, _pass -> :ok end))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Auth.basic_auth(fn _user, _pass -> :ok end))
 
       conn = Conn.new("GET", "/", headers: %{"authorization" => "Basic !!!invalid!!!"})
       {:halted, result} = Middleware.run(chain, conn)
@@ -107,8 +123,9 @@ defmodule Firebird.Phoenix.AuthTest do
     end
 
     test "rejects missing auth header" do
-      chain = Middleware.new()
-      |> Middleware.use(Auth.basic_auth(fn _user, _pass -> :ok end))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Auth.basic_auth(fn _user, _pass -> :ok end))
 
       {:halted, result} = Middleware.run(chain, Conn.new("GET", "/"))
       assert result.status == 401
@@ -117,17 +134,19 @@ defmodule Firebird.Phoenix.AuthTest do
 
   describe "require_role/2" do
     test "passes for matching role" do
-      chain = Middleware.new()
-      |> Middleware.use(fn conn -> Conn.assign(conn, :current_user, %{role: :admin}) end)
-      |> Middleware.use(Auth.require_role(:admin, fn user -> user.role end))
+      chain =
+        Middleware.new()
+        |> Middleware.use(fn conn -> Conn.assign(conn, :current_user, %{role: :admin}) end)
+        |> Middleware.use(Auth.require_role(:admin, fn user -> user.role end))
 
       {:ok, _result} = Middleware.run(chain, Conn.new("GET", "/"))
     end
 
     test "rejects non-matching role" do
-      chain = Middleware.new()
-      |> Middleware.use(fn conn -> Conn.assign(conn, :current_user, %{role: :user}) end)
-      |> Middleware.use(Auth.require_role(:admin, fn user -> user.role end))
+      chain =
+        Middleware.new()
+        |> Middleware.use(fn conn -> Conn.assign(conn, :current_user, %{role: :user}) end)
+        |> Middleware.use(Auth.require_role(:admin, fn user -> user.role end))
 
       {:halted, result} = Middleware.run(chain, Conn.new("GET", "/"))
       assert result.status == 403
@@ -135,8 +154,9 @@ defmodule Firebird.Phoenix.AuthTest do
     end
 
     test "rejects when no user assigned" do
-      chain = Middleware.new()
-      |> Middleware.use(Auth.require_role(:admin, fn user -> user.role end))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Auth.require_role(:admin, fn user -> user.role end))
 
       {:halted, result} = Middleware.run(chain, Conn.new("GET", "/"))
       assert result.status == 401
@@ -145,8 +165,9 @@ defmodule Firebird.Phoenix.AuthTest do
 
   describe "rate_limit/2" do
     test "allows requests within limit" do
-      chain = Middleware.new()
-      |> Middleware.use(Auth.rate_limit(100, 60_000))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Auth.rate_limit(100, 60_000))
 
       conn = Conn.new("GET", "/rate-test-#{System.unique_integer([:positive])}")
       {:ok, _result} = Middleware.run(chain, conn)
@@ -154,8 +175,10 @@ defmodule Firebird.Phoenix.AuthTest do
 
     test "blocks requests exceeding limit" do
       path = "/rate-limit-test-#{System.unique_integer([:positive])}"
-      chain = Middleware.new()
-      |> Middleware.use(Auth.rate_limit(3, 60_000))
+
+      chain =
+        Middleware.new()
+        |> Middleware.use(Auth.rate_limit(3, 60_000))
 
       # First 3 requests should pass
       for _ <- 1..3 do
@@ -173,15 +196,18 @@ defmodule Firebird.Phoenix.AuthTest do
 
   describe "combined auth + authorization" do
     test "bearer token + role check" do
-      chain = Middleware.new()
-      |> Middleware.use(Auth.bearer_token(fn token ->
-        case token do
-          "admin-token" -> {:ok, %{id: 1, role: :admin}}
-          "user-token" -> {:ok, %{id: 2, role: :user}}
-          _ -> :unauthorized
-        end
-      end))
-      |> Middleware.use(Auth.require_role(:admin, fn user -> user.role end))
+      chain =
+        Middleware.new()
+        |> Middleware.use(
+          Auth.bearer_token(fn token ->
+            case token do
+              "admin-token" -> {:ok, %{id: 1, role: :admin}}
+              "user-token" -> {:ok, %{id: 2, role: :user}}
+              _ -> :unauthorized
+            end
+          end)
+        )
+        |> Middleware.use(Auth.require_role(:admin, fn user -> user.role end))
 
       # Admin token passes
       conn = Conn.new("GET", "/admin", headers: %{"authorization" => "Bearer admin-token"})
diff --git a/test/phoenix/benchmark_report_test.exs b/test/phoenix/benchmark_report_test.exs
index 636cfef..de13b1f 100644
--- a/test/phoenix/benchmark_report_test.exs
+++ b/test/phoenix/benchmark_report_test.exs
@@ -11,38 +11,44 @@ defmodule Firebird.Phoenix.BenchmarkReportTest do
   describe "performance thresholds" do
     test "router: compiled match under 100µs avg" do
       result = Benchmark.run(:router, iterations: 500)
+
       assert result.compiled.avg_us < 100,
-        "Compiled match avg #{result.compiled.avg_us}µs exceeds 100µs threshold"
+             "Compiled match avg #{result.compiled.avg_us}µs exceeds 100µs threshold"
     end
 
     test "template: simple render under 100µs avg" do
       result = Benchmark.run(:template, iterations: 500)
+
       assert result.simple.avg_us < 100,
-        "Template render avg #{result.simple.avg_us}µs exceeds 100µs threshold"
+             "Template render avg #{result.simple.avg_us}µs exceeds 100µs threshold"
     end
 
     test "plug: request parse under 100µs avg" do
       result = Benchmark.run(:plug, iterations: 500)
+
       assert result.parse.avg_us < 100,
-        "Request parse avg #{result.parse.avg_us}µs exceeds 100µs threshold"
+             "Request parse avg #{result.parse.avg_us}µs exceeds 100µs threshold"
     end
 
     test "plug: response build under 100µs avg" do
       result = Benchmark.run(:plug, iterations: 500)
+
       assert result.build.avg_us < 100,
-        "Response build avg #{result.build.avg_us}µs exceeds 100µs threshold"
+             "Response build avg #{result.build.avg_us}µs exceeds 100µs threshold"
     end
 
     test "endpoint: full dispatch under 200µs avg" do
       result = Benchmark.run(:endpoint, iterations: 500)
+
       assert result.dispatch.avg_us < 200,
-        "Full dispatch avg #{result.dispatch.avg_us}µs exceeds 200µs threshold"
+             "Full dispatch avg #{result.dispatch.avg_us}µs exceeds 200µs threshold"
     end
 
     test "json: encode under 100µs avg" do
       result = Benchmark.run(:json, iterations: 500)
+
       assert result.encode.avg_us < 100,
-        "JSON encode avg #{result.encode.avg_us}µs exceeds 100µs threshold"
+             "JSON encode avg #{result.encode.avg_us}µs exceeds 100µs threshold"
     end
   end
 
@@ -50,9 +56,11 @@ defmodule Firebird.Phoenix.BenchmarkReportTest do
   describe "benchmark output format" do
     test "router results contain expected fields" do
       result = Benchmark.run(:router, iterations: 50)
+
       for key <- [:compiled, :non_compiled, :elixir_baseline, :batch, :nested] do
         assert Map.has_key?(result, key), "Missing key: #{key}"
       end
+
       for key <- [:avg_us, :p50_us, :p95_us, :p99_us, :ops_per_sec, :iterations] do
         assert Map.has_key?(result.compiled, key), "Compiled missing: #{key}"
       end
diff --git a/test/phoenix/benchmark_test.exs b/test/phoenix/benchmark_test.exs
index b2bf40d..0943059 100644
--- a/test/phoenix/benchmark_test.exs
+++ b/test/phoenix/benchmark_test.exs
@@ -27,7 +27,13 @@ defmodule Firebird.Phoenix.BenchmarkTest do
     max = Enum.max(times)
     p99 = Enum.sort(times) |> Enum.at(round(iterations * 0.99) - 1)
 
-    %{avg_us: avg / 1.0, min_us: min / 1.0, max_us: max / 1.0, p99_us: p99 / 1.0, iterations: iterations}
+    %{
+      avg_us: avg / 1.0,
+      min_us: min / 1.0,
+      max_us: max / 1.0,
+      p99_us: p99 / 1.0,
+      iterations: iterations
+    }
   end
 
   defp fmt(v), do: Float.round(v / 1.0, 1)
@@ -36,57 +42,74 @@ defmodule Firebird.Phoenix.BenchmarkTest do
     test "single route matching latency", %{c: c} do
       routes = [{"GET", "/users/:id", "UserController.show"}]
 
-      stats = bench(fn ->
-        {:ok, _} = Firebird.Phoenix.Router.match(c.router, "GET", "/users/42", routes)
-      end)
+      stats =
+        bench(fn ->
+          {:ok, _} = Firebird.Phoenix.Router.match(c.router, "GET", "/users/42", routes)
+        end)
+
+      IO.puts(
+        "\n  [Bench] Single route match: avg=#{fmt(stats.avg_us)}µs p99=#{fmt(stats.p99_us)}µs"
+      )
 
-      IO.puts("\n  [Bench] Single route match: avg=#{fmt(stats.avg_us)}µs p99=#{fmt(stats.p99_us)}µs")
       assert stats.avg_us < 2000
     end
 
     test "10-route table matching latency", %{c: c} do
-      routes = for i <- 1..10 do
-        {"GET", "/resource_#{i}/:id", "Resource#{i}Controller.show"}
-      end
+      routes =
+        for i <- 1..10 do
+          {"GET", "/resource_#{i}/:id", "Resource#{i}Controller.show"}
+        end
 
-      stats = bench(fn ->
-        {:ok, _} = Firebird.Phoenix.Router.match(c.router, "GET", "/resource_5/42", routes)
-      end)
+      stats =
+        bench(fn ->
+          {:ok, _} = Firebird.Phoenix.Router.match(c.router, "GET", "/resource_5/42", routes)
+        end)
 
       IO.puts("\n  [Bench] 10-route match: avg=#{fmt(stats.avg_us)}µs p99=#{fmt(stats.p99_us)}µs")
       assert stats.avg_us < 5000
     end
 
     test "50-route table matching latency", %{c: c} do
-      routes = for i <- 1..50 do
-        {"GET", "/resource_#{i}/:id", "Resource#{i}Controller.show"}
-      end
+      routes =
+        for i <- 1..50 do
+          {"GET", "/resource_#{i}/:id", "Resource#{i}Controller.show"}
+        end
 
-      stats = bench(fn ->
-        {:ok, _} = Firebird.Phoenix.Router.match(c.router, "GET", "/resource_25/42", routes)
-      end)
+      stats =
+        bench(fn ->
+          {:ok, _} = Firebird.Phoenix.Router.match(c.router, "GET", "/resource_25/42", routes)
+        end)
 
       IO.puts("\n  [Bench] 50-route match: avg=#{fmt(stats.avg_us)}µs p99=#{fmt(stats.p99_us)}µs")
       assert stats.avg_us < 10000
     end
 
     test "compiled routes are faster than uncompiled", %{c: c} do
-      routes = for i <- 1..20 do
-        {"GET", "/resource_#{i}/:id", "Resource#{i}Controller.show"}
-      end
+      routes =
+        for i <- 1..20 do
+          {"GET", "/resource_#{i}/:id", "Resource#{i}Controller.show"}
+        end
 
       # Uncompiled benchmark
-      uncompiled_stats = bench(fn ->
-        {:ok, _} = Firebird.Phoenix.Router.match(c.router, "GET", "/resource_10/42", routes)
-      end, 50)
+      uncompiled_stats =
+        bench(
+          fn ->
+            {:ok, _} = Firebird.Phoenix.Router.match(c.router, "GET", "/resource_10/42", routes)
+          end,
+          50
+        )
 
       # Compile routes
       {:ok, _count} = Firebird.Phoenix.Router.compile(c.router, routes)
 
       # Compiled benchmark
-      compiled_stats = bench(fn ->
-        {:ok, _} = Firebird.Phoenix.Router.match_compiled(c.router, "GET", "/resource_10/42")
-      end, 50)
+      compiled_stats =
+        bench(
+          fn ->
+            {:ok, _} = Firebird.Phoenix.Router.match_compiled(c.router, "GET", "/resource_10/42")
+          end,
+          50
+        )
 
       IO.puts("\n  [Bench] Uncompiled 20 routes: avg=#{fmt(uncompiled_stats.avg_us)}µs")
       IO.puts("  [Bench] Compiled 20 routes: avg=#{fmt(compiled_stats.avg_us)}µs")
@@ -105,11 +128,13 @@ defmodule Firebird.Phoenix.BenchmarkTest do
       ]
 
       iterations = 1000
-      {total_us, _} = :timer.tc(fn ->
-        for _ <- 1..iterations do
-          Firebird.Phoenix.Router.match(c.router, "GET", "/users/42", routes)
-        end
-      end)
+
+      {total_us, _} =
+        :timer.tc(fn ->
+          for _ <- 1..iterations do
+            Firebird.Phoenix.Router.match(c.router, "GET", "/users/42", routes)
+          end
+        end)
 
       ops_per_sec = iterations / (total_us / 1_000_000)
       IO.puts("\n  [Bench] Route matching throughput: #{Float.round(ops_per_sec, 0)} ops/sec")
@@ -117,31 +142,44 @@ defmodule Firebird.Phoenix.BenchmarkTest do
     end
 
     test "batch matching throughput", %{c: c} do
-      routes = for i <- 1..10 do
-        {"GET", "/resource_#{i}/:id", "Resource#{i}Controller.show"}
-      end
+      routes =
+        for i <- 1..10 do
+          {"GET", "/resource_#{i}/:id", "Resource#{i}Controller.show"}
+        end
 
       {:ok, _} = Firebird.Phoenix.Router.compile(c.router, routes)
 
-      requests = for i <- 1..20 do
-        {"GET", "/resource_#{rem(i, 10) + 1}/#{i}"}
-      end
+      requests =
+        for i <- 1..20 do
+          {"GET", "/resource_#{rem(i, 10) + 1}/#{i}"}
+        end
 
-      stats = bench(fn ->
-        {:ok, _results} = Firebird.Phoenix.Router.match_batch(c.router, requests)
-      end, 50)
+      stats =
+        bench(
+          fn ->
+            {:ok, _results} = Firebird.Phoenix.Router.match_batch(c.router, requests)
+          end,
+          50
+        )
 
-      IO.puts("\n  [Bench] Batch match (20 requests): avg=#{fmt(stats.avg_us)}µs (#{fmt(stats.avg_us / 20)}µs/req)")
+      IO.puts(
+        "\n  [Bench] Batch match (20 requests): avg=#{fmt(stats.avg_us)}µs (#{fmt(stats.avg_us / 20)}µs/req)"
+      )
     end
   end
 
   describe "template benchmarks" do
     test "simple template rendering latency", %{c: c} do
-      stats = bench(fn ->
-        {:ok, _} = Firebird.Phoenix.Template.render(c.template, "<h1>{{name}}</h1>", %{"name" => "World"})
-      end)
+      stats =
+        bench(fn ->
+          {:ok, _} =
+            Firebird.Phoenix.Template.render(c.template, "<h1>{{name}}</h1>", %{"name" => "World"})
+        end)
+
+      IO.puts(
+        "\n  [Bench] Simple template render: avg=#{fmt(stats.avg_us)}µs p99=#{fmt(stats.p99_us)}µs"
+      )
 
-      IO.puts("\n  [Bench] Simple template render: avg=#{fmt(stats.avg_us)}µs p99=#{fmt(stats.p99_us)}µs")
       assert stats.avg_us < 2000
     end
 
@@ -164,11 +202,15 @@ defmodule Firebird.Phoenix.BenchmarkTest do
         "footer" => "Copyright 2024"
       }
 
-      stats = bench(fn ->
-        {:ok, _} = Firebird.Phoenix.Template.render(c.template, template, vars)
-      end)
+      stats =
+        bench(fn ->
+          {:ok, _} = Firebird.Phoenix.Template.render(c.template, template, vars)
+        end)
+
+      IO.puts(
+        "\n  [Bench] 5-var template render: avg=#{fmt(stats.avg_us)}µs p99=#{fmt(stats.p99_us)}µs"
+      )
 
-      IO.puts("\n  [Bench] 5-var template render: avg=#{fmt(stats.avg_us)}µs p99=#{fmt(stats.p99_us)}µs")
       assert stats.avg_us < 5000
     end
 
@@ -177,17 +219,27 @@ defmodule Firebird.Phoenix.BenchmarkTest do
       vars = %{"name" => "World", "message" => "Hello"}
 
       # WASM rendering
-      wasm_stats = bench(fn ->
-        {:ok, _} = Firebird.Phoenix.Template.render(c.template, template, vars)
-      end, 50)
+      wasm_stats =
+        bench(
+          fn ->
+            {:ok, _} = Firebird.Phoenix.Template.render(c.template, template, vars)
+          end,
+          50
+        )
 
       # Pure Elixir rendering
-      elixir_stats = bench(fn ->
-        result = Enum.reduce(vars, template, fn {k, v}, acc ->
-          String.replace(acc, "{{#{k}}}", v)
-        end)
-        {:ok, result}
-      end, 50)
+      elixir_stats =
+        bench(
+          fn ->
+            result =
+              Enum.reduce(vars, template, fn {k, v}, acc ->
+                String.replace(acc, "{{#{k}}}", v)
+              end)
+
+            {:ok, result}
+          end,
+          50
+        )
 
       IO.puts("\n  [Bench] WASM template: avg=#{fmt(wasm_stats.avg_us)}µs")
       IO.puts("  [Bench] Elixir template: avg=#{fmt(elixir_stats.avg_us)}µs")
@@ -198,11 +250,13 @@ defmodule Firebird.Phoenix.BenchmarkTest do
 
     test "template rendering throughput", %{c: c} do
       iterations = 500
-      {total_us, _} = :timer.tc(fn ->
-        for _ <- 1..iterations do
-          Firebird.Phoenix.Template.render(c.template, "<p>{{x}}</p>", %{"x" => "v"})
-        end
-      end)
+
+      {total_us, _} =
+        :timer.tc(fn ->
+          for _ <- 1..iterations do
+            Firebird.Phoenix.Template.render(c.template, "<p>{{x}}</p>", %{"x" => "v"})
+          end
+        end)
 
       ops_per_sec = iterations / (total_us / 1_000_000)
       IO.puts("\n  [Bench] Template throughput: #{Float.round(ops_per_sec, 0)} ops/sec")
@@ -216,29 +270,47 @@ defmodule Firebird.Phoenix.BenchmarkTest do
       routes = [{"GET", "/users/:id", "UserController.show"}]
       actions = %{"UserController.show" => {200, "application/json", ~s({"id":"{{id}}"})}}
 
-      stats = bench(fn ->
-        {:ok, _} = Firebird.Phoenix.Endpoint.dispatch(c.endpoint, raw_request, routes, actions)
-      end, 50)
+      stats =
+        bench(
+          fn ->
+            {:ok, _} =
+              Firebird.Phoenix.Endpoint.dispatch(c.endpoint, raw_request, routes, actions)
+          end,
+          50
+        )
+
+      IO.puts(
+        "\n  [Bench] Full request dispatch: avg=#{fmt(stats.avg_us)}µs p99=#{fmt(stats.p99_us)}µs"
+      )
 
-      IO.puts("\n  [Bench] Full request dispatch: avg=#{fmt(stats.avg_us)}µs p99=#{fmt(stats.p99_us)}µs")
       assert stats.avg_us < 10000
     end
   end
 
   describe "json benchmarks" do
     test "JSON object encoding latency", %{c: c} do
-      stats = bench(fn ->
-        {:ok, _} = Firebird.Phoenix.JSON.encode_object(c.json, %{"name" => "Alice", "age" => "30", "city" => "NYC"})
-      end)
+      stats =
+        bench(fn ->
+          {:ok, _} =
+            Firebird.Phoenix.JSON.encode_object(c.json, %{
+              "name" => "Alice",
+              "age" => "30",
+              "city" => "NYC"
+            })
+        end)
+
+      IO.puts(
+        "\n  [Bench] JSON encode (3 fields): avg=#{fmt(stats.avg_us)}µs p99=#{fmt(stats.p99_us)}µs"
+      )
 
-      IO.puts("\n  [Bench] JSON encode (3 fields): avg=#{fmt(stats.avg_us)}µs p99=#{fmt(stats.p99_us)}µs")
       assert stats.avg_us < 2000
     end
 
     test "API response building latency", %{c: c} do
-      stats = bench(fn ->
-        {:ok, _} = Firebird.Phoenix.JSON.api_response(c.json, 200, %{"name" => "Alice"})
-      end)
+      stats =
+        bench(fn ->
+          {:ok, _} = Firebird.Phoenix.JSON.api_response(c.json, 200, %{"name" => "Alice"})
+        end)
 
       IO.puts("\n  [Bench] API response build: avg=#{fmt(stats.avg_us)}µs")
       assert stats.avg_us < 2000
@@ -249,9 +321,10 @@ defmodule Firebird.Phoenix.BenchmarkTest do
     test "cookie parsing latency", %{c: c} do
       cookie_string = "session_id=abc123; user_pref=dark; lang=en; token=xyz789; theme=blue"
 
-      stats = bench(fn ->
-        {:ok, _} = Firebird.Phoenix.Session.parse_cookies(c.session, cookie_string)
-      end)
+      stats =
+        bench(fn ->
+          {:ok, _} = Firebird.Phoenix.Session.parse_cookies(c.session, cookie_string)
+        end)
 
       IO.puts("\n  [Bench] Cookie parsing (5 cookies): avg=#{fmt(stats.avg_us)}µs")
       assert stats.avg_us < 2000
@@ -260,20 +333,27 @@ defmodule Firebird.Phoenix.BenchmarkTest do
 
   describe "plug benchmarks" do
     test "request parsing latency", %{c: c} do
-      raw_request = "POST /api/users HTTP/1.1\r\nHost: localhost\r\nContent-Type: application/json\r\nAuthorization: Bearer token123\r\n\r\n{\"name\":\"Alice\"}"
+      raw_request =
+        "POST /api/users HTTP/1.1\r\nHost: localhost\r\nContent-Type: application/json\r\nAuthorization: Bearer token123\r\n\r\n{\"name\":\"Alice\"}"
+
+      stats =
+        bench(fn ->
+          {:ok, _} = Firebird.Phoenix.Plug.parse_request(c.plug, raw_request)
+        end)
 
-      stats = bench(fn ->
-        {:ok, _} = Firebird.Phoenix.Plug.parse_request(c.plug, raw_request)
-      end)
+      IO.puts(
+        "\n  [Bench] Request parsing: avg=#{fmt(stats.avg_us)}µs p99=#{fmt(stats.p99_us)}µs"
+      )
 
-      IO.puts("\n  [Bench] Request parsing: avg=#{fmt(stats.avg_us)}µs p99=#{fmt(stats.p99_us)}µs")
       assert stats.avg_us < 2000
     end
 
     test "response building latency", %{c: c} do
-      stats = bench(fn ->
-        {:ok, _} = Firebird.Phoenix.Plug.build_response(c.plug, 200, "application/json", ~s({"ok":true}))
-      end)
+      stats =
+        bench(fn ->
+          {:ok, _} =
+            Firebird.Phoenix.Plug.build_response(c.plug, 200, "application/json", ~s({"ok":true}))
+        end)
 
       IO.puts("\n  [Bench] Response building: avg=#{fmt(stats.avg_us)}µs")
       assert stats.avg_us < 2000
@@ -282,12 +362,14 @@ defmodule Firebird.Phoenix.BenchmarkTest do
 
   describe "channel benchmarks" do
     test "topic matching latency", %{c: c} do
-      stats = bench(fn ->
-        {:ok, _} = Firebird.Phoenix.Channel.match_topic(c.channel, "room:lobby", [
-          {"room:*", "RoomChannel"},
-          {"user:*", "UserChannel"}
-        ])
-      end)
+      stats =
+        bench(fn ->
+          {:ok, _} =
+            Firebird.Phoenix.Channel.match_topic(c.channel, "room:lobby", [
+              {"room:*", "RoomChannel"},
+              {"user:*", "UserChannel"}
+            ])
+        end)
 
       IO.puts("\n  [Bench] Topic match: avg=#{fmt(stats.avg_us)}µs")
       assert stats.avg_us < 2000
@@ -301,40 +383,52 @@ defmodule Firebird.Phoenix.BenchmarkTest do
         {"GET", "/users", "UserController.index"},
         {"POST", "/users", "UserController.create"}
       ]
+
       actions = %{
         "UserController.show" => {200, "application/json", ~s({"id":"{{id}}"})},
         "UserController.index" => {200, "application/json", "[]"},
         "UserController.create" => {201, "application/json", ~s({"created":true})}
       }
 
-      stats = bench(fn ->
-        {:ok, resp} = Firebird.Phoenix.process_request(c,
-          method: "GET",
-          path: "/users/42",
-          routes: routes,
-          actions: actions
+      stats =
+        bench(
+          fn ->
+            {:ok, resp} =
+              Firebird.Phoenix.process_request(c,
+                method: "GET",
+                path: "/users/42",
+                routes: routes,
+                actions: actions
+              )
+
+            assert resp.status == 200
+          end,
+          50
         )
-        assert resp.status == 200
-      end, 50)
 
-      IO.puts("\n  [Bench] Full process_request: avg=#{fmt(stats.avg_us)}µs p99=#{fmt(stats.p99_us)}µs")
+      IO.puts(
+        "\n  [Bench] Full process_request: avg=#{fmt(stats.avg_us)}µs p99=#{fmt(stats.p99_us)}µs"
+      )
+
       assert stats.avg_us < 10000
     end
 
     test "middleware + routing + rendering pipeline", %{c: _c} do
       alias Firebird.Phoenix.{Conn, Middleware}
 
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.request_id())
-      |> Middleware.use(Middleware.timer())
-      |> Middleware.use(Middleware.logger())
-
-      stats = bench(fn ->
-        conn = Conn.new("GET", "/api/users/42")
-        {:ok, conn} = Middleware.run(chain, conn)
-        assert conn.assigns[:request_id] != nil
-        assert conn.assigns[:request_start] != nil
-      end)
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.request_id())
+        |> Middleware.use(Middleware.timer())
+        |> Middleware.use(Middleware.logger())
+
+      stats =
+        bench(fn ->
+          conn = Conn.new("GET", "/api/users/42")
+          {:ok, conn} = Middleware.run(chain, conn)
+          assert conn.assigns[:request_id] != nil
+          assert conn.assigns[:request_start] != nil
+        end)
 
       IO.puts("\n  [Bench] 3-middleware chain: avg=#{fmt(stats.avg_us)}µs")
       assert stats.avg_us < 500
@@ -354,4 +448,3 @@ defmodule Firebird.Phoenix.BenchmarkTest do
     end
   end
 end
-
diff --git a/test/phoenix/channel_extended_test.exs b/test/phoenix/channel_extended_test.exs
index bad2711..0ad395d 100644
--- a/test/phoenix/channel_extended_test.exs
+++ b/test/phoenix/channel_extended_test.exs
@@ -13,14 +13,16 @@ defmodule Firebird.Phoenix.ChannelExtendedTest do
   describe "match_topic/3 extended" do
     test "matches exact topic", %{instance: instance} do
       patterns = [{"chat:lobby", "ChatChannel"}]
+
       assert {:ok, %{handler: "ChatChannel"}} =
-        Channel.match_topic(instance, "chat:lobby", patterns)
+               Channel.match_topic(instance, "chat:lobby", patterns)
     end
 
     test "matches wildcard subtopic", %{instance: instance} do
       patterns = [{"room:*", "RoomChannel"}]
+
       assert {:ok, %{handler: "RoomChannel"}} =
-        Channel.match_topic(instance, "room:123", patterns)
+               Channel.match_topic(instance, "room:123", patterns)
     end
 
     test "returns not_found for unmatched topic", %{instance: instance} do
@@ -34,8 +36,9 @@ defmodule Firebird.Phoenix.ChannelExtendedTest do
         {"room:lobby", "LobbyChannel"},
         {"room:*", "RoomChannel"}
       ]
+
       assert {:ok, %{handler: "LobbyChannel"}} =
-        Channel.match_topic(instance, "room:lobby", patterns)
+               Channel.match_topic(instance, "room:lobby", patterns)
     end
 
     test "handles multiple topic patterns", %{instance: instance} do
@@ -48,24 +51,27 @@ defmodule Firebird.Phoenix.ChannelExtendedTest do
       ]
 
       assert {:ok, %{handler: "RoomChannel"}} =
-        Channel.match_topic(instance, "room:general", patterns)
-      assert {:ok, %{handler: "UserChannel"}} =
-        Channel.match_topic(instance, "user:42", patterns)
+               Channel.match_topic(instance, "room:general", patterns)
+
+      assert {:ok, %{handler: "UserChannel"}} = Channel.match_topic(instance, "user:42", patterns)
+
       assert {:ok, %{handler: "AdminChannel"}} =
-        Channel.match_topic(instance, "admin:panel", patterns)
+               Channel.match_topic(instance, "admin:panel", patterns)
     end
   end
 
   describe "serialize_message/4" do
     test "serializes event message", %{instance: instance} do
-      result = Channel.serialize_message(instance, "room:lobby", "new_msg",
-        %{"body" => "hello"})
+      result = Channel.serialize_message(instance, "room:lobby", "new_msg", %{"body" => "hello"})
       assert match?({:ok, _}, result)
+
       case result do
         {:ok, json} ->
           assert json =~ "room:lobby"
           assert json =~ "new_msg"
-        _ -> :ok
+
+        _ ->
+          :ok
       end
     end
 
@@ -90,18 +96,20 @@ defmodule Firebird.Phoenix.ChannelExtendedTest do
       json = ~s({"topic":"room:lobby","event":"new_msg","payload":{"body":"hello"},"ref":"1"})
       result = Channel.deserialize_message(instance, json)
       assert match?({:ok, _}, result)
+
       case result do
         {:ok, msg} ->
           assert msg["topic"] == "room:lobby" or msg.topic == "room:lobby"
-        _ -> :ok
+
+        _ ->
+          :ok
       end
     end
   end
 
   describe "track_presence/5" do
     test "tracks user join", %{instance: instance} do
-      result = Channel.track_presence(instance, :join, "user:1",
-        %{}, %{"name" => "Alice"})
+      result = Channel.track_presence(instance, :join, "user:1", %{}, %{"name" => "Alice"})
       assert match?({:ok, _}, result)
     end
 
@@ -118,8 +126,9 @@ defmodule Firebird.Phoenix.ChannelExtendedTest do
 
   describe "build_broadcast/4" do
     test "builds broadcast message", %{instance: instance} do
-      result = Channel.build_broadcast(instance, "room:lobby", "new_msg",
-        %{"body" => "hello everyone"})
+      result =
+        Channel.build_broadcast(instance, "room:lobby", "new_msg", %{"body" => "hello everyone"})
+
       assert match?({:ok, _}, result)
     end
 
@@ -147,6 +156,7 @@ defmodule Firebird.Phoenix.ChannelExtendedTest do
         {"new_msg", "handle_new_msg"},
         {"delete_msg", "handle_delete_msg"}
       ]
+
       result = Channel.route_event(instance, "new_msg", handlers)
       assert match?({:ok, _}, result)
     end
diff --git a/test/phoenix/channel_test.exs b/test/phoenix/channel_test.exs
index 8b9b8b1..5a3e20f 100644
--- a/test/phoenix/channel_test.exs
+++ b/test/phoenix/channel_test.exs
@@ -13,27 +13,30 @@ defmodule Firebird.Phoenix.ChannelTest do
   describe "match_topic/3" do
     test "matches exact topic", %{instance: instance} do
       patterns = [{"room:lobby", "RoomChannel"}]
+
       assert {:ok, %{handler: "RoomChannel", params: %{}}} =
                Channel.match_topic(instance, "room:lobby", patterns)
     end
 
     test "matches wildcard topic", %{instance: instance} do
       patterns = [{"room:*", "RoomChannel"}]
+
       assert {:ok, %{handler: "RoomChannel", params: params}} =
                Channel.match_topic(instance, "room:lobby", patterns)
+
       assert params["subtopic"] == "lobby"
     end
 
     test "matches wildcard with numeric subtopic", %{instance: instance} do
       patterns = [{"room:*", "RoomChannel"}]
+
       assert {:ok, %{handler: "RoomChannel", params: %{"subtopic" => "123"}}} =
                Channel.match_topic(instance, "room:123", patterns)
     end
 
     test "returns not_found when no match", %{instance: instance} do
       patterns = [{"room:*", "RoomChannel"}]
-      assert {:ok, :not_found} =
-               Channel.match_topic(instance, "user:1", patterns)
+      assert {:ok, :not_found} = Channel.match_topic(instance, "user:1", patterns)
     end
 
     test "matches first matching pattern", %{instance: instance} do
@@ -41,8 +44,8 @@ defmodule Firebird.Phoenix.ChannelTest do
         {"room:*", "RoomChannel"},
         {"user:*", "UserChannel"}
       ]
-      assert {:ok, %{handler: "UserChannel"}} =
-               Channel.match_topic(instance, "user:42", patterns)
+
+      assert {:ok, %{handler: "UserChannel"}} = Channel.match_topic(instance, "user:42", patterns)
     end
 
     test "exact match takes priority over wildcard", %{instance: instance} do
@@ -50,6 +53,7 @@ defmodule Firebird.Phoenix.ChannelTest do
         {"room:lobby", "LobbyChannel"},
         {"room:*", "RoomChannel"}
       ]
+
       assert {:ok, %{handler: "LobbyChannel"}} =
                Channel.match_topic(instance, "room:lobby", patterns)
     end
@@ -73,8 +77,8 @@ defmodule Firebird.Phoenix.ChannelTest do
         {"new_msg", "handle_new_msg"},
         {"typing", "handle_typing"}
       ]
-      assert {:ok, "handle_new_msg"} =
-               Channel.route_event(instance, "new_msg", handlers)
+
+      assert {:ok, "handle_new_msg"} = Channel.route_event(instance, "new_msg", handlers)
     end
 
     test "routes to catch-all handler", %{instance: instance} do
@@ -82,14 +86,13 @@ defmodule Firebird.Phoenix.ChannelTest do
         {"specific", "handle_specific"},
         {"*", "handle_any"}
       ]
-      assert {:ok, "handle_any"} =
-               Channel.route_event(instance, "unknown_event", handlers)
+
+      assert {:ok, "handle_any"} = Channel.route_event(instance, "unknown_event", handlers)
     end
 
     test "returns not_found when no match", %{instance: instance} do
       handlers = [{"new_msg", "handle_new_msg"}]
-      assert {:ok, :not_found} =
-               Channel.route_event(instance, "typing", handlers)
+      assert {:ok, :not_found} = Channel.route_event(instance, "typing", handlers)
     end
 
     test "routes first matching handler", %{instance: instance} do
@@ -97,13 +100,12 @@ defmodule Firebird.Phoenix.ChannelTest do
         {"new_msg", "first_handler"},
         {"new_msg", "second_handler"}
       ]
-      assert {:ok, "first_handler"} =
-               Channel.route_event(instance, "new_msg", handlers)
+
+      assert {:ok, "first_handler"} = Channel.route_event(instance, "new_msg", handlers)
     end
 
     test "handles empty handler list", %{instance: instance} do
-      assert {:ok, :not_found} =
-               Channel.route_event(instance, "new_msg", [])
+      assert {:ok, :not_found} = Channel.route_event(instance, "new_msg", [])
     end
   end
 
@@ -133,8 +135,7 @@ defmodule Firebird.Phoenix.ChannelTest do
     end
 
     test "serializes message without ref", %{instance: instance} do
-      assert {:ok, json} =
-               Channel.serialize_message(instance, "room:lobby", "ping", %{})
+      assert {:ok, json} = Channel.serialize_message(instance, "room:lobby", "ping", %{})
 
       assert json =~ ~s("ref":null)
     end
@@ -162,8 +163,7 @@ defmodule Firebird.Phoenix.ChannelTest do
     end
 
     test "serializes empty payload", %{instance: instance} do
-      assert {:ok, json} =
-               Channel.serialize_message(instance, "room:lobby", "heartbeat", %{})
+      assert {:ok, json} = Channel.serialize_message(instance, "room:lobby", "heartbeat", %{})
 
       assert json =~ ~s("payload":{})
     end
@@ -208,8 +208,7 @@ defmodule Firebird.Phoenix.ChannelTest do
     end
 
     test "builds broadcast with empty payload", %{instance: instance} do
-      assert {:ok, json} =
-               Channel.build_broadcast(instance, "room:lobby", "user_joined")
+      assert {:ok, json} = Channel.build_broadcast(instance, "room:lobby", "user_joined")
 
       assert json =~ ~s("payload":{})
     end
@@ -243,8 +242,7 @@ defmodule Firebird.Phoenix.ChannelTest do
     test "tracks a user leave", %{instance: instance} do
       initial_state = %{"user:1" => ~s({"name":"Alice"}), "user:2" => ~s({"name":"Bob"})}
 
-      assert {:ok, state} =
-               Channel.track_presence(instance, :leave, "user:1", initial_state)
+      assert {:ok, state} = Channel.track_presence(instance, :leave, "user:1", initial_state)
 
       refute Map.has_key?(state, "user:1")
       assert Map.has_key?(state, "user:2")
@@ -283,8 +281,7 @@ defmodule Firebird.Phoenix.ChannelTest do
     end
 
     test "multiple joins build up state", %{instance: instance} do
-      {:ok, state1} =
-        Channel.track_presence(instance, :join, "user:1", %{}, %{"name" => "Alice"})
+      {:ok, state1} = Channel.track_presence(instance, :join, "user:1", %{}, %{"name" => "Alice"})
 
       {:ok, state2} =
         Channel.track_presence(instance, :join, "user:2", state1, %{"name" => "Bob"})
diff --git a/test/phoenix/compiled_router_test.exs b/test/phoenix/compiled_router_test.exs
index e1f5e3c..f0d3029 100644
--- a/test/phoenix/compiled_router_test.exs
+++ b/test/phoenix/compiled_router_test.exs
@@ -17,7 +17,7 @@ defmodule Firebird.Phoenix.CompiledRouterTest do
       {"GET", "/users/:user_id/posts", "PostController.index"},
       {"GET", "/users/:user_id/posts/:id", "PostController.show"},
       {"GET", "/api/v1/health", "Api.HealthController.check"},
-      {"GET", "/api/v1/users", "Api.UserController.index"},
+      {"GET", "/api/v1/users", "Api.UserController.index"}
     ]
 
     {:ok, count} = Router.compile(instance, routes)
@@ -37,12 +37,12 @@ defmodule Firebird.Phoenix.CompiledRouterTest do
   describe "match_compiled/3" do
     test "matches simple routes", %{instance: instance} do
       assert {:ok, %{handler: "PageController.index", params: %{}}} =
-        Router.match_compiled(instance, "GET", "/")
+               Router.match_compiled(instance, "GET", "/")
     end
 
     test "matches routes with params", %{instance: instance} do
       assert {:ok, %{handler: "UserController.show", params: %{"id" => "42"}}} =
-        Router.match_compiled(instance, "GET", "/users/42")
+               Router.match_compiled(instance, "GET", "/users/42")
     end
 
     test "matches nested params", %{instance: instance} do
@@ -58,15 +58,15 @@ defmodule Firebird.Phoenix.CompiledRouterTest do
 
     test "respects HTTP method", %{instance: instance} do
       assert {:ok, %{handler: "UserController.create"}} =
-        Router.match_compiled(instance, "POST", "/users")
+               Router.match_compiled(instance, "POST", "/users")
 
       assert {:ok, %{handler: "UserController.index"}} =
-        Router.match_compiled(instance, "GET", "/users")
+               Router.match_compiled(instance, "GET", "/users")
     end
 
     test "handles DELETE method", %{instance: instance} do
       assert {:ok, %{handler: "UserController.delete", params: %{"id" => "7"}}} =
-        Router.match_compiled(instance, "DELETE", "/users/7")
+               Router.match_compiled(instance, "DELETE", "/users/7")
     end
   end
 
@@ -76,14 +76,17 @@ defmodule Firebird.Phoenix.CompiledRouterTest do
         {"GET", "/users"},
         {"GET", "/users/42"},
         {"POST", "/users"},
-        {"GET", "/nonexistent"},
+        {"GET", "/nonexistent"}
       ]
 
       {:ok, results} = Router.match_batch(instance, requests)
       assert length(results) == 4
 
       assert {:ok, %{handler: "UserController.index"}} = Enum.at(results, 0)
-      assert {:ok, %{handler: "UserController.show", params: %{"id" => "42"}}} = Enum.at(results, 1)
+
+      assert {:ok, %{handler: "UserController.show", params: %{"id" => "42"}}} =
+               Enum.at(results, 1)
+
       assert {:ok, %{handler: "UserController.create"}} = Enum.at(results, 2)
       assert {:ok, :not_found} = Enum.at(results, 3)
     end
diff --git a/test/phoenix/complete_phoenix_wasm_test.exs b/test/phoenix/complete_phoenix_wasm_test.exs
index 634421e..03d13d7 100644
--- a/test/phoenix/complete_phoenix_wasm_test.exs
+++ b/test/phoenix/complete_phoenix_wasm_test.exs
@@ -29,87 +29,121 @@ defmodule Firebird.Phoenix.CompletePhoenixWasmTest do
   describe "Phoenix to WASM - Complete Proof" do
     test "all 15 WASM modules load and function correctly" do
       modules = [
-        {"phoenix_router.wasm", fn instance ->
-          routes = [{"GET", "/test/:id", "TestController.show"}]
-          {:ok, match} = Firebird.Phoenix.Router.match(instance, "GET", "/test/42", routes)
-          assert match.params["id"] == "42"
-        end},
-        {"phoenix_template.wasm", fn instance ->
-          {:ok, html} = Firebird.Phoenix.Template.render(instance, "Hello {{name}}", %{"name" => "WASM"})
-          assert html == "Hello WASM"
-        end},
-        {"phoenix_plug.wasm", fn instance ->
-          {:ok, resp} = Firebird.Phoenix.Plug.build_response(instance, 200, "text/plain", "OK")
-          assert resp =~ "HTTP/1.1 200"
-        end},
-        {"phoenix_endpoint.wasm", fn instance ->
-          {:ok, conn} = Firebird.Phoenix.Endpoint.parse_conn(instance,
-            "GET /test HTTP/1.1\r\nHost: localhost\r\n\r\n")
-          assert conn.method == "GET"
-        end},
-        {"phoenix_view.wasm", fn instance ->
-          layout = "<body>{{inner_content}}</body>"
-          {:ok, html} = Firebird.Phoenix.View.render_with_layout(instance, layout, "<p>Hi</p>", %{})
-          assert html =~ "<p>Hi</p>"
-        end},
-        {"phoenix_controller.wasm", fn instance ->
-          {:ok, :valid} = Firebird.Phoenix.Controller.validate_params(instance,
-            %{"name" => "test"}, [{"name", "required"}])
-        end},
-        {"phoenix_channel.wasm", fn instance ->
-          {:ok, match} = Firebird.Phoenix.Channel.match_topic(instance, "room:lobby",
-            [{"room:*", "RoomChannel"}])
-          assert match.handler == "RoomChannel"
-        end},
-        {"phoenix_json.wasm", fn instance ->
-          {:ok, json} = Firebird.Phoenix.JSON.encode_object(instance, %{"key" => "value"})
-          assert json =~ "key"
-        end},
-        {"phoenix_session.wasm", fn instance ->
-          {:ok, cookies} = Firebird.Phoenix.Session.parse_cookies(instance, "a=1; b=2")
-          assert cookies["a"] == "1"
-        end},
-        {"phoenix_live.wasm", fn instance ->
-          # Live module should load successfully
-          assert Process.alive?(instance)
-        end},
-        {"phoenix_validator.wasm", fn instance ->
-          {:ok, result} = Firebird.Phoenix.Validator.validate(instance,
-            %{"email" => "test@example.com"}, [{:required, "email"}])
-          assert result == :valid
-        end},
-        {"phoenix_form.wasm", fn instance ->
-          {:ok, html} = Firebird.Phoenix.FormWasm.text_input(instance, "user", "name")
-          assert html =~ ~s(name="user[name]")
-        end},
-        {"phoenix_csrf.wasm", fn instance ->
-          Firebird.Phoenix.CsrfWasm.seed(instance, "test")
-          {:ok, token} = Firebird.Phoenix.CsrfWasm.generate_token(instance, "secret")
-          {:ok, :valid} = Firebird.Phoenix.CsrfWasm.verify_token(instance, token, "secret")
-        end},
-        {"phoenix_rate_limiter.wasm", fn instance ->
-          Firebird.Phoenix.RateLimiterWasm.configure(instance, rate: 10.0, burst: 5.0)
-          Firebird.Phoenix.RateLimiterWasm.set_time(instance, 1_000_000)
-          {:ok, :allowed, _} = Firebird.Phoenix.RateLimiterWasm.consume(instance, "test")
-        end},
-        {"phoenix_websocket.wasm", fn instance ->
-          {:ok, frame} = Firebird.Phoenix.WebSocketWasm.encode_text(instance, "hello")
-          {:ok, :text, "hello"} = Firebird.Phoenix.WebSocketWasm.decode_frame(instance, frame)
-        end},
+        {"phoenix_router.wasm",
+         fn instance ->
+           routes = [{"GET", "/test/:id", "TestController.show"}]
+           {:ok, match} = Firebird.Phoenix.Router.match(instance, "GET", "/test/42", routes)
+           assert match.params["id"] == "42"
+         end},
+        {"phoenix_template.wasm",
+         fn instance ->
+           {:ok, html} =
+             Firebird.Phoenix.Template.render(instance, "Hello {{name}}", %{"name" => "WASM"})
+
+           assert html == "Hello WASM"
+         end},
+        {"phoenix_plug.wasm",
+         fn instance ->
+           {:ok, resp} = Firebird.Phoenix.Plug.build_response(instance, 200, "text/plain", "OK")
+           assert resp =~ "HTTP/1.1 200"
+         end},
+        {"phoenix_endpoint.wasm",
+         fn instance ->
+           {:ok, conn} =
+             Firebird.Phoenix.Endpoint.parse_conn(
+               instance,
+               "GET /test HTTP/1.1\r\nHost: localhost\r\n\r\n"
+             )
+
+           assert conn.method == "GET"
+         end},
+        {"phoenix_view.wasm",
+         fn instance ->
+           layout = "<body>{{inner_content}}</body>"
+
+           {:ok, html} =
+             Firebird.Phoenix.View.render_with_layout(instance, layout, "<p>Hi</p>", %{})
+
+           assert html =~ "<p>Hi</p>"
+         end},
+        {"phoenix_controller.wasm",
+         fn instance ->
+           {:ok, :valid} =
+             Firebird.Phoenix.Controller.validate_params(instance, %{"name" => "test"}, [
+               {"name", "required"}
+             ])
+         end},
+        {"phoenix_channel.wasm",
+         fn instance ->
+           {:ok, match} =
+             Firebird.Phoenix.Channel.match_topic(instance, "room:lobby", [
+               {"room:*", "RoomChannel"}
+             ])
+
+           assert match.handler == "RoomChannel"
+         end},
+        {"phoenix_json.wasm",
+         fn instance ->
+           {:ok, json} = Firebird.Phoenix.JSON.encode_object(instance, %{"key" => "value"})
+           assert json =~ "key"
+         end},
+        {"phoenix_session.wasm",
+         fn instance ->
+           {:ok, cookies} = Firebird.Phoenix.Session.parse_cookies(instance, "a=1; b=2")
+           assert cookies["a"] == "1"
+         end},
+        {"phoenix_live.wasm",
+         fn instance ->
+           # Live module should load successfully
+           assert Process.alive?(instance)
+         end},
+        {"phoenix_validator.wasm",
+         fn instance ->
+           {:ok, result} =
+             Firebird.Phoenix.Validator.validate(instance, %{"email" => "test@example.com"}, [
+               {:required, "email"}
+             ])
+
+           assert result == :valid
+         end},
+        {"phoenix_form.wasm",
+         fn instance ->
+           {:ok, html} = Firebird.Phoenix.FormWasm.text_input(instance, "user", "name")
+           assert html =~ ~s(name="user[name]")
+         end},
+        {"phoenix_csrf.wasm",
+         fn instance ->
+           Firebird.Phoenix.CsrfWasm.seed(instance, "test")
+           {:ok, token} = Firebird.Phoenix.CsrfWasm.generate_token(instance, "secret")
+           {:ok, :valid} = Firebird.Phoenix.CsrfWasm.verify_token(instance, token, "secret")
+         end},
+        {"phoenix_rate_limiter.wasm",
+         fn instance ->
+           Firebird.Phoenix.RateLimiterWasm.configure(instance, rate: 10.0, burst: 5.0)
+           Firebird.Phoenix.RateLimiterWasm.set_time(instance, 1_000_000)
+           {:ok, :allowed, _} = Firebird.Phoenix.RateLimiterWasm.consume(instance, "test")
+         end},
+        {"phoenix_websocket.wasm",
+         fn instance ->
+           {:ok, frame} = Firebird.Phoenix.WebSocketWasm.encode_text(instance, "hello")
+           {:ok, :text, "hello"} = Firebird.Phoenix.WebSocketWasm.decode_frame(instance, frame)
+         end}
       ]
 
-      results = Enum.map(modules, fn {file, test_fn} ->
-        path = Path.join(@fixtures_dir, file)
-        assert File.exists?(path), "Missing WASM module: #{file}"
+      results =
+        Enum.map(modules, fn {file, test_fn} ->
+          path = Path.join(@fixtures_dir, file)
+          assert File.exists?(path), "Missing WASM module: #{file}"
 
-        {:ok, instance} = Firebird.load(path)
-        test_fn.(instance)
-        Firebird.stop(instance)
-        {file, :ok}
-      end)
+          {:ok, instance} = Firebird.load(path)
+          test_fn.(instance)
+          Firebird.stop(instance)
+          {file, :ok}
+        end)
 
       assert length(results) == 15
       IO.puts("\n✅ All 15 Phoenix WASM modules verified!")
+
       for {file, :ok} <- results do
         IO.puts("   ✅ #{file}")
       end
@@ -121,14 +155,14 @@ defmodule Firebird.Phoenix.CompletePhoenixWasmTest do
         use Firebird.Phoenix.App
 
         routes do
-          get "/", "Page.index"
-          get "/api/items/:id", "Item.show"
-          post "/api/items", "Item.create"
+          get("/", "Page.index")
+          get("/api/items/:id", "Item.show")
+          post("/api/items", "Item.create")
         end
 
-        action "Page.index", 200, "text/html", "<h1>Inline App</h1>"
-        action "Item.show", 200, "application/json", ~s({"id":"{{id}}"})
-        action "Item.create", 201, "application/json", ~s({"created":true})
+        action("Page.index", 200, "text/html", "<h1>Inline App</h1>")
+        action("Item.show", 200, "application/json", ~s({"id":"{{id}}"}))
+        action("Item.create", 201, "application/json", ~s({"created":true}))
       end
 
       {:ok, _} = InlineApp.start(port: 0)
@@ -167,10 +201,13 @@ defmodule Firebird.Phoenix.CompletePhoenixWasmTest do
           0 ->
             {:ok, match} = Firebird.Phoenix.Router.match(router, "GET", "/items/#{i}", routes)
             assert match.params["id"] == "#{i}"
+
           1 ->
-            {:ok, html} = Firebird.Phoenix.Template.render(template,
-              "Item {{n}}", %{"n" => "#{i}"})
+            {:ok, html} =
+              Firebird.Phoenix.Template.render(template, "Item {{n}}", %{"n" => "#{i}"})
+
             assert html == "Item #{i}"
+
           2 ->
             {:ok, j} = Firebird.Phoenix.JSON.encode_object(json, %{"i" => "#{i}"})
             assert j =~ "#{i}"
@@ -184,16 +221,17 @@ defmodule Firebird.Phoenix.CompletePhoenixWasmTest do
 
     test "concurrent requests with separate instances per task" do
       # Each task gets its own WASM instance (safe for concurrency)
-      tasks = for i <- 1..10 do
-        Task.async(fn ->
-          {:ok, router} = Firebird.load(Path.join(@fixtures_dir, "phoenix_router.wasm"))
-          routes = [{"GET", "/items/:id", "ItemController.show"}]
-          {:ok, match} = Firebird.Phoenix.Router.match(router, "GET", "/items/#{i}", routes)
-          Firebird.stop(router)
-          assert match.params["id"] == "#{i}"
-          :ok
-        end)
-      end
+      tasks =
+        for i <- 1..10 do
+          Task.async(fn ->
+            {:ok, router} = Firebird.load(Path.join(@fixtures_dir, "phoenix_router.wasm"))
+            routes = [{"GET", "/items/:id", "ItemController.show"}]
+            {:ok, match} = Firebird.Phoenix.Router.match(router, "GET", "/items/#{i}", routes)
+            Firebird.stop(router)
+            assert match.params["id"] == "#{i}"
+            :ok
+          end)
+        end
 
       results = Task.await_many(tasks, 10_000)
       assert Enum.all?(results, &(&1 == :ok))
diff --git a/test/phoenix/config_edge_cases_test.exs b/test/phoenix/config_edge_cases_test.exs
index a059b2b..768b8f4 100644
--- a/test/phoenix/config_edge_cases_test.exs
+++ b/test/phoenix/config_edge_cases_test.exs
@@ -96,8 +96,10 @@ defmodule Firebird.Phoenix.ConfigEdgeCasesTest do
     end
 
     test "preserves other settings when putting" do
-      config = Config.new(port: 4000, host: "0.0.0.0")
-      |> Config.put(:port, 8080)
+      config =
+        Config.new(port: 4000, host: "0.0.0.0")
+        |> Config.put(:port, 8080)
+
       assert Config.get(config, :host) == "0.0.0.0"
       assert Config.get(config, :port) == 8080
     end
@@ -110,9 +112,11 @@ defmodule Firebird.Phoenix.ConfigEdgeCasesTest do
     end
 
     test "overwrites pipeline with same name" do
-      config = Config.new()
-      |> Config.put_pipeline(:api, ["v1"])
-      |> Config.put_pipeline(:api, ["v2"])
+      config =
+        Config.new()
+        |> Config.put_pipeline(:api, ["v1"])
+        |> Config.put_pipeline(:api, ["v2"])
+
       assert Config.pipeline(config, :api) == ["v2"]
     end
 
@@ -129,10 +133,11 @@ defmodule Firebird.Phoenix.ConfigEdgeCasesTest do
 
   describe "routes edge cases" do
     test "routes preserve insertion order" do
-      config = Config.new()
-      |> Config.put_route("GET", "/a", "A.index")
-      |> Config.put_route("POST", "/b", "B.create")
-      |> Config.put_route("DELETE", "/c", "C.delete")
+      config =
+        Config.new()
+        |> Config.put_route("GET", "/a", "A.index")
+        |> Config.put_route("POST", "/b", "B.create")
+        |> Config.put_route("DELETE", "/c", "C.delete")
 
       routes = Config.routes(config)
       assert Enum.at(routes, 0) == {"GET", "/a", "A.index"}
@@ -141,9 +146,10 @@ defmodule Firebird.Phoenix.ConfigEdgeCasesTest do
     end
 
     test "duplicate routes are preserved" do
-      config = Config.new()
-      |> Config.put_route("GET", "/", "Page.index")
-      |> Config.put_route("GET", "/", "Page.index")
+      config =
+        Config.new()
+        |> Config.put_route("GET", "/", "Page.index")
+        |> Config.put_route("GET", "/", "Page.index")
 
       assert length(Config.routes(config)) == 2
     end
@@ -151,9 +157,10 @@ defmodule Firebird.Phoenix.ConfigEdgeCasesTest do
     test "supports all HTTP methods" do
       methods = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]
 
-      config = Enum.reduce(methods, Config.new(), fn method, cfg ->
-        Config.put_route(cfg, method, "/test", "Test.#{method}")
-      end)
+      config =
+        Enum.reduce(methods, Config.new(), fn method, cfg ->
+          Config.put_route(cfg, method, "/test", "Test.#{method}")
+        end)
 
       assert length(Config.routes(config)) == length(methods)
     end
@@ -176,18 +183,20 @@ defmodule Firebird.Phoenix.ConfigEdgeCasesTest do
     end
 
     test "non-nil secret_key_base passes validation" do
-      config = Config.new()
-      |> Config.put(:secret_key_base, "")
-      |> Config.put_route("GET", "/", "Page.index")
+      config =
+        Config.new()
+        |> Config.put(:secret_key_base, "")
+        |> Config.put_route("GET", "/", "Page.index")
 
       # Empty string is non-nil, should pass
       assert :ok = Config.validate(config)
     end
 
     test "false secret_key_base passes validation (non-nil)" do
-      config = Config.new()
-      |> Config.put(:secret_key_base, false)
-      |> Config.put_route("GET", "/", "Page.index")
+      config =
+        Config.new()
+        |> Config.put(:secret_key_base, false)
+        |> Config.put_route("GET", "/", "Page.index")
 
       assert :ok = Config.validate(config)
     end
@@ -215,13 +224,15 @@ defmodule Firebird.Phoenix.ConfigEdgeCasesTest do
     end
 
     test "pipelines are merged (override wins for same name)" do
-      base = Config.new()
-      |> Config.put_pipeline(:api, ["v1"])
-      |> Config.put_pipeline(:shared, ["base_plug"])
+      base =
+        Config.new()
+        |> Config.put_pipeline(:api, ["v1"])
+        |> Config.put_pipeline(:shared, ["base_plug"])
 
-      override = Config.new()
-      |> Config.put_pipeline(:shared, ["override_plug"])
-      |> Config.put_pipeline(:browser, ["secure"])
+      override =
+        Config.new()
+        |> Config.put_pipeline(:shared, ["override_plug"])
+        |> Config.put_pipeline(:browser, ["secure"])
 
       merged = Config.merge(base, override)
       assert Config.pipeline(merged, :api) == ["v1"]
@@ -239,7 +250,8 @@ defmodule Firebird.Phoenix.ConfigEdgeCasesTest do
 
     test "empty components in override keeps base components" do
       base = Config.new() |> Config.put_components([:router, :template])
-      override = %Config{}  # empty components
+      # empty components
+      override = %Config{}
       merged = Config.merge(base, override)
 
       assert merged.components == [:router, :template]
@@ -272,9 +284,10 @@ defmodule Firebird.Phoenix.ConfigEdgeCasesTest do
     end
 
     test "replaces existing components" do
-      config = Config.new()
-      |> Config.put_components([:a, :b])
-      |> Config.put_components([:c])
+      config =
+        Config.new()
+        |> Config.put_components([:a, :b])
+        |> Config.put_components([:c])
 
       assert config.components == [:c]
     end
@@ -282,16 +295,17 @@ defmodule Firebird.Phoenix.ConfigEdgeCasesTest do
 
   describe "chaining operations" do
     test "full config building chain" do
-      config = Config.new()
-      |> Config.put(:port, 8080)
-      |> Config.put(:host, "0.0.0.0")
-      |> Config.put(:secret_key_base, "super-secret-key")
-      |> Config.put_pipeline(:api, ["accept:application/json", "cors:*"])
-      |> Config.put_pipeline(:browser, ["put_secure_headers", "accept:text/html"])
-      |> Config.put_route("GET", "/api/users", "UserController.index")
-      |> Config.put_route("POST", "/api/users", "UserController.create")
-      |> Config.put_route("GET", "/", "PageController.index")
-      |> Config.put_components([:router, :endpoint])
+      config =
+        Config.new()
+        |> Config.put(:port, 8080)
+        |> Config.put(:host, "0.0.0.0")
+        |> Config.put(:secret_key_base, "super-secret-key")
+        |> Config.put_pipeline(:api, ["accept:application/json", "cors:*"])
+        |> Config.put_pipeline(:browser, ["put_secure_headers", "accept:text/html"])
+        |> Config.put_route("GET", "/api/users", "UserController.index")
+        |> Config.put_route("POST", "/api/users", "UserController.create")
+        |> Config.put_route("GET", "/", "PageController.index")
+        |> Config.put_components([:router, :endpoint])
 
       assert Config.get(config, :port) == 8080
       assert Config.get(config, :host) == "0.0.0.0"
@@ -313,9 +327,10 @@ defmodule Firebird.Phoenix.ConfigEdgeCasesTest do
     end
 
     test "struct fields have expected types" do
-      config = Config.new()
-      |> Config.put_pipeline(:test, ["a"])
-      |> Config.put_route("GET", "/", "handler")
+      config =
+        Config.new()
+        |> Config.put_pipeline(:test, ["a"])
+        |> Config.put_route("GET", "/", "handler")
 
       assert %{} = config.settings
       assert %{test: ["a"]} = config.pipelines
diff --git a/test/phoenix/config_test.exs b/test/phoenix/config_test.exs
index 7b2df21..b3b696d 100644
--- a/test/phoenix/config_test.exs
+++ b/test/phoenix/config_test.exs
@@ -67,10 +67,11 @@ defmodule Firebird.Phoenix.ConfigTest do
     end
 
     test "chains multiple puts" do
-      config = Config.new()
-      |> Config.put(:port, 8080)
-      |> Config.put(:host, "api.example.com")
-      |> Config.put(:secret_key_base, "secret123")
+      config =
+        Config.new()
+        |> Config.put(:port, 8080)
+        |> Config.put(:host, "api.example.com")
+        |> Config.put(:secret_key_base, "secret123")
 
       assert Config.get(config, :port) == 8080
       assert Config.get(config, :host) == "api.example.com"
@@ -80,16 +81,18 @@ defmodule Firebird.Phoenix.ConfigTest do
 
   describe "put_pipeline/3 and pipelines/1 and pipeline/2" do
     test "defines a pipeline" do
-      config = Config.new()
-      |> Config.put_pipeline(:api, ["accept:application/json", "cors:*"])
+      config =
+        Config.new()
+        |> Config.put_pipeline(:api, ["accept:application/json", "cors:*"])
 
       assert Config.pipeline(config, :api) == ["accept:application/json", "cors:*"]
     end
 
     test "defines multiple pipelines" do
-      config = Config.new()
-      |> Config.put_pipeline(:api, ["accept:application/json"])
-      |> Config.put_pipeline(:browser, ["accept:text/html"])
+      config =
+        Config.new()
+        |> Config.put_pipeline(:api, ["accept:application/json"])
+        |> Config.put_pipeline(:browser, ["accept:text/html"])
 
       pipelines = Config.pipelines(config)
       assert Map.has_key?(pipelines, :api)
@@ -102,9 +105,10 @@ defmodule Firebird.Phoenix.ConfigTest do
     end
 
     test "overrides existing pipeline" do
-      config = Config.new()
-      |> Config.put_pipeline(:api, ["old"])
-      |> Config.put_pipeline(:api, ["new"])
+      config =
+        Config.new()
+        |> Config.put_pipeline(:api, ["old"])
+        |> Config.put_pipeline(:api, ["new"])
 
       assert Config.pipeline(config, :api) == ["new"]
     end
@@ -112,8 +116,9 @@ defmodule Firebird.Phoenix.ConfigTest do
 
   describe "put_route/4 and routes/1" do
     test "adds a route" do
-      config = Config.new()
-      |> Config.put_route("GET", "/users", "UserController.index")
+      config =
+        Config.new()
+        |> Config.put_route("GET", "/users", "UserController.index")
 
       routes = Config.routes(config)
       assert length(routes) == 1
@@ -121,10 +126,11 @@ defmodule Firebird.Phoenix.ConfigTest do
     end
 
     test "accumulates routes" do
-      config = Config.new()
-      |> Config.put_route("GET", "/users", "UserController.index")
-      |> Config.put_route("POST", "/users", "UserController.create")
-      |> Config.put_route("GET", "/users/:id", "UserController.show")
+      config =
+        Config.new()
+        |> Config.put_route("GET", "/users", "UserController.index")
+        |> Config.put_route("POST", "/users", "UserController.create")
+        |> Config.put_route("GET", "/users/:id", "UserController.show")
 
       assert length(Config.routes(config)) == 3
     end
@@ -137,8 +143,9 @@ defmodule Firebird.Phoenix.ConfigTest do
     end
 
     test "overrides existing components" do
-      config = Config.new(components: [:router])
-      |> Config.put_components([:template])
+      config =
+        Config.new(components: [:router])
+        |> Config.put_components([:template])
 
       assert config.components == [:template]
     end
@@ -146,8 +153,9 @@ defmodule Firebird.Phoenix.ConfigTest do
 
   describe "validate/1" do
     test "fails without secret_key_base" do
-      config = Config.new()
-      |> Config.put_route("GET", "/", "PageController.index")
+      config =
+        Config.new()
+        |> Config.put_route("GET", "/", "PageController.index")
 
       assert {:error, errors} = Config.validate(config)
       assert "secret_key_base is required" in errors
@@ -161,8 +169,9 @@ defmodule Firebird.Phoenix.ConfigTest do
     end
 
     test "passes with valid config" do
-      config = Config.new(secret_key_base: "my-secret")
-      |> Config.put_route("GET", "/", "PageController.index")
+      config =
+        Config.new(secret_key_base: "my-secret")
+        |> Config.put_route("GET", "/", "PageController.index")
 
       assert :ok = Config.validate(config)
     end
@@ -226,5 +235,3 @@ defmodule Firebird.Phoenix.ConfigTest do
     end
   end
 end
-
-
diff --git a/test/phoenix/conn_test.exs b/test/phoenix/conn_test.exs
index baeaf35..331364c 100644
--- a/test/phoenix/conn_test.exs
+++ b/test/phoenix/conn_test.exs
@@ -43,8 +43,9 @@ defmodule Firebird.Phoenix.ConnTest do
 
   describe "to_raw_request/1" do
     test "builds raw HTTP request string" do
-      conn = Conn.new("GET", "/users")
-      |> Conn.put_req_header("host", "localhost")
+      conn =
+        Conn.new("GET", "/users")
+        |> Conn.put_req_header("host", "localhost")
 
       raw = Conn.to_raw_request(conn)
       assert raw =~ "GET /users HTTP/1.1"
@@ -77,18 +78,21 @@ defmodule Firebird.Phoenix.ConnTest do
     end
 
     test "does not override existing Content-Length" do
-      conn = Conn.new("POST", "/users", body: "data")
-      |> Conn.put_req_header("content-length", "100")
+      conn =
+        Conn.new("POST", "/users", body: "data")
+        |> Conn.put_req_header("content-length", "100")
+
       raw = Conn.to_raw_request(conn)
       assert raw =~ "content-length: 100"
       refute raw =~ "content-length: 4"
     end
 
     test "builds valid HTTP request with multiple headers" do
-      conn = Conn.new("PUT", "/api/items/5", body: ~s({"name":"Widget"}))
-      |> Conn.put_req_header("host", "example.com")
-      |> Conn.put_req_header("content-type", "application/json")
-      |> Conn.put_req_header("authorization", "Bearer token123")
+      conn =
+        Conn.new("PUT", "/api/items/5", body: ~s({"name":"Widget"}))
+        |> Conn.put_req_header("host", "example.com")
+        |> Conn.put_req_header("content-type", "application/json")
+        |> Conn.put_req_header("authorization", "Bearer token123")
 
       raw = Conn.to_raw_request(conn)
       assert raw =~ "PUT /api/items/5 HTTP/1.1\r\n"
@@ -103,14 +107,18 @@ defmodule Firebird.Phoenix.ConnTest do
 
   describe "header operations" do
     test "put_req_header/3 sets request header" do
-      conn = Conn.new("GET", "/")
-      |> Conn.put_req_header("Accept", "text/html")
+      conn =
+        Conn.new("GET", "/")
+        |> Conn.put_req_header("Accept", "text/html")
+
       assert conn.req_headers["accept"] == "text/html"
     end
 
     test "put_resp_header/3 sets response header" do
-      conn = Conn.new("GET", "/")
-      |> Conn.put_resp_header("Content-Type", "application/json")
+      conn =
+        Conn.new("GET", "/")
+        |> Conn.put_resp_header("Content-Type", "application/json")
+
       assert conn.resp_headers["content-type"] == "application/json"
     end
 
@@ -159,9 +167,11 @@ defmodule Firebird.Phoenix.ConnTest do
     end
 
     test "merge_params/2 merges params" do
-      conn = Conn.new("GET", "/")
-      |> Conn.merge_params(%{"id" => "42"})
-      |> Conn.merge_params(%{"name" => "Alice"})
+      conn =
+        Conn.new("GET", "/")
+        |> Conn.merge_params(%{"id" => "42"})
+        |> Conn.merge_params(%{"name" => "Alice"})
+
       assert conn.params["id"] == "42"
       assert conn.params["name"] == "Alice"
     end
@@ -275,11 +285,12 @@ defmodule Firebird.Phoenix.ConnTest do
 
   describe "to_wasm/1" do
     test "serializes Conn to WASM endpoint format" do
-      conn = Conn.new("POST", "/api/users")
-      |> Conn.put_req_header("accept", "application/json")
-      |> Conn.put_resp_header("content-type", "application/json")
-      |> Conn.assign(:role, "admin")
-      |> Conn.merge_params(%{"id" => "42"})
+      conn =
+        Conn.new("POST", "/api/users")
+        |> Conn.put_req_header("accept", "application/json")
+        |> Conn.put_resp_header("content-type", "application/json")
+        |> Conn.assign(:role, "admin")
+        |> Conn.merge_params(%{"id" => "42"})
 
       serialized = Conn.to_wasm(conn)
 
@@ -325,11 +336,12 @@ defmodule Firebird.Phoenix.ConnTest do
 
   describe "round-trip from_wasm/to_wasm" do
     test "Conn -> to_wasm -> deserialize_conn -> from_wasm preserves data" do
-      original = Conn.new("PUT", "/api/items/5")
-      |> Conn.put_status(200)
-      |> Conn.put_resp_header("x-request-id", "abc")
-      |> Conn.assign(:tenant, "acme")
-      |> Conn.merge_params(%{"id" => "5"})
+      original =
+        Conn.new("PUT", "/api/items/5")
+        |> Conn.put_status(200)
+        |> Conn.put_resp_header("x-request-id", "abc")
+        |> Conn.assign(:tenant, "acme")
+        |> Conn.merge_params(%{"id" => "5"})
 
       serialized = Conn.to_wasm(original)
       deserialized = Firebird.Phoenix.Endpoint.deserialize_conn(serialized)
@@ -344,10 +356,11 @@ defmodule Firebird.Phoenix.ConnTest do
     end
 
     test "preserves req_headers through round-trip" do
-      original = Conn.new("POST", "/api/data")
-      |> Conn.put_req_header("content-type", "application/json")
-      |> Conn.put_req_header("authorization", "Bearer tok123")
-      |> Conn.put_req_header("accept", "application/json")
+      original =
+        Conn.new("POST", "/api/data")
+        |> Conn.put_req_header("content-type", "application/json")
+        |> Conn.put_req_header("authorization", "Bearer tok123")
+        |> Conn.put_req_header("accept", "application/json")
 
       serialized = Conn.to_wasm(original)
       assert serialized =~ "req_header:content-type=application/json"
@@ -362,8 +375,9 @@ defmodule Firebird.Phoenix.ConnTest do
     end
 
     test "preserves resp_body through round-trip" do
-      original = Conn.new("GET", "/")
-      |> Conn.send_resp(200, ~s({"ok":true}))
+      original =
+        Conn.new("GET", "/")
+        |> Conn.send_resp(200, ~s({"ok":true}))
 
       serialized = Conn.to_wasm(original)
       assert serialized =~ ~s(resp_body={"ok":true})
@@ -387,15 +401,16 @@ defmodule Firebird.Phoenix.ConnTest do
     end
 
     test "full round-trip with all fields populated" do
-      original = Conn.new("PATCH", "/api/users/7?fields=name,email")
-      |> Conn.put_req_header("content-type", "application/json")
-      |> Conn.put_req_header("authorization", "Bearer secret")
-      |> Conn.put_resp_header("x-request-id", "req-999")
-      |> Conn.put_resp_header("cache-control", "no-store")
-      |> Conn.assign(:current_user, "user_7")
-      |> Conn.assign(:role, "admin")
-      |> Conn.merge_params(%{"id" => "7", "name" => "Updated"})
-      |> Conn.send_resp(200, ~s({"updated":true}))
+      original =
+        Conn.new("PATCH", "/api/users/7?fields=name,email")
+        |> Conn.put_req_header("content-type", "application/json")
+        |> Conn.put_req_header("authorization", "Bearer secret")
+        |> Conn.put_resp_header("x-request-id", "req-999")
+        |> Conn.put_resp_header("cache-control", "no-store")
+        |> Conn.assign(:current_user, "user_7")
+        |> Conn.assign(:role, "admin")
+        |> Conn.merge_params(%{"id" => "7", "name" => "Updated"})
+        |> Conn.send_resp(200, ~s({"updated":true}))
 
       serialized = Conn.to_wasm(original)
       deserialized = Firebird.Phoenix.Endpoint.deserialize_conn(serialized)
@@ -427,8 +442,9 @@ defmodule Firebird.Phoenix.ConnTest do
 
   describe "json/3" do
     test "sends JSON response with correct content type" do
-      conn = Conn.new("GET", "/api/users")
-      |> Conn.json(200, %{users: [%{id: 1, name: "Alice"}]})
+      conn =
+        Conn.new("GET", "/api/users")
+        |> Conn.json(200, %{users: [%{id: 1, name: "Alice"}]})
 
       assert conn.status == 200
       assert conn.state == :sent
@@ -438,8 +454,9 @@ defmodule Firebird.Phoenix.ConnTest do
     end
 
     test "sends JSON error response" do
-      conn = Conn.new("POST", "/api/users")
-      |> Conn.json(422, %{errors: %{name: ["can't be blank"]}})
+      conn =
+        Conn.new("POST", "/api/users")
+        |> Conn.json(422, %{errors: %{name: ["can't be blank"]}})
 
       assert conn.status == 422
       decoded = Jason.decode!(conn.resp_body)
@@ -447,8 +464,9 @@ defmodule Firebird.Phoenix.ConnTest do
     end
 
     test "sends JSON with 201 Created" do
-      conn = Conn.new("POST", "/api/items")
-      |> Conn.json(201, %{id: 42})
+      conn =
+        Conn.new("POST", "/api/items")
+        |> Conn.json(201, %{id: 42})
 
       assert conn.status == 201
       assert Jason.decode!(conn.resp_body) == %{"id" => 42}
@@ -467,8 +485,9 @@ defmodule Firebird.Phoenix.ConnTest do
 
   describe "text/3" do
     test "sends plain text response" do
-      conn = Conn.new("GET", "/health")
-      |> Conn.text(200, "OK")
+      conn =
+        Conn.new("GET", "/health")
+        |> Conn.text(200, "OK")
 
       assert conn.status == 200
       assert conn.resp_body == "OK"
@@ -485,8 +504,9 @@ defmodule Firebird.Phoenix.ConnTest do
 
   describe "html/3" do
     test "sends HTML response" do
-      conn = Conn.new("GET", "/")
-      |> Conn.html(200, "<h1>Hello</h1>")
+      conn =
+        Conn.new("GET", "/")
+        |> Conn.html(200, "<h1>Hello</h1>")
 
       assert conn.status == 200
       assert conn.resp_body == "<h1>Hello</h1>"
@@ -495,8 +515,9 @@ defmodule Firebird.Phoenix.ConnTest do
     end
 
     test "sends 404 HTML page" do
-      conn = Conn.new("GET", "/missing")
-      |> Conn.html(404, "<h1>Not Found</h1>")
+      conn =
+        Conn.new("GET", "/missing")
+        |> Conn.html(404, "<h1>Not Found</h1>")
 
       assert conn.status == 404
       assert conn.resp_body =~ "Not Found"
@@ -505,8 +526,9 @@ defmodule Firebird.Phoenix.ConnTest do
 
   describe "redirect/3" do
     test "sends 302 redirect by default" do
-      conn = Conn.new("GET", "/old-page")
-      |> Conn.redirect("/new-page")
+      conn =
+        Conn.new("GET", "/old-page")
+        |> Conn.redirect("/new-page")
 
       assert conn.status == 302
       assert conn.resp_headers["location"] == "/new-page"
@@ -515,23 +537,26 @@ defmodule Firebird.Phoenix.ConnTest do
     end
 
     test "sends 301 permanent redirect" do
-      conn = Conn.new("GET", "/old")
-      |> Conn.redirect("/new", status: 301)
+      conn =
+        Conn.new("GET", "/old")
+        |> Conn.redirect("/new", status: 301)
 
       assert conn.status == 301
       assert conn.resp_headers["location"] == "/new"
     end
 
     test "redirects to external URL" do
-      conn = Conn.new("GET", "/oauth/callback")
-      |> Conn.redirect("https://example.com/auth")
+      conn =
+        Conn.new("GET", "/oauth/callback")
+        |> Conn.redirect("https://example.com/auth")
 
       assert conn.resp_headers["location"] == "https://example.com/auth"
     end
 
     test "sends 303 See Other" do
-      conn = Conn.new("POST", "/form")
-      |> Conn.redirect("/success", status: 303)
+      conn =
+        Conn.new("POST", "/form")
+        |> Conn.redirect("/success", status: 303)
 
       assert conn.status == 303
     end
@@ -570,18 +595,20 @@ defmodule Firebird.Phoenix.ConnTest do
     end
 
     test "merges with existing params by default" do
-      conn = Conn.new("GET", "/users?sort=name")
-      |> Conn.merge_params(%{"id" => "42"})
-      |> Conn.fetch_query_params()
+      conn =
+        Conn.new("GET", "/users?sort=name")
+        |> Conn.merge_params(%{"id" => "42"})
+        |> Conn.fetch_query_params()
 
       assert conn.params["id"] == "42"
       assert conn.params["sort"] == "name"
     end
 
     test "replaces params when merge: false" do
-      conn = Conn.new("GET", "/users?sort=name")
-      |> Conn.merge_params(%{"id" => "42"})
-      |> Conn.fetch_query_params(merge: false)
+      conn =
+        Conn.new("GET", "/users?sort=name")
+        |> Conn.merge_params(%{"id" => "42"})
+        |> Conn.fetch_query_params(merge: false)
 
       assert conn.params["sort"] == "name"
       refute Map.has_key?(conn.params, "id")
@@ -625,8 +652,9 @@ defmodule Firebird.Phoenix.ConnTest do
 
   describe "response helpers + to_wasm round-trip" do
     test "json response survives to_wasm serialization" do
-      conn = Conn.new("GET", "/api")
-      |> Conn.json(200, %{ok: true})
+      conn =
+        Conn.new("GET", "/api")
+        |> Conn.json(200, %{ok: true})
 
       serialized = Conn.to_wasm(conn)
       assert serialized =~ "status=200"
@@ -635,8 +663,9 @@ defmodule Firebird.Phoenix.ConnTest do
     end
 
     test "redirect response survives to_wasm serialization" do
-      conn = Conn.new("GET", "/old")
-      |> Conn.redirect("/new")
+      conn =
+        Conn.new("GET", "/old")
+        |> Conn.redirect("/new")
 
       serialized = Conn.to_wasm(conn)
       assert serialized =~ "status=302"
@@ -644,15 +673,16 @@ defmodule Firebird.Phoenix.ConnTest do
     end
 
     test "fetch_query_params + json pipeline" do
-      conn = Conn.new("GET", "/api/items?page=2&per=10")
-      |> Conn.fetch_query_params()
-      |> then(fn conn ->
-        Conn.json(conn, 200, %{
-          page: String.to_integer(conn.params["page"]),
-          per: String.to_integer(conn.params["per"]),
-          items: []
-        })
-      end)
+      conn =
+        Conn.new("GET", "/api/items?page=2&per=10")
+        |> Conn.fetch_query_params()
+        |> then(fn conn ->
+          Conn.json(conn, 200, %{
+            page: String.to_integer(conn.params["page"]),
+            per: String.to_integer(conn.params["per"]),
+            items: []
+          })
+        end)
 
       assert conn.status == 200
       decoded = Jason.decode!(conn.resp_body)
diff --git a/test/phoenix/controller_extended_test.exs b/test/phoenix/controller_extended_test.exs
index 9a56c6f..26ff949 100644
--- a/test/phoenix/controller_extended_test.exs
+++ b/test/phoenix/controller_extended_test.exs
@@ -63,12 +63,14 @@ defmodule Firebird.Phoenix.ControllerExtendedTest do
         "email" => "alice@example.com",
         "age" => "25"
       }
+
       rules = [
         {"name", "required"},
         {"email", "required"},
         {"email", "format:email"},
         {"age", "required"}
       ]
+
       assert {:ok, :valid} = Controller.validate_params(instance, params, rules)
     end
   end
@@ -88,9 +90,12 @@ defmodule Firebird.Phoenix.ControllerExtendedTest do
 
     test "renders with custom template", %{instance: instance} do
       assigns = %{"name" => "World"}
-      result = Controller.render(instance, "greet", :html, 200, assigns,
-        "<h1>Hello {{name}}</h1>")
+
+      result =
+        Controller.render(instance, "greet", :html, 200, assigns, "<h1>Hello {{name}}</h1>")
+
       assert match?({:ok, _}, result)
+
       case result do
         {:ok, resp} -> assert resp =~ "World"
         _ -> :ok
diff --git a/test/phoenix/controller_test.exs b/test/phoenix/controller_test.exs
index 2121533..9f94442 100644
--- a/test/phoenix/controller_test.exs
+++ b/test/phoenix/controller_test.exs
@@ -86,11 +86,13 @@ defmodule Firebird.Phoenix.ControllerTest do
 
     test "validates multiple rules", %{instance: instance} do
       params = %{"name" => "", "email" => "bad", "age" => "abc"}
+
       rules = [
         {"name", "required"},
         {"email", "format:email"},
         {"age", "format:integer"}
       ]
+
       assert {:ok, errors} = Controller.validate_params(instance, params, rules)
       assert length(errors) == 3
     end
@@ -102,12 +104,14 @@ defmodule Firebird.Phoenix.ControllerTest do
         "age" => "25",
         "password" => "secret123"
       }
+
       rules = [
         {"name", "required"},
         {"email", "format:email"},
         {"age", "format:integer"},
         {"password", "min_length:6"}
       ]
+
       assert {:ok, :valid} = Controller.validate_params(instance, params, rules)
     end
   end
@@ -144,8 +148,7 @@ defmodule Firebird.Phoenix.ControllerTest do
     end
 
     test "renders 201 Created", %{instance: instance} do
-      assert {:ok, resp} =
-               Controller.render(instance, "create", :json, 201, %{"id" => "1"})
+      assert {:ok, resp} = Controller.render(instance, "create", :json, 201, %{"id" => "1"})
 
       assert resp =~ "201 Created"
     end
diff --git a/test/phoenix/csrf_test.exs b/test/phoenix/csrf_test.exs
index 36cb38e..36d79be 100644
--- a/test/phoenix/csrf_test.exs
+++ b/test/phoenix/csrf_test.exs
@@ -107,8 +107,7 @@ defmodule Firebird.Phoenix.CSRFTest do
       secret = "test-secret"
       token = CSRF.generate_signed_token(secret: secret)
       # Sleep briefly to ensure the token ages past max_age of -1
-      assert {:error, :expired} = CSRF.validate_signed(token,
-        secret: secret, max_age: -1)
+      assert {:error, :expired} = CSRF.validate_signed(token, secret: secret, max_age: -1)
     end
 
     test "rejects malformed token" do
@@ -127,36 +126,84 @@ defmodule Firebird.Phoenix.CSRFTest do
   describe "protect/1 middleware" do
     test "allows GET requests through" do
       middleware = CSRF.protect(token: "test-token")
-      conn = %Firebird.Phoenix.Conn{method: "GET", params: %{}, req_headers: %{}, halted: false,
-        status: 200, resp_body: "", resp_headers: %{}, assigns: %{}, path: "/",
-        query_string: "", body: ""}
+
+      conn = %Firebird.Phoenix.Conn{
+        method: "GET",
+        params: %{},
+        req_headers: %{},
+        halted: false,
+        status: 200,
+        resp_body: "",
+        resp_headers: %{},
+        assigns: %{},
+        path: "/",
+        query_string: "",
+        body: ""
+      }
+
       result = middleware.(conn)
       refute result.halted
     end
 
     test "allows HEAD requests through" do
       middleware = CSRF.protect(token: "test-token")
-      conn = %Firebird.Phoenix.Conn{method: "HEAD", params: %{}, req_headers: %{}, halted: false,
-        status: 200, resp_body: "", resp_headers: %{}, assigns: %{}, path: "/",
-        query_string: "", body: ""}
+
+      conn = %Firebird.Phoenix.Conn{
+        method: "HEAD",
+        params: %{},
+        req_headers: %{},
+        halted: false,
+        status: 200,
+        resp_body: "",
+        resp_headers: %{},
+        assigns: %{},
+        path: "/",
+        query_string: "",
+        body: ""
+      }
+
       result = middleware.(conn)
       refute result.halted
     end
 
     test "allows OPTIONS requests through" do
       middleware = CSRF.protect(token: "test-token")
-      conn = %Firebird.Phoenix.Conn{method: "OPTIONS", params: %{}, req_headers: %{}, halted: false,
-        status: 200, resp_body: "", resp_headers: %{}, assigns: %{}, path: "/",
-        query_string: "", body: ""}
+
+      conn = %Firebird.Phoenix.Conn{
+        method: "OPTIONS",
+        params: %{},
+        req_headers: %{},
+        halted: false,
+        status: 200,
+        resp_body: "",
+        resp_headers: %{},
+        assigns: %{},
+        path: "/",
+        query_string: "",
+        body: ""
+      }
+
       result = middleware.(conn)
       refute result.halted
     end
 
     test "blocks POST without token" do
       middleware = CSRF.protect(token: "expected-token")
-      conn = %Firebird.Phoenix.Conn{method: "POST", params: %{}, req_headers: %{}, halted: false,
-        status: 200, resp_body: "", resp_headers: %{}, assigns: %{}, path: "/",
-        query_string: "", body: ""}
+
+      conn = %Firebird.Phoenix.Conn{
+        method: "POST",
+        params: %{},
+        req_headers: %{},
+        halted: false,
+        status: 200,
+        resp_body: "",
+        resp_headers: %{},
+        assigns: %{},
+        path: "/",
+        query_string: "",
+        body: ""
+      }
+
       result = middleware.(conn)
       assert result.halted
       assert result.status == 403
@@ -164,30 +211,63 @@ defmodule Firebird.Phoenix.CSRFTest do
 
     test "allows POST with correct token in params" do
       middleware = CSRF.protect(token: "valid-token")
-      conn = %Firebird.Phoenix.Conn{method: "POST",
-        params: %{"_csrf_token" => "valid-token"}, req_headers: %{}, halted: false,
-        status: 200, resp_body: "", resp_headers: %{}, assigns: %{}, path: "/",
-        query_string: "", body: ""}
+
+      conn = %Firebird.Phoenix.Conn{
+        method: "POST",
+        params: %{"_csrf_token" => "valid-token"},
+        req_headers: %{},
+        halted: false,
+        status: 200,
+        resp_body: "",
+        resp_headers: %{},
+        assigns: %{},
+        path: "/",
+        query_string: "",
+        body: ""
+      }
+
       result = middleware.(conn)
       refute result.halted
     end
 
     test "allows POST with correct token in header" do
       middleware = CSRF.protect(token: "valid-token")
-      conn = %Firebird.Phoenix.Conn{method: "POST",
-        params: %{}, req_headers: %{"x-csrf-token" => "valid-token"}, halted: false,
-        status: 200, resp_body: "", resp_headers: %{}, assigns: %{}, path: "/",
-        query_string: "", body: ""}
+
+      conn = %Firebird.Phoenix.Conn{
+        method: "POST",
+        params: %{},
+        req_headers: %{"x-csrf-token" => "valid-token"},
+        halted: false,
+        status: 200,
+        resp_body: "",
+        resp_headers: %{},
+        assigns: %{},
+        path: "/",
+        query_string: "",
+        body: ""
+      }
+
       result = middleware.(conn)
       refute result.halted
     end
 
     test "blocks POST with wrong token" do
       middleware = CSRF.protect(token: "expected")
-      conn = %Firebird.Phoenix.Conn{method: "POST",
-        params: %{"_csrf_token" => "wrong"}, req_headers: %{}, halted: false,
-        status: 200, resp_body: "", resp_headers: %{}, assigns: %{}, path: "/",
-        query_string: "", body: ""}
+
+      conn = %Firebird.Phoenix.Conn{
+        method: "POST",
+        params: %{"_csrf_token" => "wrong"},
+        req_headers: %{},
+        halted: false,
+        status: 200,
+        resp_body: "",
+        resp_headers: %{},
+        assigns: %{},
+        path: "/",
+        query_string: "",
+        body: ""
+      }
+
       result = middleware.(conn)
       assert result.halted
       assert result.status == 403
@@ -195,18 +275,42 @@ defmodule Firebird.Phoenix.CSRFTest do
 
     test "blocks PUT without token" do
       middleware = CSRF.protect(token: "token")
-      conn = %Firebird.Phoenix.Conn{method: "PUT", params: %{}, req_headers: %{}, halted: false,
-        status: 200, resp_body: "", resp_headers: %{}, assigns: %{}, path: "/",
-        query_string: "", body: ""}
+
+      conn = %Firebird.Phoenix.Conn{
+        method: "PUT",
+        params: %{},
+        req_headers: %{},
+        halted: false,
+        status: 200,
+        resp_body: "",
+        resp_headers: %{},
+        assigns: %{},
+        path: "/",
+        query_string: "",
+        body: ""
+      }
+
       result = middleware.(conn)
       assert result.halted
     end
 
     test "blocks DELETE without token" do
       middleware = CSRF.protect(token: "token")
-      conn = %Firebird.Phoenix.Conn{method: "DELETE", params: %{}, req_headers: %{}, halted: false,
-        status: 200, resp_body: "", resp_headers: %{}, assigns: %{}, path: "/",
-        query_string: "", body: ""}
+
+      conn = %Firebird.Phoenix.Conn{
+        method: "DELETE",
+        params: %{},
+        req_headers: %{},
+        halted: false,
+        status: 200,
+        resp_body: "",
+        resp_headers: %{},
+        assigns: %{},
+        path: "/",
+        query_string: "",
+        body: ""
+      }
+
       result = middleware.(conn)
       assert result.halted
     end
diff --git a/test/phoenix/csrf_wasm_test.exs b/test/phoenix/csrf_wasm_test.exs
index cbca839..b604cb6 100644
--- a/test/phoenix/csrf_wasm_test.exs
+++ b/test/phoenix/csrf_wasm_test.exs
@@ -35,10 +35,12 @@ defmodule Firebird.Phoenix.CsrfWasmTest do
     end
 
     test "generates tokens with consistent length", %{csrf: csrf} do
-      tokens = for _ <- 1..10 do
-        {:ok, token} = CsrfWasm.generate_token(csrf, "my_secret")
-        token
-      end
+      tokens =
+        for _ <- 1..10 do
+          {:ok, token} = CsrfWasm.generate_token(csrf, "my_secret")
+          token
+        end
+
       lengths = Enum.map(tokens, &byte_size/1) |> Enum.uniq()
       # All tokens should be the same length (88 chars for 64-byte base64)
       assert length(lengths) == 1
@@ -172,10 +174,12 @@ defmodule Firebird.Phoenix.CsrfWasmTest do
     end
 
     test "generate many tokens, all unique", %{csrf: csrf} do
-      tokens = for _ <- 1..100 do
-        {:ok, token} = CsrfWasm.generate_token(csrf, "secret")
-        token
-      end
+      tokens =
+        for _ <- 1..100 do
+          {:ok, token} = CsrfWasm.generate_token(csrf, "secret")
+          token
+        end
+
       assert length(Enum.uniq(tokens)) == 100
     end
 
diff --git a/test/phoenix/edge_cases_test.exs b/test/phoenix/edge_cases_test.exs
index a4d69fe..18e2c19 100644
--- a/test/phoenix/edge_cases_test.exs
+++ b/test/phoenix/edge_cases_test.exs
@@ -34,25 +34,28 @@ defmodule Firebird.Phoenix.EdgeCasesTest do
 
     test "root path matches", %{router: instance} do
       routes = [{"GET", "/", "RootController.index"}]
+
       assert {:ok, %{handler: "RootController.index"}} =
                Firebird.Phoenix.Router.match(instance, "GET", "/", routes)
     end
 
     test "wildcard route matches deep paths", %{router: instance} do
       routes = [{"GET", "/files/*", "FileController.show"}]
+
       assert {:ok, %{handler: "FileController.show", params: params}} =
                Firebird.Phoenix.Router.match(instance, "GET", "/files/a/b/c/d.txt", routes)
+
       assert params["glob"] =~ "a/b/c/d.txt"
     end
 
     test "method mismatch returns not_found", %{router: instance} do
       routes = [{"POST", "/users", "UserController.create"}]
-      assert {:ok, :not_found} =
-               Firebird.Phoenix.Router.match(instance, "GET", "/users", routes)
+      assert {:ok, :not_found} = Firebird.Phoenix.Router.match(instance, "GET", "/users", routes)
     end
 
     test "universal method matches any", %{router: instance} do
       routes = [{"*", "/health", "HealthController.check"}]
+
       assert {:ok, %{handler: "HealthController.check"}} =
                Firebird.Phoenix.Router.match(instance, "DELETE", "/health", routes)
     end
@@ -63,8 +66,7 @@ defmodule Firebird.Phoenix.EdgeCasesTest do
     end
 
     test "URL decode handles plus as space", %{router: instance} do
-      assert {:ok, "hello world"} =
-               Firebird.Phoenix.Router.url_decode(instance, "hello+world")
+      assert {:ok, "hello world"} = Firebird.Phoenix.Router.url_decode(instance, "hello+world")
     end
 
     test "empty query string returns empty map", %{router: instance} do
@@ -81,13 +83,13 @@ defmodule Firebird.Phoenix.EdgeCasesTest do
     test "template with empty assigns renders static parts", %{template: instance} do
       assert {:ok, html} =
                Firebird.Phoenix.Template.render(instance, "<p>Hello {{name}}</p>", %{})
+
       # Unmatched variables may be removed
       assert html =~ "<p>"
     end
 
     test "HTML escape handles all special characters", %{template: instance} do
-      assert {:ok, escaped} =
-               Firebird.Phoenix.Template.html_escape(instance, ~s(&<>"'))
+      assert {:ok, escaped} = Firebird.Phoenix.Template.html_escape(instance, ~s(&<>"'))
       assert escaped =~ "&amp;"
       assert escaped =~ "&lt;"
       assert escaped =~ "&gt;"
@@ -102,6 +104,7 @@ defmodule Firebird.Phoenix.EdgeCasesTest do
     test "renders list with single item", %{template: instance} do
       assert {:ok, html} =
                Firebird.Phoenix.Template.render_list(instance, "<li>{{item}}</li>", ["only"])
+
       assert html =~ "only"
     end
 
@@ -137,6 +140,7 @@ defmodule Firebird.Phoenix.EdgeCasesTest do
                  "*/*",
                  ["text/html", "application/json"]
                )
+
       assert content_type in ["text/html", "application/json"]
     end
 
@@ -152,20 +156,22 @@ defmodule Firebird.Phoenix.EdgeCasesTest do
     test "build response with 500 status", %{plug: instance} do
       assert {:ok, resp} =
                Firebird.Phoenix.Plug.build_response(instance, 500, "text/plain", "Server Error")
+
       assert resp =~ "500"
       assert resp =~ "Server Error"
     end
 
     test "encode JSON with special characters", %{plug: instance} do
-      assert {:ok, json} =
-               Firebird.Phoenix.Plug.encode_json(instance, %{"msg" => "hello world"})
+      assert {:ok, json} = Firebird.Phoenix.Plug.encode_json(instance, %{"msg" => "hello world"})
       assert json =~ "hello world"
     end
   end
 
   describe "Endpoint edge cases" do
     test "parse conn with multiple headers", %{endpoint: instance} do
-      request = "GET /api HTTP/1.1\r\nHost: example.com\r\nAccept: */*\r\nAuth: bearer token\r\n\r\n"
+      request =
+        "GET /api HTTP/1.1\r\nHost: example.com\r\nAccept: */*\r\nAuth: bearer token\r\n\r\n"
+
       assert {:ok, conn} = Firebird.Phoenix.Endpoint.parse_conn(instance, request)
       assert conn.method == "GET"
       assert conn.path == "/api"
@@ -174,7 +180,11 @@ defmodule Firebird.Phoenix.EdgeCasesTest do
     test "pipeline with unknown plug still works", %{endpoint: instance} do
       request = "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
       # Unknown plugs should be ignored gracefully
-      assert {:ok, conn} = Firebird.Phoenix.Endpoint.execute_pipeline(instance, request, ["put_secure_headers"])
+      assert {:ok, conn} =
+               Firebird.Phoenix.Endpoint.execute_pipeline(instance, request, [
+                 "put_secure_headers"
+               ])
+
       assert conn.halted == false
     end
 
@@ -205,12 +215,14 @@ defmodule Firebird.Phoenix.EdgeCasesTest do
                  "",
                  %{"show" => "true"}
                )
+
       assert html =~ "Visible"
     end
 
     test "collection with single item", %{view: instance} do
       assert {:ok, html} =
                Firebird.Phoenix.View.render_collection(instance, "<span>{{item}}</span>", ["only"])
+
       assert html =~ "only"
     end
 
@@ -228,6 +240,7 @@ defmodule Firebird.Phoenix.EdgeCasesTest do
                  target: "_blank",
                  method: "post"
                )
+
       assert html =~ ~s(class="api-link")
       assert html =~ ~s(target="_blank")
       assert html =~ ~s(data-method="post")
@@ -241,6 +254,7 @@ defmodule Firebird.Phoenix.EdgeCasesTest do
                  width: "100",
                  height: "100"
                )
+
       assert html =~ ~s(alt="Photo")
       assert html =~ ~s(class="rounded")
       assert html =~ ~s(width="100")
@@ -248,7 +262,9 @@ defmodule Firebird.Phoenix.EdgeCasesTest do
     end
 
     test "render_page with empty meta tags", %{view: instance} do
-      assert {:ok, html} = Firebird.Phoenix.View.render_page(instance, "Title", "<p>Body</p>", %{}, [])
+      assert {:ok, html} =
+               Firebird.Phoenix.View.render_page(instance, "Title", "<p>Body</p>", %{}, [])
+
       assert html =~ "<title>Title</title>"
       assert html =~ "<p>Body</p>"
     end
@@ -256,19 +272,18 @@ defmodule Firebird.Phoenix.EdgeCasesTest do
 
   describe "Channel edge cases" do
     test "match topic with no patterns", %{channel: instance} do
-      assert {:ok, :not_found} =
-               Firebird.Phoenix.Channel.match_topic(instance, "room:1", [])
+      assert {:ok, :not_found} = Firebird.Phoenix.Channel.match_topic(instance, "room:1", [])
     end
 
     test "route event with catch-all", %{channel: instance} do
       handlers = [{"*", "handle_any"}]
+
       assert {:ok, "handle_any"} =
                Firebird.Phoenix.Channel.route_event(instance, "anything", handlers)
     end
 
     test "serialize empty payload message", %{channel: instance} do
-      assert {:ok, json} =
-               Firebird.Phoenix.Channel.serialize_message(instance, "room:1", "ping")
+      assert {:ok, json} = Firebird.Phoenix.Channel.serialize_message(instance, "room:1", "ping")
       assert json =~ ~s("topic":"room:1")
       assert json =~ ~s("event":"ping")
       assert json =~ ~s("payload":{})
@@ -277,6 +292,7 @@ defmodule Firebird.Phoenix.EdgeCasesTest do
     test "build reply with ok status", %{channel: instance} do
       assert {:ok, json} =
                Firebird.Phoenix.Channel.build_reply(instance, :ok, "ref_1", %{"msg" => "done"})
+
       assert json =~ ~s("status":"ok")
       assert json =~ ~s("ref":"ref_1")
     end
@@ -284,8 +300,8 @@ defmodule Firebird.Phoenix.EdgeCasesTest do
     test "presence join then leave results in empty state", %{channel: instance} do
       {:ok, state1} =
         Firebird.Phoenix.Channel.track_presence(instance, :join, "user:1", %{}, %{"name" => "A"})
-      {:ok, state2} =
-        Firebird.Phoenix.Channel.track_presence(instance, :leave, "user:1", state1)
+
+      {:ok, state2} = Firebird.Phoenix.Channel.track_presence(instance, :leave, "user:1", state1)
       assert map_size(state2) == 0
     end
   end
@@ -300,7 +316,9 @@ defmodule Firebird.Phoenix.EdgeCasesTest do
     end
 
     test "API error with single error", %{json: instance} do
-      assert {:ok, resp} = Firebird.Phoenix.JSON.api_error(instance, 400, [{"field", "error msg"}])
+      assert {:ok, resp} =
+               Firebird.Phoenix.JSON.api_error(instance, 400, [{"field", "error msg"}])
+
       assert resp =~ "400 Bad Request"
       assert resp =~ "error msg"
     end
@@ -339,13 +357,13 @@ defmodule Firebird.Phoenix.EdgeCasesTest do
     test "compile preserves attributes" do
       assert {:ok, template} =
                Firebird.Phoenix.EExCompiler.compile(~s(<div class="card"><%= @name %></div>))
+
       assert template =~ ~s(class="card")
       assert template =~ "{{name}}"
     end
 
     test "compile handles adjacent variables" do
-      assert {:ok, template} =
-               Firebird.Phoenix.EExCompiler.compile("<%= @first %><%= @last %>")
+      assert {:ok, template} = Firebird.Phoenix.EExCompiler.compile("<%= @first %><%= @last %>")
       assert template == "{{first}}{{last}}"
     end
   end
diff --git a/test/phoenix/eex_compiler_test.exs b/test/phoenix/eex_compiler_test.exs
index 7efd795..30a99e0 100644
--- a/test/phoenix/eex_compiler_test.exs
+++ b/test/phoenix/eex_compiler_test.exs
@@ -7,20 +7,17 @@ defmodule Firebird.Phoenix.EExCompilerTest do
 
   describe "compile/1" do
     test "compiles simple variable output" do
-      assert {:ok, "Hello {{name}}"} =
-               EExCompiler.compile("Hello <%= @name %>")
+      assert {:ok, "Hello {{name}}"} = EExCompiler.compile("Hello <%= @name %>")
     end
 
     test "compiles multiple variables" do
-      assert {:ok, template} =
-               EExCompiler.compile("<h1><%= @title %></h1><p><%= @body %></p>")
+      assert {:ok, template} = EExCompiler.compile("<h1><%= @title %></h1><p><%= @body %></p>")
 
       assert template == "<h1>{{title}}</h1><p>{{body}}</p>"
     end
 
     test "compiles raw output" do
-      assert {:ok, template} =
-               EExCompiler.compile("<div><%= raw(@html_content) %></div>")
+      assert {:ok, template} = EExCompiler.compile("<div><%= raw(@html_content) %></div>")
 
       assert template == "<div>{{{html_content}}}</div>"
     end
@@ -33,22 +30,19 @@ defmodule Firebird.Phoenix.EExCompilerTest do
     end
 
     test "preserves static HTML" do
-      assert {:ok, template} =
-               EExCompiler.compile("<html><body><h1>Static</h1></body></html>")
+      assert {:ok, template} = EExCompiler.compile("<html><body><h1>Static</h1></body></html>")
 
       assert template == "<html><body><h1>Static</h1></body></html>"
     end
 
     test "handles whitespace around variables" do
-      assert {:ok, template} =
-               EExCompiler.compile("<%= @name %>")
+      assert {:ok, template} = EExCompiler.compile("<%= @name %>")
 
       assert template == "{{name}}"
     end
 
     test "handles variables with extra whitespace" do
-      assert {:ok, template} =
-               EExCompiler.compile("<%=   @name   %>")
+      assert {:ok, template} = EExCompiler.compile("<%=   @name   %>")
 
       assert template == "{{name}}"
     end
@@ -72,8 +66,7 @@ defmodule Firebird.Phoenix.EExCompilerTest do
     end
 
     test "strips code blocks" do
-      assert {:ok, template} =
-               EExCompiler.compile("<% # comment %><h1><%= @title %></h1>")
+      assert {:ok, template} = EExCompiler.compile("<% # comment %><h1><%= @title %></h1>")
 
       assert template == "<h1>{{title}}</h1>"
     end
@@ -98,8 +91,8 @@ defmodule Firebird.Phoenix.EExCompilerTest do
       path = Path.join(System.tmp_dir!(), "test_template.html.eex")
       File.write!(path, "<h1><%= @title %></h1>")
 
+      # Note: the <h1> part should be there too
       assert {:ok, "{{title}}</h1>"} =
-               # Note: the <h1> part should be there too
                EExCompiler.compile_file(path)
                |> then(fn {:ok, t} -> {:ok, String.slice(t, 4..-1//1)} end)
 
@@ -222,15 +215,13 @@ defmodule Firebird.Phoenix.EExCompilerTest do
     end
 
     test "rejects arithmetic expressions" do
-      assert {:error, reasons} =
-               EExCompiler.validate("<%= @count + 1 %>")
+      assert {:error, reasons} = EExCompiler.validate("<%= @count + 1 %>")
 
       assert Enum.any?(reasons, &String.contains?(&1, "arithmetic"))
     end
 
     test "rejects pipeline operator" do
-      assert {:error, reasons} =
-               EExCompiler.validate("<%= @name |> String.upcase() %>")
+      assert {:error, reasons} = EExCompiler.validate("<%= @name |> String.upcase() %>")
 
       assert Enum.any?(reasons, &String.contains?(&1, "pipeline"))
     end
diff --git a/test/phoenix/eex_to_wasm_test.exs b/test/phoenix/eex_to_wasm_test.exs
index e6f16ed..9ef72a7 100644
--- a/test/phoenix/eex_to_wasm_test.exs
+++ b/test/phoenix/eex_to_wasm_test.exs
@@ -34,7 +34,10 @@ defmodule Firebird.Phoenix.EExToWasmTest do
     test "HTML escaping via WASM", %{template: template} do
       eex = "<p>User: <%= @name %></p>"
       {:ok, wasm_tmpl} = EExCompiler.compile(eex)
-      {:ok, html} = Template.render(template, wasm_tmpl, %{"name" => "<script>alert('xss')</script>"})
+
+      {:ok, html} =
+        Template.render(template, wasm_tmpl, %{"name" => "<script>alert('xss')</script>"})
+
       assert html =~ "&lt;script&gt;"
       refute html =~ "<script>"
     end
@@ -42,14 +45,17 @@ defmodule Firebird.Phoenix.EExToWasmTest do
     test "blog post template (single-line)", %{template: template} do
       # Note: WASM template uses \n as delimiter between template and assigns
       # So templates must be single-line for direct WASM rendering
-      eex = ~s(<article><h1><%= @title %></h1><p>By <%= @author %></p><div><%= @body %></div></article>)
+      eex =
+        ~s(<article><h1><%= @title %></h1><p>By <%= @author %></p><div><%= @body %></div></article>)
 
       {:ok, wasm_tmpl} = EExCompiler.compile(eex)
-      {:ok, html} = Template.render(template, wasm_tmpl, %{
-        "title" => "Phoenix WASM",
-        "author" => "Firebird Team",
-        "body" => "This is about compiling Phoenix to WASM."
-      })
+
+      {:ok, html} =
+        Template.render(template, wasm_tmpl, %{
+          "title" => "Phoenix WASM",
+          "author" => "Firebird Team",
+          "body" => "This is about compiling Phoenix to WASM."
+        })
 
       assert html =~ "Phoenix WASM"
       assert html =~ "Firebird Team"
@@ -57,14 +63,17 @@ defmodule Firebird.Phoenix.EExToWasmTest do
     end
 
     test "layout template (single-line)", %{template: template} do
-      eex = ~s(<html><head><title><%= @page_title %></title></head><body><nav><%= @nav %></nav><main><%= @content %></main></body></html>)
+      eex =
+        ~s(<html><head><title><%= @page_title %></title></head><body><nav><%= @nav %></nav><main><%= @content %></main></body></html>)
 
       {:ok, wasm_tmpl} = EExCompiler.compile(eex)
-      {:ok, html} = Template.render(template, wasm_tmpl, %{
-        "page_title" => "My Site",
-        "nav" => "Home | About",
-        "content" => "Welcome!"
-      })
+
+      {:ok, html} =
+        Template.render(template, wasm_tmpl, %{
+          "page_title" => "My Site",
+          "nav" => "Home | About",
+          "content" => "Welcome!"
+        })
 
       assert html =~ "<title>My Site</title>"
       assert html =~ "Home | About"
@@ -72,14 +81,17 @@ defmodule Firebird.Phoenix.EExToWasmTest do
     end
 
     test "form template (single-line)", %{template: template} do
-      eex = ~s(<form action="<%= @action %>" method="post"><input name="_csrf" value="<%= @csrf %>"/><input name="user[name]" value="<%= @name %>"/></form>)
+      eex =
+        ~s(<form action="<%= @action %>" method="post"><input name="_csrf" value="<%= @csrf %>"/><input name="user[name]" value="<%= @name %>"/></form>)
 
       {:ok, wasm_tmpl} = EExCompiler.compile(eex)
-      {:ok, html} = Template.render(template, wasm_tmpl, %{
-        "action" => "/users",
-        "csrf" => "abc123",
-        "name" => "Alice"
-      })
+
+      {:ok, html} =
+        Template.render(template, wasm_tmpl, %{
+          "action" => "/users",
+          "csrf" => "abc123",
+          "name" => "Alice"
+        })
 
       assert html =~ ~s(action="/users")
       assert html =~ ~s(value="abc123")
@@ -87,13 +99,18 @@ defmodule Firebird.Phoenix.EExToWasmTest do
     end
 
     test "table template (single-line)", %{template: template} do
-      eex = ~s(<table><tr><td><%= @name1 %></td><td><%= @email1 %></td></tr><tr><td><%= @name2 %></td><td><%= @email2 %></td></tr></table>)
+      eex =
+        ~s(<table><tr><td><%= @name1 %></td><td><%= @email1 %></td></tr><tr><td><%= @name2 %></td><td><%= @email2 %></td></tr></table>)
 
       {:ok, wasm_tmpl} = EExCompiler.compile(eex)
-      {:ok, html} = Template.render(template, wasm_tmpl, %{
-        "name1" => "Alice", "email1" => "alice@example.com",
-        "name2" => "Bob", "email2" => "bob@example.com"
-      })
+
+      {:ok, html} =
+        Template.render(template, wasm_tmpl, %{
+          "name1" => "Alice",
+          "email1" => "alice@example.com",
+          "name2" => "Bob",
+          "email2" => "bob@example.com"
+        })
 
       assert html =~ "Alice"
       assert html =~ "bob@example.com"
diff --git a/test/phoenix/end_to_end_test.exs b/test/phoenix/end_to_end_test.exs
index 02ac9d2..f32f579 100644
--- a/test/phoenix/end_to_end_test.exs
+++ b/test/phoenix/end_to_end_test.exs
@@ -38,27 +38,33 @@ defmodule Firebird.Phoenix.EndToEndTest do
 
   describe "complete Phoenix WASM application" do
     setup do
-      {:ok, server} = Server.start_link(
-        port: 0,
-        routes: [
-          {"GET", "/", "PageController.index"},
-          {"GET", "/api/users", "UserController.index"},
-          {"GET", "/api/users/:id", "UserController.show"},
-          {"POST", "/api/users", "UserController.create"},
-          {"PUT", "/api/users/:id", "UserController.update"},
-          {"DELETE", "/api/users/:id", "UserController.delete"},
-          {"GET", "/api/health", "HealthController.check"},
-        ],
-        actions: %{
-          "PageController.index" => {200, "text/html", "<html><body><h1>Phoenix WASM App</h1></body></html>"},
-          "UserController.index" => {200, "application/json", ~s([{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}])},
-          "UserController.show" => {200, "application/json", ~s({"id":"{{id}}","name":"User {{id}}"})},
-          "UserController.create" => {201, "application/json", ~s({"id":"3","status":"created"})},
-          "UserController.update" => {200, "application/json", ~s({"id":"{{id}}","status":"updated"})},
-          "UserController.delete" => {204, "application/json", ""},
-          "HealthController.check" => {200, "application/json", ~s({"status":"ok","wasm":true})},
-        }
-      )
+      {:ok, server} =
+        Server.start_link(
+          port: 0,
+          routes: [
+            {"GET", "/", "PageController.index"},
+            {"GET", "/api/users", "UserController.index"},
+            {"GET", "/api/users/:id", "UserController.show"},
+            {"POST", "/api/users", "UserController.create"},
+            {"PUT", "/api/users/:id", "UserController.update"},
+            {"DELETE", "/api/users/:id", "UserController.delete"},
+            {"GET", "/api/health", "HealthController.check"}
+          ],
+          actions: %{
+            "PageController.index" =>
+              {200, "text/html", "<html><body><h1>Phoenix WASM App</h1></body></html>"},
+            "UserController.index" =>
+              {200, "application/json", ~s([{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}])},
+            "UserController.show" =>
+              {200, "application/json", ~s({"id":"{{id}}","name":"User {{id}}"})},
+            "UserController.create" =>
+              {201, "application/json", ~s({"id":"3","status":"created"})},
+            "UserController.update" =>
+              {200, "application/json", ~s({"id":"{{id}}","status":"updated"})},
+            "UserController.delete" => {204, "application/json", ""},
+            "HealthController.check" => {200, "application/json", ~s({"status":"ok","wasm":true})}
+          }
+        )
 
       on_exit(fn ->
         if Process.alive?(server), do: Server.stop(server)
@@ -136,7 +142,7 @@ defmodule Firebird.Phoenix.EndToEndTest do
 
     test "route → render → response pipeline", ctx do
       routes = [
-        {"GET", "/products/:id", "ProductController.show"},
+        {"GET", "/products/:id", "ProductController.show"}
       ]
 
       # Step 1: Route matching
@@ -146,9 +152,10 @@ defmodule Firebird.Phoenix.EndToEndTest do
 
       # Step 2: Template rendering with params
       tmpl = ~S(<div class="product"><h1>Product #{{id}}</h1><p>Price: ${{price}}</p></div>)
-      {:ok, html} = Template.render(ctx.template, tmpl,
-        Map.merge(match.params, %{"price" => "29.99"})
-      )
+
+      {:ok, html} =
+        Template.render(ctx.template, tmpl, Map.merge(match.params, %{"price" => "29.99"}))
+
       assert html =~ "Product #42"
       assert html =~ "$29.99"
 
@@ -179,8 +186,8 @@ defmodule Firebird.Phoenix.EndToEndTest do
       {:ok, token} = CsrfWasm.generate_token(ctx.csrf, "app_secret")
 
       # Build form with CSRF token
-      {:ok, form_html} = FormWasm.build_form(ctx.form, "user", "/register",
-        method: :post, csrf_token: token)
+      {:ok, form_html} =
+        FormWasm.build_form(ctx.form, "user", "/register", method: :post, csrf_token: token)
 
       assert form_html =~ token
       assert form_html =~ ~s(name="_csrf_token")
@@ -192,15 +199,21 @@ defmodule Firebird.Phoenix.EndToEndTest do
     test "complete registration form with CSRF", ctx do
       {:ok, token} = CsrfWasm.generate_token(ctx.csrf, "secret")
 
-      {:ok, form_tag} = FormWasm.build_form(ctx.form, "user", "/register",
-        method: :post, csrf_token: token)
+      {:ok, form_tag} =
+        FormWasm.build_form(ctx.form, "user", "/register", method: :post, csrf_token: token)
+
       {:ok, name} = FormWasm.text_input(ctx.form, "user", "name", required: true)
       {:ok, email} = FormWasm.email_input(ctx.form, "user", "email", required: true)
       {:ok, pass} = FormWasm.password_input(ctx.form, "user", "password", required: true)
       {:ok, terms} = FormWasm.checkbox(ctx.form, "user", "terms", label: "I agree")
 
-      full_form = form_tag <> name <> email <> pass <> terms <>
-        ~s(<button type="submit">Register</button></form>)
+      full_form =
+        form_tag <>
+          name <>
+          email <>
+          pass <>
+          terms <>
+          ~s(<button type="submit">Register</button></form>)
 
       assert full_form =~ ~s(name="user[name]")
       assert full_form =~ ~s(name="user[email]")
@@ -271,8 +284,11 @@ defmodule Firebird.Phoenix.EndToEndTest do
 
     test "parse session cookies for request context", ctx do
       # Parse cookies from request
-      {:ok, cookies} = Session.parse_cookies(ctx.session,
-        "session_id=abc123; user_id=42; theme=dark")
+      {:ok, cookies} =
+        Session.parse_cookies(
+          ctx.session,
+          "session_id=abc123; user_id=42; theme=dark"
+        )
 
       assert cookies["session_id"] == "abc123"
       assert cookies["user_id"] == "42"
@@ -283,10 +299,11 @@ defmodule Firebird.Phoenix.EndToEndTest do
       # Validate request parameters using Controller
       params = %{"name" => "Alice", "email" => "alice@example.com"}
 
-      {:ok, :valid} = Controller.validate_params(ctx.controller, params, [
-        {"name", "required"},
-        {"email", "required"}
-      ])
+      {:ok, :valid} =
+        Controller.validate_params(ctx.controller, params, [
+          {"name", "required"},
+          {"email", "required"}
+        ])
 
       # Render JSON response
       {:ok, json_str} = JSON.encode_object(ctx.json, params)
@@ -317,16 +334,20 @@ defmodule Firebird.Phoenix.EndToEndTest do
     end
 
     test "matches wildcard topics", ctx do
-      {:ok, match} = Channel.match_topic(ctx.channel, "room:lobby", [
-        {"room:*", "RoomChannel"}
-      ])
+      {:ok, match} =
+        Channel.match_topic(ctx.channel, "room:lobby", [
+          {"room:*", "RoomChannel"}
+        ])
+
       assert match.handler == "RoomChannel"
     end
 
     test "exact topic matching", ctx do
-      {:ok, match} = Channel.match_topic(ctx.channel, "room:lobby", [
-        {"room:lobby", "LobbyChannel"}
-      ])
+      {:ok, match} =
+        Channel.match_topic(ctx.channel, "room:lobby", [
+          {"room:lobby", "LobbyChannel"}
+        ])
+
       assert match.handler == "LobbyChannel"
     end
   end
@@ -343,16 +364,20 @@ defmodule Firebird.Phoenix.EndToEndTest do
     end
 
     test "validates required fields", ctx do
-      {:ok, result} = Validator.validate(ctx.validator, %{"name" => "Alice"}, [
-        {:required, "name"}
-      ])
+      {:ok, result} =
+        Validator.validate(ctx.validator, %{"name" => "Alice"}, [
+          {:required, "name"}
+        ])
+
       assert result == :valid
     end
 
     test "detects missing required fields", ctx do
-      {:ok, result} = Validator.validate(ctx.validator, %{"name" => ""}, [
-        {:required, "name"}
-      ])
+      {:ok, result} =
+        Validator.validate(ctx.validator, %{"name" => ""}, [
+          {:required, "name"}
+        ])
+
       assert result != :valid
     end
   end
@@ -377,21 +402,24 @@ defmodule Firebird.Phoenix.EndToEndTest do
         validator: "phoenix_validator.wasm",
         form: "phoenix_form.wasm",
         csrf: "phoenix_csrf.wasm",
-        rate_limiter: "phoenix_rate_limiter.wasm",
+        rate_limiter: "phoenix_rate_limiter.wasm"
       }
 
       # Load all components
-      loaded = Enum.reduce(components, %{}, fn {key, file}, acc ->
-        path = Path.join(@fixtures_dir, file)
-        if File.exists?(path) do
-          {:ok, pid} = Firebird.load(path)
-          Map.put(acc, key, pid)
-        else
-          acc
-        end
-      end)
+      loaded =
+        Enum.reduce(components, %{}, fn {key, file}, acc ->
+          path = Path.join(@fixtures_dir, file)
 
-      assert map_size(loaded) == 14, "Expected 14 components, got #{map_size(loaded)}: #{inspect(Map.keys(loaded))}"
+          if File.exists?(path) do
+            {:ok, pid} = Firebird.load(path)
+            Map.put(acc, key, pid)
+          else
+            acc
+          end
+        end)
+
+      assert map_size(loaded) == 14,
+             "Expected 14 components, got #{map_size(loaded)}: #{inspect(Map.keys(loaded))}"
 
       # Verify all are running
       for {key, pid} <- loaded do
@@ -399,9 +427,11 @@ defmodule Firebird.Phoenix.EndToEndTest do
       end
 
       # Use router
-      {:ok, match} = Router.match(loaded.router, "GET", "/users/42", [
-        {"GET", "/users/:id", "UserController.show"}
-      ])
+      {:ok, match} =
+        Router.match(loaded.router, "GET", "/users/42", [
+          {"GET", "/users/:id", "UserController.show"}
+        ])
+
       assert match.params["id"] == "42"
 
       # Use template
diff --git a/test/phoenix/endpoint_batch_test.exs b/test/phoenix/endpoint_batch_test.exs
index 14443a4..6e36a2a 100644
--- a/test/phoenix/endpoint_batch_test.exs
+++ b/test/phoenix/endpoint_batch_test.exs
@@ -219,18 +219,22 @@ defmodule Firebird.Phoenix.EndpointBatchTest do
     end
 
     test "single response batch", %{instance: instance} do
-      assert {:ok, [response]} = Endpoint.batch_json_response(instance, [
-        {200, %{"ok" => "true"}}
-      ])
+      assert {:ok, [response]} =
+               Endpoint.batch_json_response(instance, [
+                 {200, %{"ok" => "true"}}
+               ])
+
       assert response =~ "200 OK"
       assert response =~ ~s("ok":true)
     end
 
     test "empty data maps", %{instance: instance} do
-      assert {:ok, results} = Endpoint.batch_json_response(instance, [
-        {200, %{}},
-        {204, %{}}
-      ])
+      assert {:ok, results} =
+               Endpoint.batch_json_response(instance, [
+                 {200, %{}},
+                 {204, %{}}
+               ])
+
       assert length(results) == 2
       assert Enum.at(results, 0) =~ "{}"
     end
diff --git a/test/phoenix/endpoint_deserialize_test.exs b/test/phoenix/endpoint_deserialize_test.exs
index 997fce6..1572056 100644
--- a/test/phoenix/endpoint_deserialize_test.exs
+++ b/test/phoenix/endpoint_deserialize_test.exs
@@ -83,7 +83,8 @@ defmodule Firebird.Phoenix.EndpointDeserializeTest do
 
     test "handles malformed status gracefully" do
       conn = Endpoint.deserialize_conn("status=not_a_number")
-      assert conn.status == 200  # falls back to default
+      # falls back to default
+      assert conn.status == 200
     end
 
     test "handles values containing equals signs" do
@@ -105,20 +106,24 @@ defmodule Firebird.Phoenix.EndpointDeserializeTest do
     end
 
     test "parses a full realistic conn" do
-      input = Enum.join([
-        "method=POST",
-        "path=/api/users",
-        "query=format=json",
-        "status=201",
-        "state=sent",
-        "halted=false",
-        "body={\"name\":\"Bob\"}",
-        "resp_header:content-type=application/json",
-        "resp_header:x-request-id=abc-123",
-        "assign:current_user=bob",
-        "param:format=json",
-        "cookie:session=xyz"
-      ], "\n")
+      input =
+        Enum.join(
+          [
+            "method=POST",
+            "path=/api/users",
+            "query=format=json",
+            "status=201",
+            "state=sent",
+            "halted=false",
+            "body={\"name\":\"Bob\"}",
+            "resp_header:content-type=application/json",
+            "resp_header:x-request-id=abc-123",
+            "assign:current_user=bob",
+            "param:format=json",
+            "cookie:session=xyz"
+          ],
+          "\n"
+        )
 
       conn = Endpoint.deserialize_conn(input)
 
diff --git a/test/phoenix/endpoint_test.exs b/test/phoenix/endpoint_test.exs
index b1129c9..9e34033 100644
--- a/test/phoenix/endpoint_test.exs
+++ b/test/phoenix/endpoint_test.exs
@@ -29,13 +29,17 @@ defmodule Firebird.Phoenix.EndpointTest do
     end
 
     test "parses POST request with body", %{instance: instance} do
-      request = "POST /api/users HTTP/1.1\r\nContent-Type: application/json\r\n\r\n{\"name\":\"Alice\"}"
+      request =
+        "POST /api/users HTTP/1.1\r\nContent-Type: application/json\r\n\r\n{\"name\":\"Alice\"}"
+
       assert {:ok, conn} = Endpoint.parse_conn(instance, request)
       assert conn.method == "POST"
     end
 
     test "parses request with cookies", %{instance: instance} do
-      request = "GET / HTTP/1.1\r\nHost: example.com\r\nCookie: session_id=abc123; theme=dark\r\n\r\n"
+      request =
+        "GET / HTTP/1.1\r\nHost: example.com\r\nCookie: session_id=abc123; theme=dark\r\n\r\n"
+
       assert {:ok, conn} = Endpoint.parse_conn(instance, request)
       assert conn.cookies["session_id"] == "abc123"
       assert conn.cookies["theme"] == "dark"
@@ -95,29 +99,42 @@ defmodule Firebird.Phoenix.EndpointTest do
 
     test "executes set_header plug", %{instance: instance} do
       request = "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
-      assert {:ok, conn} = Endpoint.execute_pipeline(instance, request, ["set_header:x-custom:hello"])
+
+      assert {:ok, conn} =
+               Endpoint.execute_pipeline(instance, request, ["set_header:x-custom:hello"])
+
       assert conn.resp_headers["x-custom"] == "hello"
     end
 
     test "executes require_header plug - success", %{instance: instance} do
       request = "GET / HTTP/1.1\r\nHost: example.com\r\nAuthorization: Bearer token\r\n\r\n"
-      assert {:ok, conn} = Endpoint.execute_pipeline(instance, request, ["require_header:authorization"])
+
+      assert {:ok, conn} =
+               Endpoint.execute_pipeline(instance, request, ["require_header:authorization"])
+
       assert conn.halted == false
     end
 
     test "executes require_header plug - missing header halts", %{instance: instance} do
       request = "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
-      assert {:ok, conn} = Endpoint.execute_pipeline(instance, request, ["require_header:authorization"])
+
+      assert {:ok, conn} =
+               Endpoint.execute_pipeline(instance, request, ["require_header:authorization"])
+
       assert conn.halted == true
       assert conn.status == 400
     end
 
     test "halted pipeline stops execution", %{instance: instance} do
       request = "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
-      assert {:ok, conn} = Endpoint.execute_pipeline(instance, request, [
-        "require_header:authorization",
-        "put_secure_headers"  # This should NOT execute because pipeline is halted
-      ])
+
+      assert {:ok, conn} =
+               Endpoint.execute_pipeline(instance, request, [
+                 "require_header:authorization",
+                 # This should NOT execute because pipeline is halted
+                 "put_secure_headers"
+               ])
+
       assert conn.halted == true
       # Security headers should NOT be set since pipeline halted before that plug
       assert conn.resp_headers["x-frame-options"] == nil
@@ -137,7 +154,10 @@ defmodule Firebird.Phoenix.EndpointTest do
 
     test "executes assign plug", %{instance: instance} do
       request = "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
-      assert {:ok, conn} = Endpoint.execute_pipeline(instance, request, ["assign:current_user=alice"])
+
+      assert {:ok, conn} =
+               Endpoint.execute_pipeline(instance, request, ["assign:current_user=alice"])
+
       assert conn.assigns["current_user"] == "alice"
     end
 
@@ -149,11 +169,14 @@ defmodule Firebird.Phoenix.EndpointTest do
 
     test "executes multiple plugs in order", %{instance: instance} do
       request = "GET / HTTP/1.1\r\nHost: example.com\r\nAccept: text/html\r\n\r\n"
-      assert {:ok, conn} = Endpoint.execute_pipeline(instance, request, [
-        "put_secure_headers",
-        "cors:https://example.com",
-        "set_header:x-request-id:123"
-      ])
+
+      assert {:ok, conn} =
+               Endpoint.execute_pipeline(instance, request, [
+                 "put_secure_headers",
+                 "cors:https://example.com",
+                 "set_header:x-request-id:123"
+               ])
+
       assert conn.resp_headers["x-frame-options"] == "SAMEORIGIN"
       assert conn.resp_headers["access-control-allow-origin"] == "https://example.com"
       assert conn.resp_headers["x-request-id"] == "123"
@@ -167,7 +190,10 @@ defmodule Firebird.Phoenix.EndpointTest do
 
     test "CORS with specific origin", %{instance: instance} do
       request = "GET /api HTTP/1.1\r\nHost: example.com\r\n\r\n"
-      assert {:ok, conn} = Endpoint.execute_pipeline(instance, request, ["cors:https://myapp.com"])
+
+      assert {:ok, conn} =
+               Endpoint.execute_pipeline(instance, request, ["cors:https://myapp.com"])
+
       assert conn.resp_headers["access-control-allow-origin"] == "https://myapp.com"
     end
   end
@@ -216,7 +242,10 @@ defmodule Firebird.Phoenix.EndpointTest do
     test "dispatches with multiple path params", %{instance: instance} do
       request = "GET /users/5/posts/10 HTTP/1.1\r\nHost: example.com\r\n\r\n"
       routes = [{"GET", "/users/:user_id/posts/:post_id", "PostController.show"}]
-      actions = %{"PostController.show" => {200, "text/html", "User {{user_id}} Post {{post_id}}"}}
+
+      actions = %{
+        "PostController.show" => {200, "text/html", "User {{user_id}} Post {{post_id}}"}
+      }
 
       assert {:ok, response} = Endpoint.dispatch(instance, request, routes, actions)
       assert response =~ "User 5 Post 10"
@@ -225,10 +254,12 @@ defmodule Firebird.Phoenix.EndpointTest do
     test "dispatches with method matching", %{instance: instance} do
       request_get = "GET /users HTTP/1.1\r\nHost: example.com\r\n\r\n"
       request_post = "POST /users HTTP/1.1\r\nHost: example.com\r\n\r\n"
+
       routes = [
         {"GET", "/users", "UserController.index"},
         {"POST", "/users", "UserController.create"}
       ]
+
       actions = %{
         "UserController.index" => {200, "text/html", "List"},
         "UserController.create" => {201, "text/html", "Created"}
@@ -250,6 +281,7 @@ defmodule Firebird.Phoenix.EndpointTest do
         {"PUT", "/api/users/:id", "UserController.update"},
         {"DELETE", "/api/users/:id", "UserController.delete"}
       ]
+
       actions = %{
         "UserController.index" => {200, "application/json", ~s([])},
         "UserController.show" => {200, "application/json", ~s({"id":"{{id}}"})},
@@ -266,7 +298,9 @@ defmodule Firebird.Phoenix.EndpointTest do
 
   describe "json_response/3" do
     test "builds JSON 200 response", %{instance: instance} do
-      assert {:ok, response} = Endpoint.json_response(instance, 200, %{"name" => "Alice", "age" => "30"})
+      assert {:ok, response} =
+               Endpoint.json_response(instance, 200, %{"name" => "Alice", "age" => "30"})
+
       assert response =~ "HTTP/1.1 200 OK"
       assert response =~ "application/json"
       assert response =~ ~s("name":"Alice")
@@ -290,7 +324,9 @@ defmodule Firebird.Phoenix.EndpointTest do
     end
 
     test "handles boolean values", %{instance: instance} do
-      assert {:ok, response} = Endpoint.json_response(instance, 200, %{"active" => "true", "deleted" => "false"})
+      assert {:ok, response} =
+               Endpoint.json_response(instance, 200, %{"active" => "true", "deleted" => "false"})
+
       assert response =~ ~s("active":true)
       assert response =~ ~s("deleted":false)
     end
@@ -308,44 +344,51 @@ defmodule Firebird.Phoenix.EndpointTest do
 
   describe "render_response/5" do
     test "renders template with assigns", %{instance: instance} do
-      assert {:ok, response} = Endpoint.render_response(instance, 200, "text/html",
-        "<h1>Hello {{name}}</h1>",
-        %{"name" => "World"}
-      )
+      assert {:ok, response} =
+               Endpoint.render_response(instance, 200, "text/html", "<h1>Hello {{name}}</h1>", %{
+                 "name" => "World"
+               })
+
       assert response =~ "HTTP/1.1 200 OK"
       assert response =~ "text/html"
       assert response =~ "<h1>Hello World</h1>"
     end
 
     test "HTML-escapes assigns", %{instance: instance} do
-      assert {:ok, response} = Endpoint.render_response(instance, 200, "text/html",
-        "<p>{{content}}</p>",
-        %{"content" => "<script>alert('xss')</script>"}
-      )
+      assert {:ok, response} =
+               Endpoint.render_response(instance, 200, "text/html", "<p>{{content}}</p>", %{
+                 "content" => "<script>alert('xss')</script>"
+               })
+
       assert response =~ "&lt;script&gt;"
       refute response =~ "<script>alert"
     end
 
     test "renders with multiple assigns", %{instance: instance} do
-      assert {:ok, response} = Endpoint.render_response(instance, 200, "text/html",
-        "<div>{{first}} {{last}}</div>",
-        %{"first" => "John", "last" => "Doe"}
-      )
+      assert {:ok, response} =
+               Endpoint.render_response(
+                 instance,
+                 200,
+                 "text/html",
+                 "<div>{{first}} {{last}}</div>",
+                 %{"first" => "John", "last" => "Doe"}
+               )
+
       assert response =~ "John"
       assert response =~ "Doe"
     end
 
     test "renders without assigns", %{instance: instance} do
-      assert {:ok, response} = Endpoint.render_response(instance, 200, "text/html",
-        "<h1>Static</h1>"
-      )
+      assert {:ok, response} =
+               Endpoint.render_response(instance, 200, "text/html", "<h1>Static</h1>")
+
       assert response =~ "<h1>Static</h1>"
     end
 
     test "renders with 404 status", %{instance: instance} do
-      assert {:ok, response} = Endpoint.render_response(instance, 404, "text/html",
-        "<h1>Not Found</h1>"
-      )
+      assert {:ok, response} =
+               Endpoint.render_response(instance, 404, "text/html", "<h1>Not Found</h1>")
+
       assert response =~ "404 Not Found"
     end
   end
diff --git a/test/phoenix/error_handler_test.exs b/test/phoenix/error_handler_test.exs
index 5cd7f7b..51b4882 100644
--- a/test/phoenix/error_handler_test.exs
+++ b/test/phoenix/error_handler_test.exs
@@ -23,25 +23,28 @@ defmodule Firebird.Phoenix.ErrorHandlerTest do
 
   describe "put_template/3" do
     test "adds a custom template" do
-      handler = ErrorHandler.new()
-      |> ErrorHandler.put_template(404, "<h1>Custom 404</h1>")
+      handler =
+        ErrorHandler.new()
+        |> ErrorHandler.put_template(404, "<h1>Custom 404</h1>")
 
       assert handler.templates[404] == "<h1>Custom 404</h1>"
     end
 
     test "adds multiple templates" do
-      handler = ErrorHandler.new()
-      |> ErrorHandler.put_template(404, "Not Found")
-      |> ErrorHandler.put_template(500, "Server Error")
+      handler =
+        ErrorHandler.new()
+        |> ErrorHandler.put_template(404, "Not Found")
+        |> ErrorHandler.put_template(500, "Server Error")
 
       assert handler.templates[404] == "Not Found"
       assert handler.templates[500] == "Server Error"
     end
 
     test "overrides existing template" do
-      handler = ErrorHandler.new()
-      |> ErrorHandler.put_template(404, "Old")
-      |> ErrorHandler.put_template(404, "New")
+      handler =
+        ErrorHandler.new()
+        |> ErrorHandler.put_template(404, "Old")
+        |> ErrorHandler.put_template(404, "New")
 
       assert handler.templates[404] == "New"
     end
@@ -67,8 +70,9 @@ defmodule Firebird.Phoenix.ErrorHandlerTest do
     end
 
     test "renders custom template with variable substitution" do
-      handler = ErrorHandler.new()
-      |> ErrorHandler.put_template(404, "<h1>{{status}}</h1><p>{{message}}</p>")
+      handler =
+        ErrorHandler.new()
+        |> ErrorHandler.put_template(404, "<h1>{{status}}</h1><p>{{message}}</p>")
 
       html = ErrorHandler.render(handler, 404, %{"message" => "Page not found"})
       assert html =~ "404"
@@ -100,13 +104,15 @@ defmodule Firebird.Phoenix.ErrorHandlerTest do
     end
 
     test "renders custom template with extra assigns" do
-      handler = ErrorHandler.new()
-      |> ErrorHandler.put_template(422, "Error: {{message}} ({{detail}})")
+      handler =
+        ErrorHandler.new()
+        |> ErrorHandler.put_template(422, "Error: {{message}} ({{detail}})")
 
-      result = ErrorHandler.render(handler, 422, %{
-        "message" => "Validation failed",
-        "detail" => "Name is required"
-      })
+      result =
+        ErrorHandler.render(handler, 422, %{
+          "message" => "Validation failed",
+          "detail" => "Name is required"
+        })
 
       assert result =~ "Validation failed"
       assert result =~ "Name is required"
@@ -129,23 +135,23 @@ defmodule Firebird.Phoenix.ErrorHandlerTest do
 
     test "renders all common status codes" do
       for {status, message} <- [
-        {400, "Bad Request"},
-        {401, "Unauthorized"},
-        {403, "Forbidden"},
-        {404, "Not Found"},
-        {405, "Method Not Allowed"},
-        {406, "Not Acceptable"},
-        {408, "Request Timeout"},
-        {409, "Conflict"},
-        {413, "Payload Too Large"},
-        {415, "Unsupported Media Type"},
-        {422, "Unprocessable Entity"},
-        {429, "Too Many Requests"},
-        {500, "Internal Server Error"},
-        {502, "Bad Gateway"},
-        {503, "Service Unavailable"},
-        {504, "Gateway Timeout"}
-      ] do
+            {400, "Bad Request"},
+            {401, "Unauthorized"},
+            {403, "Forbidden"},
+            {404, "Not Found"},
+            {405, "Method Not Allowed"},
+            {406, "Not Acceptable"},
+            {408, "Request Timeout"},
+            {409, "Conflict"},
+            {413, "Payload Too Large"},
+            {415, "Unsupported Media Type"},
+            {422, "Unprocessable Entity"},
+            {429, "Too Many Requests"},
+            {500, "Internal Server Error"},
+            {502, "Bad Gateway"},
+            {503, "Service Unavailable"},
+            {504, "Gateway Timeout"}
+          ] do
         html = ErrorHandler.render_error(status)
         assert html =~ "#{status}", "Missing status #{status} in HTML"
         assert html =~ message, "Missing message '#{message}' for status #{status}"
@@ -194,7 +200,8 @@ defmodule Firebird.Phoenix.ErrorHandlerTest do
   describe "status_message/1" do
     test "returns message for known codes" do
       assert ErrorHandler.status_message(200) == "OK" or
-             ErrorHandler.status_message(200) == "Unknown Error"
+               ErrorHandler.status_message(200) == "Unknown Error"
+
       assert ErrorHandler.status_message(404) == "Not Found"
       assert ErrorHandler.status_message(500) == "Internal Server Error"
     end
@@ -217,4 +224,3 @@ defmodule Firebird.Phoenix.ErrorHandlerTest do
     end
   end
 end
-
diff --git a/test/phoenix/form_test.exs b/test/phoenix/form_test.exs
index f9a7d10..5e8eecd 100644
--- a/test/phoenix/form_test.exs
+++ b/test/phoenix/form_test.exs
@@ -347,19 +347,21 @@ defmodule Firebird.Phoenix.FormTest do
 
   describe "complete form example" do
     test "builds a full user form" do
-      form = [
-        Form.form_for("user", "/users", method: :post, csrf_token: "test-token"),
-        Form.label("user", "name", "Name"),
-        Form.text_input("user", "name", value: "Alice", required: true),
-        Form.label("user", "email", "Email"),
-        Form.email_input("user", "email", placeholder: "user@example.com"),
-        Form.label("user", "role", "Role"),
-        Form.select("user", "role", ["admin", "user"], selected: "user"),
-        Form.checkbox("user", "active", checked: true),
-        Form.textarea("user", "bio", rows: "5"),
-        Form.submit("Create User", class: "btn"),
-        Form.end_form()
-      ] |> Enum.join("\n")
+      form =
+        [
+          Form.form_for("user", "/users", method: :post, csrf_token: "test-token"),
+          Form.label("user", "name", "Name"),
+          Form.text_input("user", "name", value: "Alice", required: true),
+          Form.label("user", "email", "Email"),
+          Form.email_input("user", "email", placeholder: "user@example.com"),
+          Form.label("user", "role", "Role"),
+          Form.select("user", "role", ["admin", "user"], selected: "user"),
+          Form.checkbox("user", "active", checked: true),
+          Form.textarea("user", "bio", rows: "5"),
+          Form.submit("Create User", class: "btn"),
+          Form.end_form()
+        ]
+        |> Enum.join("\n")
 
       assert form =~ ~s(action="/users")
       assert form =~ ~s(_csrf_token)
diff --git a/test/phoenix/form_wasm_test.exs b/test/phoenix/form_wasm_test.exs
index 6105396..755953b 100644
--- a/test/phoenix/form_wasm_test.exs
+++ b/test/phoenix/form_wasm_test.exs
@@ -93,7 +93,9 @@ defmodule Firebird.Phoenix.FormWasmTest do
     end
 
     test "escapes value for XSS protection", %{form: form} do
-      {:ok, html} = FormWasm.text_input(form, "user", "name", value: "<script>alert('xss')</script>")
+      {:ok, html} =
+        FormWasm.text_input(form, "user", "name", value: "<script>alert('xss')</script>")
+
       assert html =~ "&lt;script&gt;"
       refute html =~ "<script>"
     end
@@ -243,29 +245,38 @@ defmodule Firebird.Phoenix.FormWasmTest do
 
   describe "complete form building" do
     test "builds a complete user registration form", %{form: form} do
-      {:ok, form_tag} = FormWasm.build_form(form, "user", "/register",
-        method: :post, csrf_token: "tok123", class: "registration-form")
-
-      {:ok, name_field} = FormWasm.text_input(form, "user", "name",
-        placeholder: "Full name", required: true)
-
-      {:ok, email_field} = FormWasm.email_input(form, "user", "email",
-        placeholder: "Email address", required: true)
-
-      {:ok, password_field} = FormWasm.password_input(form, "user", "password",
-        placeholder: "Password", required: true)
-
-      {:ok, bio_field} = FormWasm.textarea(form, "user", "bio",
-        rows: 5, placeholder: "Tell us about yourself")
-
-      {:ok, role_field} = FormWasm.select(form, "user", "role",
-        [{"user", "User"}, {"admin", "Admin"}], selected: "user")
-
-      {:ok, terms_field} = FormWasm.checkbox(form, "user", "terms",
-        label: "I agree to the terms")
-
-      full_form = form_tag <> name_field <> email_field <> password_field <>
-        bio_field <> role_field <> terms_field <> "</form>"
+      {:ok, form_tag} =
+        FormWasm.build_form(form, "user", "/register",
+          method: :post,
+          csrf_token: "tok123",
+          class: "registration-form"
+        )
+
+      {:ok, name_field} =
+        FormWasm.text_input(form, "user", "name", placeholder: "Full name", required: true)
+
+      {:ok, email_field} =
+        FormWasm.email_input(form, "user", "email", placeholder: "Email address", required: true)
+
+      {:ok, password_field} =
+        FormWasm.password_input(form, "user", "password", placeholder: "Password", required: true)
+
+      {:ok, bio_field} =
+        FormWasm.textarea(form, "user", "bio", rows: 5, placeholder: "Tell us about yourself")
+
+      {:ok, role_field} =
+        FormWasm.select(form, "user", "role", [{"user", "User"}, {"admin", "Admin"}],
+          selected: "user"
+        )
+
+      {:ok, terms_field} = FormWasm.checkbox(form, "user", "terms", label: "I agree to the terms")
+
+      full_form =
+        form_tag <>
+          name_field <>
+          email_field <>
+          password_field <>
+          bio_field <> role_field <> terms_field <> "</form>"
 
       # Verify all parts are present
       assert full_form =~ ~s(class="registration-form")
diff --git a/test/phoenix/full_stack_test.exs b/test/phoenix/full_stack_test.exs
index 379087c..fee646d 100644
--- a/test/phoenix/full_stack_test.exs
+++ b/test/phoenix/full_stack_test.exs
@@ -25,13 +25,16 @@ defmodule Firebird.Phoenix.FullStackTest do
       actions = %{
         "PageController.index" => {200, "text/html", "<h1>Welcome</h1>"},
         "UserController.index" => {200, "application/json", ~s([{"id":"1"},{"id":"2"}])},
-        "UserController.show" => {200, "application/json", ~s({"id":"{{id}}","name":"User {{id}}"})},
+        "UserController.show" =>
+          {200, "application/json", ~s({"id":"{{id}}","name":"User {{id}}"})},
         "UserController.create" => {201, "application/json", ~s({"status":"created"})}
       }
 
       raw = "GET /users/42 HTTP/1.1\r\nHost: localhost\r\nAccept: application/json\r\n\r\n"
 
-      assert {:ok, response} = Firebird.Phoenix.Endpoint.dispatch(c.endpoint, raw, routes, actions)
+      assert {:ok, response} =
+               Firebird.Phoenix.Endpoint.dispatch(c.endpoint, raw, routes, actions)
+
       assert response =~ "42"
       assert response =~ "User 42"
     end
@@ -47,20 +50,24 @@ defmodule Firebird.Phoenix.FullStackTest do
         "UserController.create" => {201, "application/json", ~s({"status":"created"})}
       }
 
-      raw = "POST /users HTTP/1.1\r\nHost: localhost\r\nContent-Type: application/json\r\n\r\n{\"name\":\"Alice\"}"
+      raw =
+        "POST /users HTTP/1.1\r\nHost: localhost\r\nContent-Type: application/json\r\n\r\n{\"name\":\"Alice\"}"
+
+      assert {:ok, response} =
+               Firebird.Phoenix.Endpoint.dispatch(c.endpoint, raw, routes, actions)
 
-      assert {:ok, response} = Firebird.Phoenix.Endpoint.dispatch(c.endpoint, raw, routes, actions)
       assert response =~ "created"
     end
 
     test "process_request/2 high-level API works end-to-end", %{c: c} do
-      {:ok, resp} = Firebird.Phoenix.process_request(c,
-        method: "GET",
-        path: "/api/users/99",
-        headers: %{"host" => "localhost", "accept" => "application/json"},
-        routes: [{"GET", "/api/users/:id", "Api.UserController.show"}],
-        actions: %{"Api.UserController.show" => {200, "application/json", ~s({"id":"{{id}}"})}}
-      )
+      {:ok, resp} =
+        Firebird.Phoenix.process_request(c,
+          method: "GET",
+          path: "/api/users/99",
+          headers: %{"host" => "localhost", "accept" => "application/json"},
+          routes: [{"GET", "/api/users/:id", "Api.UserController.show"}],
+          actions: %{"Api.UserController.show" => {200, "application/json", ~s({"id":"{{id}}"})}}
+        )
 
       assert resp.status == 200
       assert resp.body =~ "99"
@@ -134,19 +141,26 @@ defmodule Firebird.Phoenix.FullStackTest do
 
   describe "session + endpoint integration" do
     test "parse cookies from request", %{c: c} do
-      {:ok, cookies} = Firebird.Phoenix.Session.parse_cookies(
-        c.session, "user_id=42; theme=dark; lang=en"
-      )
+      {:ok, cookies} =
+        Firebird.Phoenix.Session.parse_cookies(
+          c.session,
+          "user_id=42; theme=dark; lang=en"
+        )
+
       assert cookies["user_id"] == "42"
       assert cookies["theme"] == "dark"
       assert cookies["lang"] == "en"
     end
 
     test "sign and verify cookies", %{c: c} do
-      {:ok, signed} = Firebird.Phoenix.Session.sign_cookie(c.session, "secret_key_base_123", "user_42")
+      {:ok, signed} =
+        Firebird.Phoenix.Session.sign_cookie(c.session, "secret_key_base_123", "user_42")
+
       assert is_binary(signed)
 
-      {:ok, verified} = Firebird.Phoenix.Session.verify_cookie(c.session, "secret_key_base_123", signed)
+      {:ok, verified} =
+        Firebird.Phoenix.Session.verify_cookie(c.session, "secret_key_base_123", signed)
+
       assert verified == "user_42"
     end
 
@@ -163,7 +177,8 @@ defmodule Firebird.Phoenix.FullStackTest do
       params = %{"name" => "Alice", "email" => "alice@example.com"}
       rules = [{"name", "required"}, {"email", "required"}]
 
-      assert {:ok, :valid} = Firebird.Phoenix.Controller.validate_params(c.controller, params, rules)
+      assert {:ok, :valid} =
+               Firebird.Phoenix.Controller.validate_params(c.controller, params, rules)
     end
 
     test "validate params with missing required field", %{c: c} do
@@ -176,45 +191,54 @@ defmodule Firebird.Phoenix.FullStackTest do
     end
 
     test "validate email format", %{c: c} do
-      {:ok, :valid} = Firebird.Phoenix.Controller.validate_params(
-        c.controller,
-        %{"email" => "user@example.com"},
-        [{"email", "format:email"}]
-      )
-
-      {:ok, errors} = Firebird.Phoenix.Controller.validate_params(
-        c.controller,
-        %{"email" => "not-an-email"},
-        [{"email", "format:email"}]
-      )
+      {:ok, :valid} =
+        Firebird.Phoenix.Controller.validate_params(
+          c.controller,
+          %{"email" => "user@example.com"},
+          [{"email", "format:email"}]
+        )
+
+      {:ok, errors} =
+        Firebird.Phoenix.Controller.validate_params(
+          c.controller,
+          %{"email" => "not-an-email"},
+          [{"email", "format:email"}]
+        )
+
       assert length(errors) > 0
     end
   end
 
   describe "json API integration" do
     test "encode object to JSON", %{c: c} do
-      {:ok, json} = Firebird.Phoenix.JSON.encode_object(c.json, %{
-        "id" => "1",
-        "name" => "Alice",
-        "active" => "true"
-      })
+      {:ok, json} =
+        Firebird.Phoenix.JSON.encode_object(c.json, %{
+          "id" => "1",
+          "name" => "Alice",
+          "active" => "true"
+        })
+
       assert json =~ "\"id\""
       assert json =~ "\"Alice\""
     end
 
     test "build API response", %{c: c} do
-      {:ok, response} = Firebird.Phoenix.JSON.api_response(c.json, 200, %{
-        "id" => "42",
-        "name" => "Alice"
-      })
+      {:ok, response} =
+        Firebird.Phoenix.JSON.api_response(c.json, 200, %{
+          "id" => "42",
+          "name" => "Alice"
+        })
+
       assert response =~ "42"
       assert response =~ "Alice"
     end
 
     test "build API error response", %{c: c} do
-      {:ok, response} = Firebird.Phoenix.JSON.api_error(c.json, 422, [
-        {"email", "is invalid"}
-      ])
+      {:ok, response} =
+        Firebird.Phoenix.JSON.api_error(c.json, 422, [
+          {"email", "is invalid"}
+        ])
+
       assert response =~ "email"
       assert response =~ "invalid"
     end
@@ -243,15 +267,24 @@ defmodule Firebird.Phoenix.FullStackTest do
 
   describe "channel integration" do
     test "match topic pattern", %{c: c} do
-      {:ok, result} = Firebird.Phoenix.Channel.match_topic(c.channel, "room:lobby", [{"room:*", "RoomChannel.join"}])
+      {:ok, result} =
+        Firebird.Phoenix.Channel.match_topic(c.channel, "room:lobby", [
+          {"room:*", "RoomChannel.join"}
+        ])
+
       assert result.handler == "RoomChannel.join"
       assert result.params["subtopic"] == "lobby"
     end
 
     test "serialize channel message", %{c: c} do
-      {:ok, serialized} = Firebird.Phoenix.Channel.serialize_message(
-        c.channel, "room:lobby", "new_msg", %{"body" => "Hello"}
-      )
+      {:ok, serialized} =
+        Firebird.Phoenix.Channel.serialize_message(
+          c.channel,
+          "room:lobby",
+          "new_msg",
+          %{"body" => "Hello"}
+        )
+
       assert is_binary(serialized)
       assert serialized =~ "room:lobby"
       assert serialized =~ "new_msg"
@@ -299,48 +332,64 @@ defmodule Firebird.Phoenix.FullStackTest do
         "UserController.index" => {200, "application/json", ~s([{"id":"1"},{"id":"2"}])},
         "UserController.show" => {200, "application/json", ~s({"id":"{{id}}"})},
         "UserController.create" => {201, "application/json", ~s({"id":"3","status":"created"})},
-        "UserController.update" => {200, "application/json", ~s({"id":"{{id}}","status":"updated"})},
+        "UserController.update" =>
+          {200, "application/json", ~s({"id":"{{id}}","status":"updated"})},
         "UserController.delete" => {204, "text/plain", ""}
       }
 
       # GET /api/users (index)
-      {:ok, resp} = Firebird.Phoenix.Endpoint.dispatch(
-        c.endpoint,
-        "GET /api/users HTTP/1.1\r\nHost: localhost\r\n\r\n",
-        routes, actions
-      )
+      {:ok, resp} =
+        Firebird.Phoenix.Endpoint.dispatch(
+          c.endpoint,
+          "GET /api/users HTTP/1.1\r\nHost: localhost\r\n\r\n",
+          routes,
+          actions
+        )
+
       assert resp =~ "id"
 
       # GET /api/users/1 (show)
-      {:ok, resp} = Firebird.Phoenix.Endpoint.dispatch(
-        c.endpoint,
-        "GET /api/users/1 HTTP/1.1\r\nHost: localhost\r\n\r\n",
-        routes, actions
-      )
+      {:ok, resp} =
+        Firebird.Phoenix.Endpoint.dispatch(
+          c.endpoint,
+          "GET /api/users/1 HTTP/1.1\r\nHost: localhost\r\n\r\n",
+          routes,
+          actions
+        )
+
       assert resp =~ "\"1\""
 
       # POST /api/users (create)
-      {:ok, resp} = Firebird.Phoenix.Endpoint.dispatch(
-        c.endpoint,
-        "POST /api/users HTTP/1.1\r\nHost: localhost\r\nContent-Type: application/json\r\n\r\n{}",
-        routes, actions
-      )
+      {:ok, resp} =
+        Firebird.Phoenix.Endpoint.dispatch(
+          c.endpoint,
+          "POST /api/users HTTP/1.1\r\nHost: localhost\r\nContent-Type: application/json\r\n\r\n{}",
+          routes,
+          actions
+        )
+
       assert resp =~ "created"
 
       # PUT /api/users/1 (update)
-      {:ok, resp} = Firebird.Phoenix.Endpoint.dispatch(
-        c.endpoint,
-        "PUT /api/users/1 HTTP/1.1\r\nHost: localhost\r\n\r\n",
-        routes, actions
-      )
+      {:ok, resp} =
+        Firebird.Phoenix.Endpoint.dispatch(
+          c.endpoint,
+          "PUT /api/users/1 HTTP/1.1\r\nHost: localhost\r\n\r\n",
+          routes,
+          actions
+        )
+
       assert resp =~ "updated"
 
       # DELETE /api/users/1 (delete)
-      {:ok, resp} = Firebird.Phoenix.Endpoint.dispatch(
-        c.endpoint,
-        "DELETE /api/users/1 HTTP/1.1\r\nHost: localhost\r\n\r\n",
-        routes, actions
-      )
+      {:ok, resp} =
+        Firebird.Phoenix.Endpoint.dispatch(
+          c.endpoint,
+          "DELETE /api/users/1 HTTP/1.1\r\nHost: localhost\r\n\r\n",
+          routes,
+          actions
+        )
+
       assert is_binary(resp)
     end
   end
@@ -366,12 +415,14 @@ defmodule Firebird.Phoenix.FullStackTest do
 
   describe "edge cases" do
     test "empty route list returns 404", %{c: c} do
-      {:ok, resp} = Firebird.Phoenix.process_request(c,
-        method: "GET",
-        path: "/anything",
-        routes: [],
-        actions: %{}
-      )
+      {:ok, resp} =
+        Firebird.Phoenix.process_request(c,
+          method: "GET",
+          path: "/anything",
+          routes: [],
+          actions: %{}
+        )
+
       assert resp.status == 404
     end
 
diff --git a/test/phoenix/integration_test.exs b/test/phoenix/integration_test.exs
index 89a8c26..93473c6 100644
--- a/test/phoenix/integration_test.exs
+++ b/test/phoenix/integration_test.exs
@@ -165,10 +165,16 @@ defmodule Firebird.Phoenix.IntegrationTest do
     test "channel message round-trip", ctx do
       # 1. Serialize a message
       {:ok, json} =
-        Channel.serialize_message(ctx.channel, "room:lobby", "new_msg", %{
-          "body" => "Hello world",
-          "sender" => "alice"
-        }, "ref_1")
+        Channel.serialize_message(
+          ctx.channel,
+          "room:lobby",
+          "new_msg",
+          %{
+            "body" => "Hello world",
+            "sender" => "alice"
+          },
+          "ref_1"
+        )
 
       assert json =~ ~s("topic":"room:lobby")
       assert json =~ ~s("event":"new_msg")
diff --git a/test/phoenix/json_test.exs b/test/phoenix/json_test.exs
index a882a9a..6e5cc1d 100644
--- a/test/phoenix/json_test.exs
+++ b/test/phoenix/json_test.exs
@@ -23,7 +23,9 @@ defmodule Firebird.Phoenix.JSONTest do
     end
 
     test "encodes boolean values", %{instance: instance} do
-      assert {:ok, json} = JSON.encode_object(instance, %{"active" => "true", "deleted" => "false"})
+      assert {:ok, json} =
+               JSON.encode_object(instance, %{"active" => "true", "deleted" => "false"})
+
       assert json =~ ~s("active":true)
       assert json =~ ~s("deleted":false)
     end
@@ -78,8 +80,7 @@ defmodule Firebird.Phoenix.JSONTest do
 
   describe "api_response/3 with map" do
     test "builds 200 response with data", %{instance: instance} do
-      assert {:ok, resp} =
-               JSON.api_response(instance, 200, %{"id" => "1", "name" => "Alice"})
+      assert {:ok, resp} = JSON.api_response(instance, 200, %{"id" => "1", "name" => "Alice"})
 
       assert resp =~ "HTTP/1.1 200 OK"
       assert resp =~ "application/json"
@@ -89,8 +90,7 @@ defmodule Firebird.Phoenix.JSONTest do
     end
 
     test "builds 201 created response", %{instance: instance} do
-      assert {:ok, resp} =
-               JSON.api_response(instance, 201, %{"id" => "1", "name" => "New User"})
+      assert {:ok, resp} = JSON.api_response(instance, 201, %{"id" => "1", "name" => "New User"})
 
       assert resp =~ "201 Created"
     end
diff --git a/test/phoenix/live_extended_test.exs b/test/phoenix/live_extended_test.exs
index ba02d50..f1a03ca 100644
--- a/test/phoenix/live_extended_test.exs
+++ b/test/phoenix/live_extended_test.exs
@@ -15,6 +15,7 @@ defmodule Firebird.Phoenix.LiveExtendedTest do
       html = "<div><h1>Hello</h1></div>"
       result = Live.diff_html(instance, html, html)
       assert match?({:ok, _}, result)
+
       case result do
         {:ok, patches} -> assert patches == [] or Enum.all?(patches, &(&1.type == :noop))
         _ -> :ok
@@ -107,36 +108,48 @@ defmodule Firebird.Phoenix.LiveExtendedTest do
 
   describe "render_component/5" do
     test "renders component with template", %{instance: instance} do
-      result = Live.render_component(instance, "user-card",
-        "<div class=\"card\"><h2>{{name}}</h2></div>",
-        %{"name" => "Alice"})
+      result =
+        Live.render_component(
+          instance,
+          "user-card",
+          "<div class=\"card\"><h2>{{name}}</h2></div>",
+          %{"name" => "Alice"}
+        )
+
       assert match?({:ok, _}, result)
+
       case result do
         {:ok, html} ->
           assert html =~ "Alice"
           assert html =~ "card"
-        _ -> :ok
+
+        _ ->
+          :ok
       end
     end
 
     test "renders component without assigns", %{instance: instance} do
-      result = Live.render_component(instance, "static",
-        "<p>Static content</p>", %{})
+      result = Live.render_component(instance, "static", "<p>Static content</p>", %{})
       assert match?({:ok, _}, result)
     end
 
     test "renders component with children", %{instance: instance} do
-      result = Live.render_component(instance, "wrapper",
-        "<div>{{children}}</div>",
-        %{},
-        [{"child1", "<p>Child 1</p>"}, {"child2", "<p>Child 2</p>"}])
+      result =
+        Live.render_component(instance, "wrapper", "<div>{{children}}</div>", %{}, [
+          {"child1", "<p>Child 1</p>"},
+          {"child2", "<p>Child 2</p>"}
+        ])
+
       assert match?({:ok, _}, result)
     end
 
     test "renders component with multiple assigns", %{instance: instance} do
-      result = Live.render_component(instance, "profile",
-        "<div>{{name}} - {{role}}</div>",
-        %{"name" => "Bob", "role" => "Admin"})
+      result =
+        Live.render_component(instance, "profile", "<div>{{name}} - {{role}}</div>", %{
+          "name" => "Bob",
+          "role" => "Admin"
+        })
+
       assert match?({:ok, _}, result)
     end
   end
@@ -148,13 +161,15 @@ defmodule Firebird.Phoenix.LiveExtendedTest do
       {:ok, patches} = Live.diff_html(instance, old, new)
 
       if length(patches) > 0 do
-        patches_str = Enum.map_join(patches, "\n", fn patch ->
-          case patch do
-            %{type: :replace, old: o, new: n} -> "replace|#{o}|#{n}"
-            %{type: :noop} -> "noop"
-            other -> inspect(other)
-          end
-        end)
+        patches_str =
+          Enum.map_join(patches, "\n", fn patch ->
+            case patch do
+              %{type: :replace, old: o, new: n} -> "replace|#{o}|#{n}"
+              %{type: :noop} -> "noop"
+              other -> inspect(other)
+            end
+          end)
+
         result = Live.apply_patches(instance, old, patches_str)
         assert match?({:ok, _}, result)
       end
diff --git a/test/phoenix/live_test.exs b/test/phoenix/live_test.exs
index 0c6010a..3adc233 100644
--- a/test/phoenix/live_test.exs
+++ b/test/phoenix/live_test.exs
@@ -36,9 +36,10 @@ defmodule Firebird.Phoenix.LiveTest do
       new = ~s(<div class="new">Content</div>)
       assert {:ok, patches} = Live.diff_html(instance, old, new)
       assert length(patches) > 0
+
       assert Enum.any?(patches, fn p ->
-        p.type == :attr or p.type == :raw
-      end)
+               p.type == :attr or p.type == :raw
+             end)
     end
 
     test "handles empty old HTML", %{instance: instance} do
@@ -168,8 +169,7 @@ defmodule Firebird.Phoenix.LiveTest do
     end
 
     test "renders component with no assigns or children", %{instance: instance} do
-      assert {:ok, html} =
-               Live.render_component(instance, "static", "<p>Static</p>")
+      assert {:ok, html} = Live.render_component(instance, "static", "<p>Static</p>")
 
       assert html =~ "data-phx-component=\"static\""
       assert html =~ "Static"
diff --git a/test/phoenix/middleware_test.exs b/test/phoenix/middleware_test.exs
index 46f94ed..d83f5a1 100644
--- a/test/phoenix/middleware_test.exs
+++ b/test/phoenix/middleware_test.exs
@@ -13,19 +13,21 @@ defmodule Firebird.Phoenix.MiddlewareTest do
 
   describe "use/2" do
     test "adds middleware function" do
-      chain = Middleware.new()
-      |> Middleware.use(fn conn -> conn end)
+      chain =
+        Middleware.new()
+        |> Middleware.use(fn conn -> conn end)
 
       assert Middleware.count(chain) == 1
     end
 
     test "preserves order" do
-      chain = Middleware.new()
-      |> Middleware.use(fn conn -> Conn.assign(conn, :order, [1]) end)
-      |> Middleware.use(fn conn ->
-        order = conn.assigns[:order] || []
-        Conn.assign(conn, :order, order ++ [2])
-      end)
+      chain =
+        Middleware.new()
+        |> Middleware.use(fn conn -> Conn.assign(conn, :order, [1]) end)
+        |> Middleware.use(fn conn ->
+          order = conn.assigns[:order] || []
+          Conn.assign(conn, :order, order ++ [2])
+        end)
 
       assert Middleware.count(chain) == 2
     end
@@ -33,9 +35,10 @@ defmodule Firebird.Phoenix.MiddlewareTest do
 
   describe "run/2" do
     test "executes middleware in order" do
-      chain = Middleware.new()
-      |> Middleware.use(fn conn -> Conn.assign(conn, :step1, true) end)
-      |> Middleware.use(fn conn -> Conn.assign(conn, :step2, true) end)
+      chain =
+        Middleware.new()
+        |> Middleware.use(fn conn -> Conn.assign(conn, :step1, true) end)
+        |> Middleware.use(fn conn -> Conn.assign(conn, :step2, true) end)
 
       conn = Conn.new("GET", "/")
       {:ok, result} = Middleware.run(chain, conn)
@@ -45,10 +48,11 @@ defmodule Firebird.Phoenix.MiddlewareTest do
     end
 
     test "halts pipeline when middleware returns {:halt, conn}" do
-      chain = Middleware.new()
-      |> Middleware.use(fn conn -> Conn.assign(conn, :before_halt, true) end)
-      |> Middleware.use(fn conn -> {:halt, Conn.send_resp(conn, 401, "Unauthorized")} end)
-      |> Middleware.use(fn conn -> Conn.assign(conn, :after_halt, true) end)
+      chain =
+        Middleware.new()
+        |> Middleware.use(fn conn -> Conn.assign(conn, :before_halt, true) end)
+        |> Middleware.use(fn conn -> {:halt, Conn.send_resp(conn, 401, "Unauthorized")} end)
+        |> Middleware.use(fn conn -> Conn.assign(conn, :after_halt, true) end)
 
       conn = Conn.new("GET", "/")
       {:halted, result} = Middleware.run(chain, conn)
@@ -60,8 +64,9 @@ defmodule Firebird.Phoenix.MiddlewareTest do
     end
 
     test "returns {:ok, conn} when all middleware completes" do
-      chain = Middleware.new()
-      |> Middleware.use(fn conn -> conn end)
+      chain =
+        Middleware.new()
+        |> Middleware.use(fn conn -> conn end)
 
       {:ok, _result} = Middleware.run(chain, Conn.new("GET", "/"))
     end
@@ -76,8 +81,9 @@ defmodule Firebird.Phoenix.MiddlewareTest do
 
   describe "built-in middleware" do
     test "request_id/0 adds unique request ID" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.request_id())
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.request_id())
 
       {:ok, result} = Middleware.run(chain, Conn.new("GET", "/"))
       assert is_binary(result.assigns[:request_id])
@@ -89,32 +95,36 @@ defmodule Firebird.Phoenix.MiddlewareTest do
     end
 
     test "timer/0 records start time" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.timer())
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.timer())
 
       {:ok, result} = Middleware.run(chain, Conn.new("GET", "/"))
       assert is_integer(result.assigns[:request_start])
     end
 
     test "accept/1 passes matching content type" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.accept("application/json"))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.accept("application/json"))
 
       conn = Conn.new("GET", "/", headers: %{"accept" => "application/json"})
       {:ok, _result} = Middleware.run(chain, conn)
     end
 
     test "accept/1 passes wildcard accept" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.accept("application/json"))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.accept("application/json"))
 
       conn = Conn.new("GET", "/", headers: %{"accept" => "*/*"})
       {:ok, _result} = Middleware.run(chain, conn)
     end
 
     test "accept/1 halts with 406 for wrong content type" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.accept("application/json"))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.accept("application/json"))
 
       conn = Conn.new("GET", "/", headers: %{"accept" => "text/html"})
       {:halted, result} = Middleware.run(chain, conn)
@@ -122,39 +132,44 @@ defmodule Firebird.Phoenix.MiddlewareTest do
     end
 
     test "accept/1 passes when no Accept header" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.accept("application/json"))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.accept("application/json"))
 
       {:ok, _result} = Middleware.run(chain, Conn.new("GET", "/"))
     end
 
     test "require_header/1 passes when header present" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.require_header("authorization"))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.require_header("authorization"))
 
       conn = Conn.new("GET", "/", headers: %{"authorization" => "Bearer token"})
       {:ok, _result} = Middleware.run(chain, conn)
     end
 
     test "require_header/1 halts with 400 when header missing" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.require_header("authorization"))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.require_header("authorization"))
 
       {:halted, result} = Middleware.run(chain, Conn.new("GET", "/"))
       assert result.status == 400
     end
 
     test "default_header/2 sets header if not present" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.default_header("x-powered-by", "Firebird"))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.default_header("x-powered-by", "Firebird"))
 
       {:ok, result} = Middleware.run(chain, Conn.new("GET", "/"))
       assert result.resp_headers["x-powered-by"] == "Firebird"
     end
 
     test "default_header/2 does not override existing header" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.default_header("x-powered-by", "Firebird"))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.default_header("x-powered-by", "Firebird"))
 
       conn = Conn.new("GET", "/") |> Conn.put_resp_header("x-powered-by", "Custom")
       {:ok, result} = Middleware.run(chain, conn)
@@ -162,8 +177,9 @@ defmodule Firebird.Phoenix.MiddlewareTest do
     end
 
     test "logger/0 records request info" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.logger())
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.logger())
 
       {:ok, result} = Middleware.run(chain, Conn.new("POST", "/api/data"))
       assert result.assigns[:log] == "POST /api/data"
@@ -172,12 +188,13 @@ defmodule Firebird.Phoenix.MiddlewareTest do
 
   describe "composing middleware chains" do
     test "full API middleware stack" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.request_id())
-      |> Middleware.use(Middleware.timer())
-      |> Middleware.use(Middleware.logger())
-      |> Middleware.use(Middleware.accept("application/json"))
-      |> Middleware.use(Middleware.default_header("x-powered-by", "Firebird"))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.request_id())
+        |> Middleware.use(Middleware.timer())
+        |> Middleware.use(Middleware.logger())
+        |> Middleware.use(Middleware.accept("application/json"))
+        |> Middleware.use(Middleware.default_header("x-powered-by", "Firebird"))
 
       conn = Conn.new("GET", "/api/users", headers: %{"accept" => "application/json"})
       {:ok, result} = Middleware.run(chain, conn)
@@ -190,9 +207,10 @@ defmodule Firebird.Phoenix.MiddlewareTest do
     end
 
     test "auth middleware halts before business logic" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.require_header("authorization"))
-      |> Middleware.use(fn conn -> Conn.assign(conn, :loaded_data, true) end)
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.require_header("authorization"))
+        |> Middleware.use(fn conn -> Conn.assign(conn, :loaded_data, true) end)
 
       # Without auth
       {:halted, result} = Middleware.run(chain, Conn.new("GET", "/"))
diff --git a/test/phoenix/middleware_wasm_render_test.exs b/test/phoenix/middleware_wasm_render_test.exs
index e2107a0..5beaada 100644
--- a/test/phoenix/middleware_wasm_render_test.exs
+++ b/test/phoenix/middleware_wasm_render_test.exs
@@ -12,14 +12,10 @@ defmodule Firebird.Phoenix.MiddlewareWasmRenderTest do
   alias Firebird.Phoenix.{Middleware, Conn}
 
   @actions %{
-    "UserController.index" => {200, "application/json",
-      ~s([{"id":"1","name":"Alice"}])},
-    "UserController.show" => {200, "application/json",
-      ~s({"id":"{{id}}","name":"User {{id}}"})},
-    "UserController.create" => {201, "application/json",
-      ~s({"status":"created"})},
-    "PageController.index" => {200, "text/html",
-      "<h1>Hello {{name}}</h1>"}
+    "UserController.index" => {200, "application/json", ~s([{"id":"1","name":"Alice"}])},
+    "UserController.show" => {200, "application/json", ~s({"id":"{{id}}","name":"User {{id}}"})},
+    "UserController.create" => {201, "application/json", ~s({"status":"created"})},
+    "PageController.index" => {200, "text/html", "<h1>Hello {{name}}</h1>"}
   }
 
   # ── Structure tests (no WASM instance needed) ───────────
@@ -31,8 +27,9 @@ defmodule Firebird.Phoenix.MiddlewareWasmRenderTest do
     end
 
     test "can be added to a middleware chain" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_render(self(), @actions))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_render(self(), @actions))
 
       assert Middleware.count(chain) == 1
     end
@@ -48,8 +45,9 @@ defmodule Firebird.Phoenix.MiddlewareWasmRenderTest do
   describe "wasm_render/3 when no handler is set" do
     test "skips by default (fallback: :skip)" do
       # Use :fake_instance atom — won't be called for static templates or skip path
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
 
       conn = Conn.new("GET", "/")
       {:ok, result} = Middleware.run(chain, conn)
@@ -60,11 +58,13 @@ defmodule Firebird.Phoenix.MiddlewareWasmRenderTest do
     end
 
     test "halts with 500 when fallback: :halt" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions, fallback: :halt))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions, fallback: :halt))
 
-      conn = Conn.new("GET", "/")
-      |> Conn.assign(:handler, nil)
+      conn =
+        Conn.new("GET", "/")
+        |> Conn.assign(:handler, nil)
 
       {:halted, result} = Middleware.run(chain, conn)
       assert result.status == 500
@@ -76,22 +76,26 @@ defmodule Firebird.Phoenix.MiddlewareWasmRenderTest do
 
   describe "wasm_render/3 with unknown handler" do
     test "skips when handler not in actions (default fallback: :skip)" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
 
-      conn = Conn.new("GET", "/unknown")
-      |> Conn.assign(:handler, "UnknownController.missing")
+      conn =
+        Conn.new("GET", "/unknown")
+        |> Conn.assign(:handler, "UnknownController.missing")
 
       {:ok, result} = Middleware.run(chain, conn)
       assert result.resp_body == nil
     end
 
     test "halts with 500 when handler not in actions (fallback: :halt)" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions, fallback: :halt))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions, fallback: :halt))
 
-      conn = Conn.new("GET", "/unknown")
-      |> Conn.assign(:handler, "UnknownController.missing")
+      conn =
+        Conn.new("GET", "/unknown")
+        |> Conn.assign(:handler, "UnknownController.missing")
 
       {:halted, result} = Middleware.run(chain, conn)
       assert result.status == 500
@@ -103,11 +107,13 @@ defmodule Firebird.Phoenix.MiddlewareWasmRenderTest do
 
   describe "wasm_render/3 with static templates" do
     test "renders static template without variables (no WASM call needed)" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
 
-      conn = Conn.new("GET", "/users")
-      |> Conn.assign(:handler, "UserController.index")
+      conn =
+        Conn.new("GET", "/users")
+        |> Conn.assign(:handler, "UserController.index")
 
       {:ok, result} = Middleware.run(chain, conn)
       assert result.status == 200
@@ -116,11 +122,13 @@ defmodule Firebird.Phoenix.MiddlewareWasmRenderTest do
     end
 
     test "renders static template with 201 status" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
 
-      conn = Conn.new("POST", "/users")
-      |> Conn.assign(:handler, "UserController.create")
+      conn =
+        Conn.new("POST", "/users")
+        |> Conn.assign(:handler, "UserController.create")
 
       {:ok, result} = Middleware.run(chain, conn)
       assert result.status == 201
@@ -134,12 +142,14 @@ defmodule Firebird.Phoenix.MiddlewareWasmRenderTest do
     test "renders {{var}} templates using Elixir fallback when WASM unavailable" do
       # Using :fake_instance — Template.render will fail,
       # triggering the Elixir fallback path
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
 
-      conn = Conn.new("GET", "/users/42")
-      |> Conn.assign(:handler, "UserController.show")
-      |> Conn.merge_params(%{"id" => "42"})
+      conn =
+        Conn.new("GET", "/users/42")
+        |> Conn.assign(:handler, "UserController.show")
+        |> Conn.merge_params(%{"id" => "42"})
 
       {:ok, result} = Middleware.run(chain, conn)
       assert result.status == 200
@@ -148,12 +158,14 @@ defmodule Firebird.Phoenix.MiddlewareWasmRenderTest do
     end
 
     test "renders HTML template with Elixir fallback" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
 
-      conn = Conn.new("GET", "/")
-      |> Conn.assign(:handler, "PageController.index")
-      |> Conn.merge_params(%{"name" => "World"})
+      conn =
+        Conn.new("GET", "/")
+        |> Conn.assign(:handler, "PageController.index")
+        |> Conn.merge_params(%{"name" => "World"})
 
       {:ok, result} = Middleware.run(chain, conn)
       assert result.status == 200
@@ -163,16 +175,17 @@ defmodule Firebird.Phoenix.MiddlewareWasmRenderTest do
 
     test "handles multiple params in template" do
       actions = %{
-        "ProfileController.show" => {200, "text/html",
-          "<h1>{{name}}</h1><p>Age: {{age}}</p>"}
+        "ProfileController.show" => {200, "text/html", "<h1>{{name}}</h1><p>Age: {{age}}</p>"}
       }
 
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_render(:fake_instance, actions))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_render(:fake_instance, actions))
 
-      conn = Conn.new("GET", "/profile")
-      |> Conn.assign(:handler, "ProfileController.show")
-      |> Conn.merge_params(%{"name" => "Alice", "age" => "30"})
+      conn =
+        Conn.new("GET", "/profile")
+        |> Conn.assign(:handler, "ProfileController.show")
+        |> Conn.merge_params(%{"name" => "Alice", "age" => "30"})
 
       {:ok, result} = Middleware.run(chain, conn)
       assert result.resp_body == "<h1>Alice</h1><p>Age: 30</p>"
@@ -183,12 +196,14 @@ defmodule Firebird.Phoenix.MiddlewareWasmRenderTest do
         "Test.action" => {200, "text/plain", "id={{id}}"}
       }
 
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_render(:fake_instance, actions))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_render(:fake_instance, actions))
 
-      conn = Conn.new("GET", "/")
-      |> Conn.assign(:handler, "Test.action")
-      |> Conn.merge_params(%{id: 99})
+      conn =
+        Conn.new("GET", "/")
+        |> Conn.assign(:handler, "Test.action")
+        |> Conn.merge_params(%{id: 99})
 
       {:ok, result} = Middleware.run(chain, conn)
       assert result.resp_body == "id=99"
@@ -199,33 +214,37 @@ defmodule Firebird.Phoenix.MiddlewareWasmRenderTest do
 
   describe "wasm_render/3 composes with other middleware" do
     test "composes with wasm_route in a full pipeline" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.request_id())
-      |> Middleware.use(Middleware.timer())
-      |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.request_id())
+        |> Middleware.use(Middleware.timer())
+        |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
 
       assert Middleware.count(chain) == 3
     end
 
     test "wasm_route + wasm_render pipeline structure" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.request_id())
-      |> Middleware.use(Middleware.timer())
-      |> Middleware.use(Middleware.wasm_route(:fake_instance))
-      |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
-      |> Middleware.use(Middleware.logger())
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.request_id())
+        |> Middleware.use(Middleware.timer())
+        |> Middleware.use(Middleware.wasm_route(:fake_instance))
+        |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
+        |> Middleware.use(Middleware.logger())
 
       assert Middleware.count(chain) == 5
     end
 
     test "render middleware preserves previous assigns" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.request_id())
-      |> Middleware.use(Middleware.timer())
-      |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.request_id())
+        |> Middleware.use(Middleware.timer())
+        |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
 
-      conn = Conn.new("GET", "/users")
-      |> Conn.assign(:handler, "UserController.index")
+      conn =
+        Conn.new("GET", "/users")
+        |> Conn.assign(:handler, "UserController.index")
 
       {:ok, result} = Middleware.run(chain, conn)
       assert result.assigns[:request_id]
@@ -235,12 +254,16 @@ defmodule Firebird.Phoenix.MiddlewareWasmRenderTest do
     end
 
     test "render middleware does not run after halted pipeline" do
-      chain = Middleware.new()
-      |> Middleware.use(fn _conn -> {:halt, Conn.send_resp(Conn.new("GET", "/"), 401, "Unauthorized")} end)
-      |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
+      chain =
+        Middleware.new()
+        |> Middleware.use(fn _conn ->
+          {:halt, Conn.send_resp(Conn.new("GET", "/"), 401, "Unauthorized")}
+        end)
+        |> Middleware.use(Middleware.wasm_render(:fake_instance, @actions))
 
-      conn = Conn.new("GET", "/users")
-      |> Conn.assign(:handler, "UserController.index")
+      conn =
+        Conn.new("GET", "/users")
+        |> Conn.assign(:handler, "UserController.index")
 
       {:halted, result} = Middleware.run(chain, conn)
       assert result.status == 401
@@ -270,12 +293,14 @@ defmodule Firebird.Phoenix.MiddlewareWasmRenderTest do
 
     @tag :wasm_integration
     test "renders template with WASM engine", %{instance: instance} do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_render(instance, @actions))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_render(instance, @actions))
 
-      conn = Conn.new("GET", "/users/7")
-      |> Conn.assign(:handler, "UserController.show")
-      |> Conn.merge_params(%{"id" => "7"})
+      conn =
+        Conn.new("GET", "/users/7")
+        |> Conn.assign(:handler, "UserController.show")
+        |> Conn.merge_params(%{"id" => "7"})
 
       {:ok, result} = Middleware.run(chain, conn)
       assert result.status == 200
@@ -288,12 +313,14 @@ defmodule Firebird.Phoenix.MiddlewareWasmRenderTest do
         "Page.show" => {200, "text/html", "<p>{{content}}</p>"}
       }
 
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_render(instance, actions))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_render(instance, actions))
 
-      conn = Conn.new("GET", "/page")
-      |> Conn.assign(:handler, "Page.show")
-      |> Conn.merge_params(%{"content" => "<script>alert('xss')</script>"})
+      conn =
+        Conn.new("GET", "/page")
+        |> Conn.assign(:handler, "Page.show")
+        |> Conn.merge_params(%{"content" => "<script>alert('xss')</script>"})
 
       {:ok, result} = Middleware.run(chain, conn)
       assert result.status == 200
diff --git a/test/phoenix/middleware_wasm_test.exs b/test/phoenix/middleware_wasm_test.exs
index 98afc7d..a0d7c47 100644
--- a/test/phoenix/middleware_wasm_test.exs
+++ b/test/phoenix/middleware_wasm_test.exs
@@ -18,8 +18,9 @@ defmodule Firebird.Phoenix.MiddlewareWasmTest do
   describe "wasm_csrf/2" do
     test "skips safe methods (GET, HEAD, OPTIONS)" do
       # wasm_csrf should not check GET requests regardless of tokens
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_csrf(self()))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_csrf(self()))
 
       for method <- ["GET", "HEAD", "OPTIONS"] do
         conn = Conn.new(method, "/")
@@ -29,11 +30,13 @@ defmodule Firebird.Phoenix.MiddlewareWasmTest do
     end
 
     test "halts with 403 when CSRF token header is missing" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_csrf(self()))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_csrf(self()))
 
-      conn = Conn.new("POST", "/api/data")
-      |> Conn.assign(:csrf_token, "expected_token")
+      conn =
+        Conn.new("POST", "/api/data")
+        |> Conn.assign(:csrf_token, "expected_token")
 
       {:halted, result} = Middleware.run(chain, conn)
       assert result.status == 403
@@ -41,11 +44,13 @@ defmodule Firebird.Phoenix.MiddlewareWasmTest do
     end
 
     test "halts with 403 when expected token is not in assigns" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_csrf(self()))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_csrf(self()))
 
-      conn = Conn.new("POST", "/api/data")
-      |> Conn.put_req_header("x-csrf-token", "some_token")
+      conn =
+        Conn.new("POST", "/api/data")
+        |> Conn.put_req_header("x-csrf-token", "some_token")
 
       {:halted, result} = Middleware.run(chain, conn)
       assert result.status == 403
@@ -53,24 +58,28 @@ defmodule Firebird.Phoenix.MiddlewareWasmTest do
     end
 
     test "checks custom header name via :header option" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_csrf(self(), header: "x-my-csrf"))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_csrf(self(), header: "x-my-csrf"))
 
       # Missing custom header should halt
-      conn = Conn.new("POST", "/api/data")
-      |> Conn.assign(:csrf_token, "token123")
+      conn =
+        Conn.new("POST", "/api/data")
+        |> Conn.assign(:csrf_token, "token123")
 
       {:halted, result} = Middleware.run(chain, conn)
       assert result.status == 403
     end
 
     test "checks custom assign key via :assign option" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_csrf(self(), assign: :my_token))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_csrf(self(), assign: :my_token))
 
       # Token in header but no :my_token assign
-      conn = Conn.new("POST", "/api/data")
-      |> Conn.put_req_header("x-csrf-token", "token123")
+      conn =
+        Conn.new("POST", "/api/data")
+        |> Conn.put_req_header("x-csrf-token", "token123")
 
       {:halted, result} = Middleware.run(chain, conn)
       assert result.status == 403
@@ -78,16 +87,18 @@ defmodule Firebird.Phoenix.MiddlewareWasmTest do
     end
 
     test "only checks configured methods via :methods option" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_csrf(self(), methods: ["DELETE"]))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_csrf(self(), methods: ["DELETE"]))
 
       # POST should pass through without checking
       conn = Conn.new("POST", "/api/data")
       {:ok, _result} = Middleware.run(chain, conn)
 
       # DELETE without token should halt
-      conn = Conn.new("DELETE", "/api/data")
-      |> Conn.assign(:csrf_token, "expected")
+      conn =
+        Conn.new("DELETE", "/api/data")
+        |> Conn.assign(:csrf_token, "expected")
 
       {:halted, result} = Middleware.run(chain, conn)
       assert result.status == 403
@@ -103,8 +114,9 @@ defmodule Firebird.Phoenix.MiddlewareWasmTest do
     end
 
     test "middleware can be added to chain" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_negotiate(self(), ["text/html"]))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_negotiate(self(), ["text/html"]))
 
       assert Middleware.count(chain) == 1
     end
@@ -119,8 +131,9 @@ defmodule Firebird.Phoenix.MiddlewareWasmTest do
     end
 
     test "middleware can be added to chain" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_fetch_query_params(self()))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_fetch_query_params(self()))
 
       assert Middleware.count(chain) == 1
     end
@@ -128,8 +141,9 @@ defmodule Firebird.Phoenix.MiddlewareWasmTest do
     test "conn with empty query string passes through unchanged" do
       # Conn.fetch_query_params is a no-op for empty query strings,
       # so this should work without a real WASM instance
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_fetch_query_params(self()))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_fetch_query_params(self()))
 
       conn = Conn.new("GET", "/search")
       {:ok, result} = Middleware.run(chain, conn)
@@ -147,35 +161,41 @@ defmodule Firebird.Phoenix.MiddlewareWasmTest do
 
     test "skips non-HTML content types" do
       # Should pass through without calling WASM for non-HTML responses
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_html_escape(self()))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_html_escape(self()))
 
-      conn = Conn.new("GET", "/")
-      |> Conn.put_resp_header("content-type", "application/json")
-      |> Conn.put_resp_body(~s({"key": "value"}))
+      conn =
+        Conn.new("GET", "/")
+        |> Conn.put_resp_header("content-type", "application/json")
+        |> Conn.put_resp_body(~s({"key": "value"}))
 
       {:ok, result} = Middleware.run(chain, conn)
       assert result.resp_body == ~s({"key": "value"})
     end
 
     test "skips when response body is nil" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_html_escape(self()))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_html_escape(self()))
 
-      conn = Conn.new("GET", "/")
-      |> Conn.put_resp_header("content-type", "text/html")
+      conn =
+        Conn.new("GET", "/")
+        |> Conn.put_resp_header("content-type", "text/html")
 
       {:ok, result} = Middleware.run(chain, conn)
       assert result.resp_body == nil
     end
 
     test "skips when response body is empty" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_html_escape(self()))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_html_escape(self()))
 
-      conn = Conn.new("GET", "/")
-      |> Conn.put_resp_header("content-type", "text/html")
-      |> Conn.put_resp_body("")
+      conn =
+        Conn.new("GET", "/")
+        |> Conn.put_resp_header("content-type", "text/html")
+        |> Conn.put_resp_body("")
 
       {:ok, result} = Middleware.run(chain, conn)
       assert result.resp_body == ""
@@ -196,8 +216,9 @@ defmodule Firebird.Phoenix.MiddlewareWasmTest do
     end
 
     test "middleware can be added to chain" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_route(self()))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_route(self()))
 
       assert Middleware.count(chain) == 1
     end
@@ -207,11 +228,12 @@ defmodule Firebird.Phoenix.MiddlewareWasmTest do
 
   describe "WASM middleware composition" do
     test "WASM middleware composes with built-in middleware" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.request_id())
-      |> Middleware.use(Middleware.timer())
-      |> Middleware.use(Middleware.wasm_csrf(self()))
-      |> Middleware.use(Middleware.logger())
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.request_id())
+        |> Middleware.use(Middleware.timer())
+        |> Middleware.use(Middleware.wasm_csrf(self()))
+        |> Middleware.use(Middleware.logger())
 
       assert Middleware.count(chain) == 4
 
@@ -225,29 +247,34 @@ defmodule Firebird.Phoenix.MiddlewareWasmTest do
     end
 
     test "WASM CSRF middleware halts before subsequent middleware" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.timer())
-      |> Middleware.use(Middleware.wasm_csrf(self()))
-      |> Middleware.use(Middleware.logger())
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.timer())
+        |> Middleware.use(Middleware.wasm_csrf(self()))
+        |> Middleware.use(Middleware.logger())
 
       # POST without CSRF token should halt before logger
-      conn = Conn.new("POST", "/api/data")
-      |> Conn.assign(:csrf_token, "expected")
+      conn =
+        Conn.new("POST", "/api/data")
+        |> Conn.assign(:csrf_token, "expected")
 
       {:halted, result} = Middleware.run(chain, conn)
 
-      assert result.assigns[:request_start]  # timer ran
-      refute result.assigns[:log]            # logger did NOT run
+      # timer ran
+      assert result.assigns[:request_start]
+      # logger did NOT run
+      refute result.assigns[:log]
       assert result.status == 403
     end
 
     test "multiple WASM middleware can be chained" do
-      chain = Middleware.new()
-      |> Middleware.use(Middleware.wasm_fetch_query_params(self()))
-      |> Middleware.use(Middleware.wasm_negotiate(self(), ["application/json"]))
-      |> Middleware.use(Middleware.wasm_csrf(self()))
-      |> Middleware.use(Middleware.wasm_route(self()))
-      |> Middleware.use(Middleware.wasm_html_escape(self()))
+      chain =
+        Middleware.new()
+        |> Middleware.use(Middleware.wasm_fetch_query_params(self()))
+        |> Middleware.use(Middleware.wasm_negotiate(self(), ["application/json"]))
+        |> Middleware.use(Middleware.wasm_csrf(self()))
+        |> Middleware.use(Middleware.wasm_route(self()))
+        |> Middleware.use(Middleware.wasm_html_escape(self()))
 
       assert Middleware.count(chain) == 5
     end
diff --git a/test/phoenix/multiline_template_test.exs b/test/phoenix/multiline_template_test.exs
index 9b1cdb0..23ea794 100644
--- a/test/phoenix/multiline_template_test.exs
+++ b/test/phoenix/multiline_template_test.exs
@@ -25,11 +25,12 @@ defmodule Firebird.Phoenix.MultilineTemplateTest do
       </html>
       """
 
-      {:ok, html} = Template.render(template, tmpl, %{
-        "title" => "Test Page",
-        "heading" => "Welcome",
-        "content" => "Hello World"
-      })
+      {:ok, html} =
+        Template.render(template, tmpl, %{
+          "title" => "Test Page",
+          "heading" => "Welcome",
+          "content" => "Hello World"
+        })
 
       assert html =~ "Test Page"
       assert html =~ "Welcome"
@@ -45,10 +46,12 @@ defmodule Firebird.Phoenix.MultilineTemplateTest do
       """
 
       {:ok, wasm_tmpl} = EExCompiler.compile(eex)
-      {:ok, html} = Template.render(template, wasm_tmpl, %{
-        "title" => "My Post",
-        "author" => "Alice"
-      })
+
+      {:ok, html} =
+        Template.render(template, wasm_tmpl, %{
+          "title" => "My Post",
+          "author" => "Alice"
+        })
 
       assert html =~ "My Post"
       assert html =~ "Alice"
@@ -63,11 +66,12 @@ defmodule Firebird.Phoenix.MultilineTemplateTest do
       </div>
       """
 
-      {:ok, html} = Template.render(template, tmpl, %{
-        "header" => "Title",
-        "body" => "Content",
-        "footer" => "Footer"
-      })
+      {:ok, html} =
+        Template.render(template, tmpl, %{
+          "header" => "Title",
+          "body" => "Content",
+          "footer" => "Footer"
+        })
 
       assert html =~ ~s(class="card-header")
       assert html =~ "Title"
@@ -87,9 +91,10 @@ defmodule Firebird.Phoenix.MultilineTemplateTest do
       </html>
       """
 
-      {:ok, html} = Template.render(template, layout, %{
-        "inner_content" => "<h1>Page Content</h1>"
-      })
+      {:ok, html} =
+        Template.render(template, layout, %{
+          "inner_content" => "<h1>Page Content</h1>"
+        })
 
       assert html =~ "Navigation"
       assert html =~ "Page Content"
diff --git a/test/phoenix/phoenix_app_wasm_test.exs b/test/phoenix/phoenix_app_wasm_test.exs
index 7a8e1ce..a080b8b 100644
--- a/test/phoenix/phoenix_app_wasm_test.exs
+++ b/test/phoenix/phoenix_app_wasm_test.exs
@@ -21,9 +21,20 @@ defmodule Firebird.Phoenix.PhoenixAppWasmTest do
   use ExUnit.Case, async: false
 
   alias Firebird.Phoenix.{
-    Server, Router, Template, Plug, Endpoint,
-    JSON, Session, Controller, View, Validator,
-    FormWasm, CsrfWasm, RateLimiterWasm, WebSocketWasm
+    Server,
+    Router,
+    Template,
+    Plug,
+    Endpoint,
+    JSON,
+    Session,
+    Controller,
+    View,
+    Validator,
+    FormWasm,
+    CsrfWasm,
+    RateLimiterWasm,
+    WebSocketWasm
   }
 
   @fixtures_dir Path.join(__DIR__, "../../fixtures")
@@ -43,30 +54,33 @@ defmodule Firebird.Phoenix.PhoenixAppWasmTest do
     {"DELETE", "/api/v1/posts/:id", "PostController.delete"},
     {"GET", "/api/v1/posts/:post_id/comments", "CommentController.index"},
     {"GET", "/api/v1/posts/:post_id/comments/:id", "CommentController.show"},
-    {"GET", "/api/v1/health", "HealthController.index"},
+    {"GET", "/api/v1/health", "HealthController.index"}
   ]
 
   @app_actions %{
-    "PageController.index" => {200, "text/html",
-      "<html><head><title>Blog</title></head><body><h1>My Blog</h1></body></html>"},
-    "SessionController.new" => {200, "text/html",
-      "<html><body><h1>Login</h1><form method='post'><input name='email'/></form></body></html>"},
+    "PageController.index" =>
+      {200, "text/html",
+       "<html><head><title>Blog</title></head><body><h1>My Blog</h1></body></html>"},
+    "SessionController.new" =>
+      {200, "text/html",
+       "<html><body><h1>Login</h1><form method='post'><input name='email'/></form></body></html>"},
     "SessionController.create" => {302, "text/html", ""},
-    "PostController.index" => {200, "application/json",
-      ~s([{"id":1,"title":"Hello WASM","body":"First post"},{"id":2,"title":"Phoenix","body":"Framework"}])},
-    "PostController.show" => {200, "application/json",
-      ~s({"id":"{{id}}","title":"Post {{id}}","body":"Content of post {{id}}"})},
-    "PostController.create" => {201, "application/json",
-      ~s({"id":"3","title":"New Post","status":"created"})},
-    "PostController.update" => {200, "application/json",
-      ~s({"id":"{{id}}","status":"updated"})},
+    "PostController.index" =>
+      {200, "application/json",
+       ~s([{"id":1,"title":"Hello WASM","body":"First post"},{"id":2,"title":"Phoenix","body":"Framework"}])},
+    "PostController.show" =>
+      {200, "application/json",
+       ~s({"id":"{{id}}","title":"Post {{id}}","body":"Content of post {{id}}"})},
+    "PostController.create" =>
+      {201, "application/json", ~s({"id":"3","title":"New Post","status":"created"})},
+    "PostController.update" => {200, "application/json", ~s({"id":"{{id}}","status":"updated"})},
     "PostController.delete" => {204, "application/json", ""},
-    "CommentController.index" => {200, "application/json",
-      ~s([{"id":1,"post_id":"{{post_id}}","body":"Great!"}])},
-    "CommentController.show" => {200, "application/json",
-      ~s({"id":"{{id}}","post_id":"{{post_id}}","body":"Comment body"})},
-    "HealthController.index" => {200, "application/json",
-      ~s({"status":"healthy","version":"1.0","wasm":true})},
+    "CommentController.index" =>
+      {200, "application/json", ~s([{"id":1,"post_id":"{{post_id}}","body":"Great!"}])},
+    "CommentController.show" =>
+      {200, "application/json", ~s({"id":"{{id}}","post_id":"{{post_id}}","body":"Comment body"})},
+    "HealthController.index" =>
+      {200, "application/json", ~s({"status":"healthy","version":"1.0","wasm":true})}
   }
 
   # ═══════════════════════════════════════════════════════════
@@ -75,11 +89,12 @@ defmodule Firebird.Phoenix.PhoenixAppWasmTest do
 
   describe "Phoenix WASM blog application" do
     setup do
-      {:ok, server} = Server.start_link(
-        port: 0,
-        routes: @app_routes,
-        actions: @app_actions
-      )
+      {:ok, server} =
+        Server.start_link(
+          port: 0,
+          routes: @app_routes,
+          actions: @app_actions
+        )
 
       on_exit(fn -> if Process.alive?(server), do: Server.stop(server) end)
       %{server: server}
@@ -182,18 +197,20 @@ defmodule Firebird.Phoenix.PhoenixAppWasmTest do
         form: "phoenix_form.wasm",
         csrf: "phoenix_csrf.wasm",
         rate_limiter: "phoenix_rate_limiter.wasm",
-        websocket: "phoenix_websocket.wasm",
+        websocket: "phoenix_websocket.wasm"
       }
 
-      loaded = Enum.reduce(components, %{}, fn {key, file}, acc ->
-        path = Path.join(@fixtures_dir, file)
-        if File.exists?(path) do
-          {:ok, pid} = Firebird.load(path)
-          Map.put(acc, key, pid)
-        else
-          acc
-        end
-      end)
+      loaded =
+        Enum.reduce(components, %{}, fn {key, file}, acc ->
+          path = Path.join(@fixtures_dir, file)
+
+          if File.exists?(path) do
+            {:ok, pid} = Firebird.load(path)
+            Map.put(acc, key, pid)
+          else
+            acc
+          end
+        end)
 
       on_exit(fn ->
         for {_, pid} <- loaded, is_pid(pid) and Process.alive?(pid) do
@@ -206,7 +223,9 @@ defmodule Firebird.Phoenix.PhoenixAppWasmTest do
 
     test "full request pipeline: parse → route → validate → render", ctx do
       # 1. Parse request
-      raw = "POST /api/v1/posts HTTP/1.1\r\nHost: localhost\r\nContent-Type: application/json\r\n\r\n"
+      raw =
+        "POST /api/v1/posts HTTP/1.1\r\nHost: localhost\r\nContent-Type: application/json\r\n\r\n"
+
       {:ok, req} = Plug.parse_request(ctx.plug, raw)
       assert req.method == "POST"
 
@@ -216,12 +235,15 @@ defmodule Firebird.Phoenix.PhoenixAppWasmTest do
       assert match.params["id"] == "42"
 
       # 3. Validate params
-      {:ok, :valid} = Controller.validate_params(ctx.controller, match.params, [
-        {"id", "required"}
-      ])
+      {:ok, :valid} =
+        Controller.validate_params(ctx.controller, match.params, [
+          {"id", "required"}
+        ])
 
       # 4. Render JSON response
-      {:ok, json} = JSON.encode_object(ctx.json, %{"id" => match.params["id"], "title" => "Post 42"})
+      {:ok, json} =
+        JSON.encode_object(ctx.json, %{"id" => match.params["id"], "title" => "Post 42"})
+
       assert json =~ "42"
       assert json =~ "Post 42"
 
@@ -236,12 +258,17 @@ defmodule Firebird.Phoenix.PhoenixAppWasmTest do
       {:ok, token} = CsrfWasm.generate_token(ctx.csrf, "blog_secret")
 
       # Build login form
-      {:ok, form} = FormWasm.build_form(ctx.form, "session", "/login",
-        method: :post, csrf_token: token)
-      {:ok, email} = FormWasm.email_input(ctx.form, "session", "email",
-        placeholder: "Email", required: true)
-      {:ok, pass} = FormWasm.password_input(ctx.form, "session", "password",
-        placeholder: "Password", required: true)
+      {:ok, form} =
+        FormWasm.build_form(ctx.form, "session", "/login", method: :post, csrf_token: token)
+
+      {:ok, email} =
+        FormWasm.email_input(ctx.form, "session", "email", placeholder: "Email", required: true)
+
+      {:ok, pass} =
+        FormWasm.password_input(ctx.form, "session", "password",
+          placeholder: "Password",
+          required: true
+        )
 
       full_form = form <> email <> pass <> ~s(<button type="submit">Login</button></form>)
 
@@ -269,7 +296,9 @@ defmodule Firebird.Phoenix.PhoenixAppWasmTest do
 
     test "WebSocket upgrade flow", ctx do
       # Check if request is upgrade
-      headers = "Upgrade: websocket\nConnection: Upgrade\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ=="
+      headers =
+        "Upgrade: websocket\nConnection: Upgrade\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ=="
+
       {:ok, true, key} = WebSocketWasm.is_upgrade?(ctx.websocket, headers)
 
       # Generate upgrade response
@@ -277,15 +306,26 @@ defmodule Firebird.Phoenix.PhoenixAppWasmTest do
       assert response =~ "101 Switching Protocols"
 
       # Encode a Channel join message
-      {:ok, json} = WebSocketWasm.serialize_channel_msg(
-        ctx.websocket, "1", "1", "posts:lobby", "phx_join", "{}")
+      {:ok, json} =
+        WebSocketWasm.serialize_channel_msg(
+          ctx.websocket,
+          "1",
+          "1",
+          "posts:lobby",
+          "phx_join",
+          "{}"
+        )
+
       assert json =~ "posts:lobby"
       assert json =~ "phx_join"
     end
 
     test "session cookie handling", ctx do
-      {:ok, cookies} = Session.parse_cookies(ctx.session,
-        "session_id=xyz789; user_id=42; _csrf_token=abc")
+      {:ok, cookies} =
+        Session.parse_cookies(
+          ctx.session,
+          "session_id=xyz789; user_id=42; _csrf_token=abc"
+        )
 
       assert cookies["session_id"] == "xyz789"
       assert cookies["user_id"] == "42"
@@ -304,9 +344,11 @@ defmodule Firebird.Phoenix.PhoenixAppWasmTest do
     end
 
     test "validation rejects invalid data", ctx do
-      {:ok, result} = Validator.validate(ctx.validator, %{"email" => ""}, [
-        {:required, "email"}
-      ])
+      {:ok, result} =
+        Validator.validate(ctx.validator, %{"email" => ""}, [
+          {:required, "email"}
+        ])
+
       assert result != :valid
     end
   end
diff --git a/test/phoenix/phoenix_extended_test.exs b/test/phoenix/phoenix_extended_test.exs
index 2cca0f0..3bf4786 100644
--- a/test/phoenix/phoenix_extended_test.exs
+++ b/test/phoenix/phoenix_extended_test.exs
@@ -41,12 +41,13 @@ defmodule Firebird.Phoenix.ExtendedTest do
     test "uses router when no endpoint available" do
       {:ok, components} = Firebird.Phoenix.start(only: [:router])
 
-      {:ok, resp} = Firebird.Phoenix.process_request(components,
-        method: "GET",
-        path: "/users/42",
-        routes: [{"GET", "/users/:id", "User.show"}],
-        actions: %{"User.show" => {200, "application/json", ~s({"id":"{{id}}"})}}
-      )
+      {:ok, resp} =
+        Firebird.Phoenix.process_request(components,
+          method: "GET",
+          path: "/users/42",
+          routes: [{"GET", "/users/:id", "User.show"}],
+          actions: %{"User.show" => {200, "application/json", ~s({"id":"{{id}}"})}}
+        )
 
       assert resp.status == 200
       assert resp.body =~ "42"
@@ -56,12 +57,13 @@ defmodule Firebird.Phoenix.ExtendedTest do
     test "returns 404 from router fallback for unmatched" do
       {:ok, components} = Firebird.Phoenix.start(only: [:router])
 
-      {:ok, resp} = Firebird.Phoenix.process_request(components,
-        method: "GET",
-        path: "/missing",
-        routes: [{"GET", "/users", "User.index"}],
-        actions: %{"User.index" => {200, "text/plain", "users"}}
-      )
+      {:ok, resp} =
+        Firebird.Phoenix.process_request(components,
+          method: "GET",
+          path: "/missing",
+          routes: [{"GET", "/users", "User.index"}],
+          actions: %{"User.index" => {200, "text/plain", "users"}}
+        )
 
       assert resp.status == 404
       Firebird.Phoenix.stop(components)
@@ -70,12 +72,13 @@ defmodule Firebird.Phoenix.ExtendedTest do
     test "returns error for no action handler" do
       {:ok, components} = Firebird.Phoenix.start(only: [:router])
 
-      result = Firebird.Phoenix.process_request(components,
-        method: "GET",
-        path: "/users",
-        routes: [{"GET", "/users", "User.index"}],
-        actions: %{}
-      )
+      result =
+        Firebird.Phoenix.process_request(components,
+          method: "GET",
+          path: "/users",
+          routes: [{"GET", "/users", "User.index"}],
+          actions: %{}
+        )
 
       assert match?({:error, :no_action_for_handler}, result)
       Firebird.Phoenix.stop(components)
@@ -84,11 +87,12 @@ defmodule Firebird.Phoenix.ExtendedTest do
 
   describe "process_request/2 - no components" do
     test "returns error when no router or endpoint" do
-      result = Firebird.Phoenix.process_request(%{},
-        method: "GET",
-        path: "/",
-        routes: []
-      )
+      result =
+        Firebird.Phoenix.process_request(%{},
+          method: "GET",
+          path: "/",
+          routes: []
+        )
 
       assert match?({:error, :no_endpoint_or_router}, result)
     end
@@ -101,12 +105,13 @@ defmodule Firebird.Phoenix.ExtendedTest do
       routes = [{"GET", "/users/:id", "User.show"}]
       actions = %{"User.show" => {200, "application/json", ~s({"id":"{{id}}"})}}
 
-      {:ok, resp} = Firebird.Phoenix.process_request(components,
-        method: "GET",
-        path: "/users/42",
-        routes: routes,
-        actions: actions
-      )
+      {:ok, resp} =
+        Firebird.Phoenix.process_request(components,
+          method: "GET",
+          path: "/users/42",
+          routes: routes,
+          actions: actions
+        )
 
       assert resp.status == 200
       Firebird.Phoenix.stop(components)
@@ -115,13 +120,14 @@ defmodule Firebird.Phoenix.ExtendedTest do
     test "dispatches with headers" do
       {:ok, components} = Firebird.Phoenix.start(only: [:endpoint])
 
-      {:ok, resp} = Firebird.Phoenix.process_request(components,
-        method: "GET",
-        path: "/users",
-        headers: %{"accept" => "application/json"},
-        routes: [{"GET", "/users", "User.index"}],
-        actions: %{"User.index" => {200, "application/json", "[]"}}
-      )
+      {:ok, resp} =
+        Firebird.Phoenix.process_request(components,
+          method: "GET",
+          path: "/users",
+          headers: %{"accept" => "application/json"},
+          routes: [{"GET", "/users", "User.index"}],
+          actions: %{"User.index" => {200, "application/json", "[]"}}
+        )
 
       assert resp.status == 200
       Firebird.Phoenix.stop(components)
@@ -172,12 +178,13 @@ defmodule Firebird.Phoenix.ExtendedTest do
     test "process_request parses complete HTTP response" do
       {:ok, components} = Firebird.Phoenix.start(only: [:endpoint])
 
-      {:ok, resp} = Firebird.Phoenix.process_request(components,
-        method: "GET",
-        path: "/test",
-        routes: [{"GET", "/test", "Test.index"}],
-        actions: %{"Test.index" => {200, "text/html", "<h1>Hello</h1>"}}
-      )
+      {:ok, resp} =
+        Firebird.Phoenix.process_request(components,
+          method: "GET",
+          path: "/test",
+          routes: [{"GET", "/test", "Test.index"}],
+          actions: %{"Test.index" => {200, "text/html", "<h1>Hello</h1>"}}
+        )
 
       assert is_map(resp)
       assert resp.status == 200
diff --git a/test/phoenix/phoenix_lifecycle_test.exs b/test/phoenix/phoenix_lifecycle_test.exs
index ba7fc24..b9eedbb 100644
--- a/test/phoenix/phoenix_lifecycle_test.exs
+++ b/test/phoenix/phoenix_lifecycle_test.exs
@@ -18,9 +18,11 @@ defmodule Firebird.Phoenix.LifecycleTest do
   describe "full HTTP lifecycle" do
     test "GET request → route → render → response", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.route("GET", "/", "Page.index")
-      |> RequestHandler.template("Page.index", 200, "text/html", "<h1>Welcome</h1>")
+
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/", "Page.index")
+        |> RequestHandler.template("Page.index", 200, "text/html", "<h1>Welcome</h1>")
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/")
       assert conn.status == 200
@@ -29,24 +31,33 @@ defmodule Firebird.Phoenix.LifecycleTest do
 
     test "POST request with body → route → action → response", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.route("POST", "/api/items", "Item.create")
-      |> RequestHandler.action("Item.create", fn _params ->
-        {201, "application/json", ~s({"status":"created","id":"new-uuid"})}
-      end)
-
-      {:ok, conn} = RequestHandler.handle(handler, "POST", "/api/items",
-        body: ~s({"name":"Widget"}))
+
+      handler =
+        handler
+        |> RequestHandler.route("POST", "/api/items", "Item.create")
+        |> RequestHandler.action("Item.create", fn _params ->
+          {201, "application/json", ~s({"status":"created","id":"new-uuid"})}
+        end)
+
+      {:ok, conn} =
+        RequestHandler.handle(handler, "POST", "/api/items", body: ~s({"name":"Widget"}))
+
       assert conn.status == 201
       assert conn.resp_body =~ "created"
     end
 
     test "parameterized route → template rendering", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.route("GET", "/users/:id", "User.show")
-      |> RequestHandler.template("User.show", 200, "application/json",
-          ~s({"id":"{{id}}","type":"user"}))
+
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/users/:id", "User.show")
+        |> RequestHandler.template(
+          "User.show",
+          200,
+          "application/json",
+          ~s({"id":"{{id}}","type":"user"})
+        )
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/users/42")
       assert conn.status == 200
@@ -56,13 +67,15 @@ defmodule Firebird.Phoenix.LifecycleTest do
 
     test "middleware → routing → response", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.use_middleware(Middleware.request_id())
-      |> RequestHandler.use_middleware(Middleware.timer())
-      |> RequestHandler.route("GET", "/api/status", "Status.check")
-      |> RequestHandler.action("Status.check", fn _params ->
-        {200, "application/json", ~s({"status":"healthy"})}
-      end)
+
+      handler =
+        handler
+        |> RequestHandler.use_middleware(Middleware.request_id())
+        |> RequestHandler.use_middleware(Middleware.timer())
+        |> RequestHandler.route("GET", "/api/status", "Status.check")
+        |> RequestHandler.action("Status.check", fn _params ->
+          {200, "application/json", ~s({"status":"healthy"})}
+        end)
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/api/status")
       assert conn.status == 200
@@ -72,10 +85,12 @@ defmodule Firebird.Phoenix.LifecycleTest do
 
     test "auth middleware blocks unauthorized requests", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.use_middleware(Middleware.require_header("authorization"))
-      |> RequestHandler.route("GET", "/api/secret", "Secret.show")
-      |> RequestHandler.template("Secret.show", 200, "text/plain", "top secret")
+
+      handler =
+        handler
+        |> RequestHandler.use_middleware(Middleware.require_header("authorization"))
+        |> RequestHandler.route("GET", "/api/secret", "Secret.show")
+        |> RequestHandler.template("Secret.show", 200, "text/plain", "top secret")
 
       # Without auth
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/api/secret")
@@ -83,8 +98,11 @@ defmodule Firebird.Phoenix.LifecycleTest do
       assert conn.status == 400
 
       # With auth
-      {:ok, conn} = RequestHandler.handle(handler, "GET", "/api/secret",
-        headers: %{"authorization" => "Bearer token123"})
+      {:ok, conn} =
+        RequestHandler.handle(handler, "GET", "/api/secret",
+          headers: %{"authorization" => "Bearer token123"}
+        )
+
       assert conn.status == 200
       assert conn.resp_body == "top secret"
     end
@@ -92,14 +110,16 @@ defmodule Firebird.Phoenix.LifecycleTest do
     test "CSRF protection middleware", %{components: c} do
       token = CSRF.generate_token()
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.use_middleware(CSRF.protect(token: token))
-      |> RequestHandler.route("GET", "/form", "Form.new")
-      |> RequestHandler.route("POST", "/form", "Form.create")
-      |> RequestHandler.template("Form.new", 200, "text/html", "<form>...</form>")
-      |> RequestHandler.action("Form.create", fn _params ->
-        {201, "text/plain", "created"}
-      end)
+
+      handler =
+        handler
+        |> RequestHandler.use_middleware(CSRF.protect(token: token))
+        |> RequestHandler.route("GET", "/form", "Form.new")
+        |> RequestHandler.route("POST", "/form", "Form.create")
+        |> RequestHandler.template("Form.new", 200, "text/html", "<form>...</form>")
+        |> RequestHandler.action("Form.create", fn _params ->
+          {201, "text/plain", "created"}
+        end)
 
       # GET passes through (safe method)
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/form")
@@ -111,24 +131,32 @@ defmodule Firebird.Phoenix.LifecycleTest do
       assert conn.status == 403
 
       # POST with correct token passes
-      {:ok, conn} = RequestHandler.handle(handler, "POST", "/form",
-        headers: %{"x-csrf-token" => token})
+      {:ok, conn} =
+        RequestHandler.handle(handler, "POST", "/form", headers: %{"x-csrf-token" => token})
+
       assert conn.status == 201
     end
 
     test "multiple routes with REST pattern", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.route("GET", "/api/posts", "Post.index")
-      |> RequestHandler.route("GET", "/api/posts/:id", "Post.show")
-      |> RequestHandler.route("POST", "/api/posts", "Post.create")
-      |> RequestHandler.route("PUT", "/api/posts/:id", "Post.update")
-      |> RequestHandler.route("DELETE", "/api/posts/:id", "Post.delete")
-      |> RequestHandler.template("Post.index", 200, "application/json", "[]")
-      |> RequestHandler.template("Post.show", 200, "application/json", ~s({"id":"{{id}}"}))
-      |> RequestHandler.template("Post.create", 201, "application/json", ~s({"created":true}))
-      |> RequestHandler.template("Post.update", 200, "application/json", ~s({"id":"{{id}}","updated":true}))
-      |> RequestHandler.template("Post.delete", 204, "text/plain", "")
+
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/api/posts", "Post.index")
+        |> RequestHandler.route("GET", "/api/posts/:id", "Post.show")
+        |> RequestHandler.route("POST", "/api/posts", "Post.create")
+        |> RequestHandler.route("PUT", "/api/posts/:id", "Post.update")
+        |> RequestHandler.route("DELETE", "/api/posts/:id", "Post.delete")
+        |> RequestHandler.template("Post.index", 200, "application/json", "[]")
+        |> RequestHandler.template("Post.show", 200, "application/json", ~s({"id":"{{id}}"}))
+        |> RequestHandler.template("Post.create", 201, "application/json", ~s({"created":true}))
+        |> RequestHandler.template(
+          "Post.update",
+          200,
+          "application/json",
+          ~s({"id":"{{id}}","updated":true})
+        )
+        |> RequestHandler.template("Post.delete", 204, "text/plain", "")
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/api/posts")
       assert conn.status == 200
@@ -184,8 +212,8 @@ defmodule Firebird.Phoenix.LifecycleTest do
     end
 
     test "channel message encode/decode roundtrip" do
-      frame = WebSocket.encode_channel_message("room:lobby", "new_msg",
-        %{"body" => "Hello!"}, ref: "1")
+      frame =
+        WebSocket.encode_channel_message("room:lobby", "new_msg", %{"body" => "Hello!"}, ref: "1")
 
       {:ok, {:text, json}, <<>>} = WebSocket.decode_frame(frame)
       {:ok, msg} = WebSocket.decode_channel_message(json)
@@ -210,28 +238,33 @@ defmodule Firebird.Phoenix.LifecycleTest do
         {"GET", "/users/:id", "UserController.show"},
         {"GET", "/users", "UserController.index"}
       ]
+
       actions = %{
         "UserController.show" => {200, "application/json", ~s({"id":"{{id}}"})},
         "UserController.index" => {200, "application/json", "[]"}
       }
 
-      {:ok, resp} = Firebird.Phoenix.process_request(c,
-        method: "GET",
-        path: "/users/42",
-        routes: routes,
-        actions: actions
-      )
+      {:ok, resp} =
+        Firebird.Phoenix.process_request(c,
+          method: "GET",
+          path: "/users/42",
+          routes: routes,
+          actions: actions
+        )
+
       assert resp.status == 200
       assert resp.body =~ "42"
     end
 
     test "returns 404 for unmatched routes", %{components: c} do
-      result = Firebird.Phoenix.process_request(c,
-        method: "GET",
-        path: "/nonexistent",
-        routes: [{"GET", "/users", "User.index"}],
-        actions: %{"User.index" => {200, "text/plain", "users"}}
-      )
+      result =
+        Firebird.Phoenix.process_request(c,
+          method: "GET",
+          path: "/nonexistent",
+          routes: [{"GET", "/users", "User.index"}],
+          actions: %{"User.index" => {200, "text/plain", "users"}}
+        )
+
       # Should return 404 somehow
       case result do
         {:ok, resp} -> assert resp.status == 404
diff --git a/test/phoenix/pipeline_test.exs b/test/phoenix/pipeline_test.exs
index ac3fe82..c45ab19 100644
--- a/test/phoenix/pipeline_test.exs
+++ b/test/phoenix/pipeline_test.exs
@@ -19,25 +19,28 @@ defmodule Firebird.Phoenix.PipelineTest do
 
   describe "plug/3" do
     test "adds a named pipeline" do
-      pipeline = Pipeline.new()
-      |> Pipeline.plug(:browser, ["put_secure_headers", "accept:text/html"])
+      pipeline =
+        Pipeline.new()
+        |> Pipeline.plug(:browser, ["put_secure_headers", "accept:text/html"])
 
       assert Pipeline.get(pipeline, :browser) == ["put_secure_headers", "accept:text/html"]
     end
 
     test "supports multiple pipelines" do
-      pipeline = Pipeline.new()
-      |> Pipeline.plug(:browser, ["put_secure_headers"])
-      |> Pipeline.plug(:api, ["accept:application/json", "cors:*"])
+      pipeline =
+        Pipeline.new()
+        |> Pipeline.plug(:browser, ["put_secure_headers"])
+        |> Pipeline.plug(:api, ["accept:application/json", "cors:*"])
 
       assert Pipeline.get(pipeline, :browser) == ["put_secure_headers"]
       assert Pipeline.get(pipeline, :api) == ["accept:application/json", "cors:*"]
     end
 
     test "overwrites existing pipeline with same name" do
-      pipeline = Pipeline.new()
-      |> Pipeline.plug(:api, ["old_plug"])
-      |> Pipeline.plug(:api, ["new_plug"])
+      pipeline =
+        Pipeline.new()
+        |> Pipeline.plug(:api, ["old_plug"])
+        |> Pipeline.plug(:api, ["new_plug"])
 
       assert Pipeline.get(pipeline, :api) == ["new_plug"]
     end
@@ -52,9 +55,10 @@ defmodule Firebird.Phoenix.PipelineTest do
 
   describe "names/1" do
     test "returns all pipeline names" do
-      pipeline = Pipeline.new()
-      |> Pipeline.plug(:browser, ["a"])
-      |> Pipeline.plug(:api, ["b"])
+      pipeline =
+        Pipeline.new()
+        |> Pipeline.plug(:browser, ["a"])
+        |> Pipeline.plug(:api, ["b"])
 
       names = Pipeline.names(pipeline) |> Enum.sort()
       assert names == [:api, :browser]
@@ -82,8 +86,9 @@ defmodule Firebird.Phoenix.PipelineTest do
 
   describe "execute/4" do
     test "executes a named pipeline against a request", %{endpoint: endpoint} do
-      pipeline = Pipeline.new()
-      |> Pipeline.plug(:secure, ["put_secure_headers"])
+      pipeline =
+        Pipeline.new()
+        |> Pipeline.plug(:secure, ["put_secure_headers"])
 
       raw = "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n"
 
@@ -93,24 +98,28 @@ defmodule Firebird.Phoenix.PipelineTest do
 
     test "returns error for unknown pipeline", %{endpoint: endpoint} do
       pipeline = Pipeline.new()
+
       assert {:error, :unknown_pipeline} =
-        Pipeline.execute(pipeline, :unknown, endpoint, "GET / HTTP/1.1\r\n\r\n")
+               Pipeline.execute(pipeline, :unknown, endpoint, "GET / HTTP/1.1\r\n\r\n")
     end
 
     test "accepts Conn struct as request", %{endpoint: endpoint} do
-      pipeline = Pipeline.new()
-      |> Pipeline.plug(:secure, ["put_secure_headers"])
+      pipeline =
+        Pipeline.new()
+        |> Pipeline.plug(:secure, ["put_secure_headers"])
 
-      conn = Conn.new("GET", "/")
-      |> Conn.put_req_header("host", "localhost")
+      conn =
+        Conn.new("GET", "/")
+        |> Conn.put_req_header("host", "localhost")
 
       assert {:ok, result} = Pipeline.execute(pipeline, :secure, endpoint, conn)
       assert result.resp_headers["x-frame-options"] == "SAMEORIGIN"
     end
 
     test "executes CORS pipeline", %{endpoint: endpoint} do
-      pipeline = Pipeline.new()
-      |> Pipeline.plug(:api, ["cors:*"])
+      pipeline =
+        Pipeline.new()
+        |> Pipeline.plug(:api, ["cors:*"])
 
       raw = "GET /api HTTP/1.1\r\nHost: localhost\r\nOrigin: http://example.com\r\n\r\n"
 
@@ -121,9 +130,10 @@ defmodule Firebird.Phoenix.PipelineTest do
 
   describe "through/4" do
     test "executes multiple pipelines in sequence", %{endpoint: endpoint} do
-      pipeline = Pipeline.new()
-      |> Pipeline.plug(:secure, ["put_secure_headers"])
-      |> Pipeline.plug(:cors, ["cors:*"])
+      pipeline =
+        Pipeline.new()
+        |> Pipeline.plug(:secure, ["put_secure_headers"])
+        |> Pipeline.plug(:cors, ["cors:*"])
 
       raw = "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n"
 
@@ -134,8 +144,9 @@ defmodule Firebird.Phoenix.PipelineTest do
 
     test "returns error for empty pipeline list", %{endpoint: endpoint} do
       pipeline = Pipeline.new()
+
       assert {:error, :empty_pipeline} =
-        Pipeline.through(pipeline, [:nonexistent], endpoint, "GET / HTTP/1.1\r\n\r\n")
+               Pipeline.through(pipeline, [:nonexistent], endpoint, "GET / HTTP/1.1\r\n\r\n")
     end
   end
 end
diff --git a/test/phoenix/plug_batch_test.exs b/test/phoenix/plug_batch_test.exs
index b9ee072..10ba77f 100644
--- a/test/phoenix/plug_batch_test.exs
+++ b/test/phoenix/plug_batch_test.exs
@@ -36,6 +36,7 @@ defmodule Firebird.Phoenix.PlugBatchTest do
         %{"count" => "42", "active" => "true"},
         %{"count" => "0", "active" => "false"}
       ]
+
       assert {:ok, results} = Plug.batch_encode_json(instance, data_list)
       assert length(results) == 2
     end
diff --git a/test/phoenix/plug_extended_test.exs b/test/phoenix/plug_extended_test.exs
index 7720c5c..3e3f5ee 100644
--- a/test/phoenix/plug_extended_test.exs
+++ b/test/phoenix/plug_extended_test.exs
@@ -20,7 +20,9 @@ defmodule Firebird.Phoenix.PlugExtendedTest do
     end
 
     test "parses POST with body", %{instance: instance} do
-      request = "POST /api/users HTTP/1.1\r\nHost: example.com\r\nContent-Type: application/json\r\n\r\n{\"name\":\"Alice\"}"
+      request =
+        "POST /api/users HTTP/1.1\r\nHost: example.com\r\nContent-Type: application/json\r\n\r\n{\"name\":\"Alice\"}"
+
       assert {:ok, req} = Plug.parse_request(instance, request)
       assert req.method == "POST"
       assert req.path == "/api/users"
@@ -28,7 +30,9 @@ defmodule Firebird.Phoenix.PlugExtendedTest do
     end
 
     test "parses multiple headers", %{instance: instance} do
-      request = "GET / HTTP/1.1\r\nHost: example.com\r\nAccept: text/html\r\nAuthorization: Bearer token123\r\nX-Request-ID: abc\r\n\r\n"
+      request =
+        "GET / HTTP/1.1\r\nHost: example.com\r\nAccept: text/html\r\nAuthorization: Bearer token123\r\nX-Request-ID: abc\r\n\r\n"
+
       assert {:ok, req} = Plug.parse_request(instance, request)
       assert req.headers["host"] == "example.com"
     end
@@ -41,7 +45,9 @@ defmodule Firebird.Phoenix.PlugExtendedTest do
     end
 
     test "parses PUT request", %{instance: instance} do
-      request = "PUT /api/items/1 HTTP/1.1\r\nHost: example.com\r\nContent-Type: application/json\r\n\r\n{\"name\":\"updated\"}"
+      request =
+        "PUT /api/items/1 HTTP/1.1\r\nHost: example.com\r\nContent-Type: application/json\r\n\r\n{\"name\":\"updated\"}"
+
       assert {:ok, req} = Plug.parse_request(instance, request)
       assert req.method == "PUT"
     end
@@ -121,26 +127,41 @@ defmodule Firebird.Phoenix.PlugExtendedTest do
 
   describe "negotiate_content_type/3" do
     test "negotiates JSON", %{instance: instance} do
-      assert {:ok, "application/json"} = Plug.negotiate_content_type(
-        instance, "application/json", ["text/html", "application/json"])
+      assert {:ok, "application/json"} =
+               Plug.negotiate_content_type(
+                 instance,
+                 "application/json",
+                 ["text/html", "application/json"]
+               )
     end
 
     test "negotiates HTML", %{instance: instance} do
-      assert {:ok, "text/html"} = Plug.negotiate_content_type(
-        instance, "text/html", ["text/html", "application/json"])
+      assert {:ok, "text/html"} =
+               Plug.negotiate_content_type(
+                 instance,
+                 "text/html",
+                 ["text/html", "application/json"]
+               )
     end
 
     test "negotiates with quality values", %{instance: instance} do
-      assert {:ok, result} = Plug.negotiate_content_type(
-        instance,
-        "text/html;q=0.9, application/json;q=1.0",
-        ["text/html", "application/json"])
+      assert {:ok, result} =
+               Plug.negotiate_content_type(
+                 instance,
+                 "text/html;q=0.9, application/json;q=1.0",
+                 ["text/html", "application/json"]
+               )
+
       assert is_binary(result)
     end
 
     test "returns not_acceptable when no match", %{instance: instance} do
-      assert {:ok, :not_acceptable} = Plug.negotiate_content_type(
-        instance, "text/xml", ["text/html", "application/json"])
+      assert {:ok, :not_acceptable} =
+               Plug.negotiate_content_type(
+                 instance,
+                 "text/xml",
+                 ["text/html", "application/json"]
+               )
     end
 
     test "handles wildcard accept", %{instance: instance} do
diff --git a/test/phoenix/plug_test.exs b/test/phoenix/plug_test.exs
index eca1d77..db8f4d2 100644
--- a/test/phoenix/plug_test.exs
+++ b/test/phoenix/plug_test.exs
@@ -27,7 +27,9 @@ defmodule Firebird.Phoenix.PlugTest do
     end
 
     test "parses POST request with body", %{instance: instance} do
-      request = "POST /api/users HTTP/1.1\r\nContent-Type: application/json\r\n\r\n{\"name\":\"Alice\"}"
+      request =
+        "POST /api/users HTTP/1.1\r\nContent-Type: application/json\r\n\r\n{\"name\":\"Alice\"}"
+
       assert {:ok, parsed} = Plug.parse_request(instance, request)
       assert parsed.method == "POST"
       assert parsed.path == "/api/users"
@@ -35,7 +37,9 @@ defmodule Firebird.Phoenix.PlugTest do
     end
 
     test "parses multiple headers", %{instance: instance} do
-      request = "GET / HTTP/1.1\r\nHost: example.com\r\nAccept: text/html\r\nUser-Agent: Test\r\n\r\n"
+      request =
+        "GET / HTTP/1.1\r\nHost: example.com\r\nAccept: text/html\r\nUser-Agent: Test\r\n\r\n"
+
       assert {:ok, parsed} = Plug.parse_request(instance, request)
       assert parsed.headers["host"] == "example.com"
       assert parsed.headers["accept"] == "text/html"
@@ -63,7 +67,9 @@ defmodule Firebird.Phoenix.PlugTest do
     end
 
     test "builds 201 Created response", %{instance: instance} do
-      assert {:ok, response} = Plug.build_response(instance, 201, "application/json", ~s({"id": 1}))
+      assert {:ok, response} =
+               Plug.build_response(instance, 201, "application/json", ~s({"id": 1}))
+
       assert response =~ "HTTP/1.1 201 Created"
       assert response =~ "application/json"
     end
@@ -126,34 +132,43 @@ defmodule Firebird.Phoenix.PlugTest do
   describe "negotiate_content_type/3" do
     test "matches exact content type", %{instance: instance} do
       assert {:ok, "application/json"} =
-        Plug.negotiate_content_type(instance, "application/json", ["text/html", "application/json"])
+               Plug.negotiate_content_type(instance, "application/json", [
+                 "text/html",
+                 "application/json"
+               ])
     end
 
     test "respects quality values", %{instance: instance} do
       assert {:ok, "application/json"} =
-        Plug.negotiate_content_type(instance, "text/html;q=0.5, application/json;q=1.0",
-          ["text/html", "application/json"])
+               Plug.negotiate_content_type(instance, "text/html;q=0.5, application/json;q=1.0", [
+                 "text/html",
+                 "application/json"
+               ])
     end
 
     test "handles wildcard accept", %{instance: instance} do
       assert {:ok, "text/html"} =
-        Plug.negotiate_content_type(instance, "*/*", ["text/html", "application/json"])
+               Plug.negotiate_content_type(instance, "*/*", ["text/html", "application/json"])
     end
 
     test "handles type wildcard", %{instance: instance} do
       assert {:ok, "text/html"} =
-        Plug.negotiate_content_type(instance, "text/*", ["text/html", "application/json"])
+               Plug.negotiate_content_type(instance, "text/*", ["text/html", "application/json"])
     end
 
     test "returns not_acceptable when no match", %{instance: instance} do
       assert {:ok, :not_acceptable} =
-        Plug.negotiate_content_type(instance, "application/xml", ["text/html", "application/json"])
+               Plug.negotiate_content_type(instance, "application/xml", [
+                 "text/html",
+                 "application/json"
+               ])
     end
 
     test "handles complex accept header", %{instance: instance} do
       accept = "text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8"
+
       assert {:ok, "text/html"} =
-        Plug.negotiate_content_type(instance, accept, ["text/html", "application/json"])
+               Plug.negotiate_content_type(instance, accept, ["text/html", "application/json"])
     end
   end
 
diff --git a/test/phoenix/rate_limiter_test.exs b/test/phoenix/rate_limiter_test.exs
index e5d76a2..e17b813 100644
--- a/test/phoenix/rate_limiter_test.exs
+++ b/test/phoenix/rate_limiter_test.exs
@@ -51,8 +51,10 @@ defmodule Firebird.Phoenix.RateLimiterTest do
 
       {:ok, limiter, _} = RateLimiter.check(limiter, "client1")
       {:ok, limiter, _} = RateLimiter.check(limiter, "client1")
+
       assert {:error, :rate_limited, _limiter, retry_after} =
-        RateLimiter.check(limiter, "client1")
+               RateLimiter.check(limiter, "client1")
+
       assert is_integer(retry_after)
       assert retry_after > 0
     end
@@ -76,8 +78,10 @@ defmodule Firebird.Phoenix.RateLimiterTest do
       result = RateLimiter.check(limiter, "client1")
       # With high rate, tokens refill quickly
       case result do
-        {:ok, _, _} -> :ok  # Tokens refilled fast enough
-        {:error, :rate_limited, _, _} -> :ok  # Expected
+        # Tokens refilled fast enough
+        {:ok, _, _} -> :ok
+        # Expected
+        {:error, :rate_limited, _, _} -> :ok
       end
     end
   end
@@ -138,11 +142,21 @@ defmodule Firebird.Phoenix.RateLimiterTest do
 
     test "middleware allows requests" do
       middleware = RateLimiter.middleware(rate: 100, period: :minute)
+
       conn = %Firebird.Phoenix.Conn{
-        method: "GET", path: "/api", params: %{}, body: "",
-        req_headers: %{}, resp_headers: %{}, resp_body: "",
-        status: 200, assigns: %{}, halted: false, query_string: ""
+        method: "GET",
+        path: "/api",
+        params: %{},
+        body: "",
+        req_headers: %{},
+        resp_headers: %{},
+        resp_body: "",
+        status: 200,
+        assigns: %{},
+        halted: false,
+        query_string: ""
       }
+
       result = middleware.(conn)
       refute result.halted
       assert result.resp_headers["x-ratelimit-remaining"] != nil
@@ -151,10 +165,19 @@ defmodule Firebird.Phoenix.RateLimiterTest do
 
     test "middleware blocks excess requests" do
       middleware = RateLimiter.middleware(rate: 1, period: :minute, burst: 1)
+
       conn = %Firebird.Phoenix.Conn{
-        method: "GET", path: "/api", params: %{}, body: "",
-        req_headers: %{}, resp_headers: %{}, resp_body: "",
-        status: 200, assigns: %{}, halted: false, query_string: ""
+        method: "GET",
+        path: "/api",
+        params: %{},
+        body: "",
+        req_headers: %{},
+        resp_headers: %{},
+        resp_body: "",
+        status: 200,
+        assigns: %{},
+        halted: false,
+        query_string: ""
       }
 
       # First request passes
@@ -170,15 +193,33 @@ defmodule Firebird.Phoenix.RateLimiterTest do
 
     test "middleware uses custom key header" do
       middleware = RateLimiter.middleware(rate: 1, burst: 1, key_header: "x-api-key")
+
       conn1 = %Firebird.Phoenix.Conn{
-        method: "GET", path: "/api", params: %{}, body: "",
-        req_headers: %{"x-api-key" => "key1"}, resp_headers: %{}, resp_body: "",
-        status: 200, assigns: %{}, halted: false, query_string: ""
+        method: "GET",
+        path: "/api",
+        params: %{},
+        body: "",
+        req_headers: %{"x-api-key" => "key1"},
+        resp_headers: %{},
+        resp_body: "",
+        status: 200,
+        assigns: %{},
+        halted: false,
+        query_string: ""
       }
+
       conn2 = %Firebird.Phoenix.Conn{
-        method: "GET", path: "/api", params: %{}, body: "",
-        req_headers: %{"x-api-key" => "key2"}, resp_headers: %{}, resp_body: "",
-        status: 200, assigns: %{}, halted: false, query_string: ""
+        method: "GET",
+        path: "/api",
+        params: %{},
+        body: "",
+        req_headers: %{"x-api-key" => "key2"},
+        resp_headers: %{},
+        resp_body: "",
+        status: 200,
+        assigns: %{},
+        halted: false,
+        query_string: ""
       }
 
       # Both pass (different keys)
diff --git a/test/phoenix/rate_limiter_wasm_test.exs b/test/phoenix/rate_limiter_wasm_test.exs
index fb3cd97..fdbd707 100644
--- a/test/phoenix/rate_limiter_wasm_test.exs
+++ b/test/phoenix/rate_limiter_wasm_test.exs
@@ -81,6 +81,7 @@ defmodule Firebird.Phoenix.RateLimiterWasmTest do
       for _ <- 1..5 do
         RateLimiterWasm.consume(rl, "clientA")
       end
+
       {:ok, :denied, _} = RateLimiterWasm.consume(rl, "clientA")
 
       # Client B should still be allowed
@@ -94,6 +95,7 @@ defmodule Firebird.Phoenix.RateLimiterWasmTest do
       for _ <- 1..5 do
         RateLimiterWasm.consume(rl, "refill_test")
       end
+
       {:ok, :denied, _} = RateLimiterWasm.consume(rl, "refill_test")
 
       # Advance time by 1 second (rate=10/sec, so should get 10 tokens but capped at burst=5)
diff --git a/test/phoenix/request_handler_compiled_routes_test.exs b/test/phoenix/request_handler_compiled_routes_test.exs
index 72a7843..df8efca 100644
--- a/test/phoenix/request_handler_compiled_routes_test.exs
+++ b/test/phoenix/request_handler_compiled_routes_test.exs
@@ -25,14 +25,16 @@ defmodule Firebird.Phoenix.RequestHandlerCompiledRoutesTest do
         :exit, _ -> :ok
       end
     end)
+
     {:ok, handler: handler}
   end
 
   describe "compile_routes/1" do
     test "explicitly compiles routes and sets routes_compiled flag", %{handler: handler} do
-      handler = handler
-      |> RequestHandler.route("GET", "/users", "UserController.index")
-      |> RequestHandler.route("GET", "/users/:id", "UserController.show")
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/users", "UserController.index")
+        |> RequestHandler.route("GET", "/users/:id", "UserController.show")
 
       assert handler.routes_compiled == false
 
@@ -41,8 +43,9 @@ defmodule Firebird.Phoenix.RequestHandlerCompiledRoutesTest do
     end
 
     test "adding a route after compile resets routes_compiled", %{handler: handler} do
-      handler = handler
-      |> RequestHandler.route("GET", "/users", "UserController.index")
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/users", "UserController.index")
 
       {:ok, compiled} = RequestHandler.compile_routes(handler)
       assert compiled.routes_compiled == true
@@ -59,9 +62,10 @@ defmodule Firebird.Phoenix.RequestHandlerCompiledRoutesTest do
 
   describe "auto-compilation on first handle/4" do
     test "routes are auto-compiled on first request", %{handler: handler} do
-      handler = handler
-      |> RequestHandler.route("GET", "/health", "HealthController.check")
-      |> RequestHandler.template("HealthController.check", 200, "text/plain", "OK")
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/health", "HealthController.check")
+        |> RequestHandler.template("HealthController.check", 200, "text/plain", "OK")
 
       assert handler.routes_compiled == false
 
@@ -72,10 +76,15 @@ defmodule Firebird.Phoenix.RequestHandlerCompiledRoutesTest do
     end
 
     test "compiled routes match with path parameters", %{handler: handler} do
-      handler = handler
-      |> RequestHandler.route("GET", "/users/:id", "UserController.show")
-      |> RequestHandler.template("UserController.show", 200, "application/json",
-          ~s({"id":"{{id}}"}))
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/users/:id", "UserController.show")
+        |> RequestHandler.template(
+          "UserController.show",
+          200,
+          "application/json",
+          ~s({"id":"{{id}}"})
+        )
 
       {:ok, compiled} = RequestHandler.compile_routes(handler)
 
@@ -85,9 +94,10 @@ defmodule Firebird.Phoenix.RequestHandlerCompiledRoutesTest do
     end
 
     test "compiled routes return 404 for unmatched paths", %{handler: handler} do
-      handler = handler
-      |> RequestHandler.route("GET", "/users", "UserController.index")
-      |> RequestHandler.template("UserController.index", 200, "text/plain", "users")
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/users", "UserController.index")
+        |> RequestHandler.template("UserController.index", 200, "text/plain", "users")
 
       {:ok, compiled} = RequestHandler.compile_routes(handler)
 
@@ -96,13 +106,14 @@ defmodule Firebird.Phoenix.RequestHandlerCompiledRoutesTest do
     end
 
     test "compiled routes handle multiple HTTP methods", %{handler: handler} do
-      handler = handler
-      |> RequestHandler.route("GET", "/items", "ItemController.index")
-      |> RequestHandler.route("POST", "/items", "ItemController.create")
-      |> RequestHandler.route("DELETE", "/items/:id", "ItemController.delete")
-      |> RequestHandler.template("ItemController.index", 200, "text/plain", "list")
-      |> RequestHandler.template("ItemController.create", 201, "text/plain", "created")
-      |> RequestHandler.template("ItemController.delete", 200, "text/plain", "deleted {{id}}")
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/items", "ItemController.index")
+        |> RequestHandler.route("POST", "/items", "ItemController.create")
+        |> RequestHandler.route("DELETE", "/items/:id", "ItemController.delete")
+        |> RequestHandler.template("ItemController.index", 200, "text/plain", "list")
+        |> RequestHandler.template("ItemController.create", 201, "text/plain", "created")
+        |> RequestHandler.template("ItemController.delete", 200, "text/plain", "deleted {{id}}")
 
       {:ok, compiled} = RequestHandler.compile_routes(handler)
 
@@ -122,32 +133,42 @@ defmodule Firebird.Phoenix.RequestHandlerCompiledRoutesTest do
 
   describe "performance: compiled vs uncompiled" do
     test "compiled routes are faster than uncompiled for repeated matching", %{handler: handler} do
-      handler = handler
-      |> RequestHandler.route("GET", "/", "PageController.index")
-      |> RequestHandler.route("GET", "/users", "UserController.index")
-      |> RequestHandler.route("GET", "/users/:id", "UserController.show")
-      |> RequestHandler.route("POST", "/users", "UserController.create")
-      |> RequestHandler.route("PUT", "/users/:id", "UserController.update")
-      |> RequestHandler.route("DELETE", "/users/:id", "UserController.delete")
-      |> RequestHandler.route("GET", "/posts", "PostController.index")
-      |> RequestHandler.route("GET", "/posts/:id", "PostController.show")
-      |> RequestHandler.template("UserController.show", 200, "application/json", ~s({"id":"{{id}}"}))
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/", "PageController.index")
+        |> RequestHandler.route("GET", "/users", "UserController.index")
+        |> RequestHandler.route("GET", "/users/:id", "UserController.show")
+        |> RequestHandler.route("POST", "/users", "UserController.create")
+        |> RequestHandler.route("PUT", "/users/:id", "UserController.update")
+        |> RequestHandler.route("DELETE", "/users/:id", "UserController.delete")
+        |> RequestHandler.route("GET", "/posts", "PostController.index")
+        |> RequestHandler.route("GET", "/posts/:id", "PostController.show")
+        |> RequestHandler.template(
+          "UserController.show",
+          200,
+          "application/json",
+          ~s({"id":"{{id}}"})
+        )
 
       # Benchmark uncompiled (sends route table each time)
       iterations = 200
-      {uncompiled_us, _} = :timer.tc(fn ->
-        for _ <- 1..iterations do
-          RequestHandler.handle(handler, "GET", "/users/42")
-        end
-      end)
+
+      {uncompiled_us, _} =
+        :timer.tc(fn ->
+          for _ <- 1..iterations do
+            RequestHandler.handle(handler, "GET", "/users/42")
+          end
+        end)
 
       # Benchmark compiled
       {:ok, compiled} = RequestHandler.compile_routes(handler)
-      {compiled_us, _} = :timer.tc(fn ->
-        for _ <- 1..iterations do
-          RequestHandler.handle(compiled, "GET", "/users/42")
-        end
-      end)
+
+      {compiled_us, _} =
+        :timer.tc(fn ->
+          for _ <- 1..iterations do
+            RequestHandler.handle(compiled, "GET", "/users/42")
+          end
+        end)
 
       uncompiled_avg = uncompiled_us / iterations
       compiled_avg = compiled_us / iterations
diff --git a/test/phoenix/request_handler_extended_test.exs b/test/phoenix/request_handler_extended_test.exs
index 28f9b4f..df28a68 100644
--- a/test/phoenix/request_handler_extended_test.exs
+++ b/test/phoenix/request_handler_extended_test.exs
@@ -12,31 +12,37 @@ defmodule Firebird.Phoenix.RequestHandlerExtendedTest do
   describe "through/2 pipeline activation" do
     test "activates pipelines", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.pipeline(:api, ["cors:*"])
-      |> RequestHandler.pipeline(:browser, ["put_secure_headers"])
-      |> RequestHandler.through([:api, :browser])
+
+      handler =
+        handler
+        |> RequestHandler.pipeline(:api, ["cors:*"])
+        |> RequestHandler.pipeline(:browser, ["put_secure_headers"])
+        |> RequestHandler.through([:api, :browser])
 
       assert handler.active_pipelines == [:api, :browser]
     end
 
     test "through replaces previous pipelines", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.pipeline(:api, ["cors:*"])
-      |> RequestHandler.through([:api])
-      |> RequestHandler.through([])
+
+      handler =
+        handler
+        |> RequestHandler.pipeline(:api, ["cors:*"])
+        |> RequestHandler.through([:api])
+        |> RequestHandler.through([])
 
       assert handler.active_pipelines == []
     end
 
     test "active pipelines execute WASM plugs during handle/4", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.pipeline(:browser, ["put_secure_headers"])
-      |> RequestHandler.through([:browser])
-      |> RequestHandler.route("GET", "/", "Page.index")
-      |> RequestHandler.template("Page.index", 200, "text/html", "<h1>Home</h1>")
+
+      handler =
+        handler
+        |> RequestHandler.pipeline(:browser, ["put_secure_headers"])
+        |> RequestHandler.through([:browser])
+        |> RequestHandler.route("GET", "/", "Page.index")
+        |> RequestHandler.template("Page.index", 200, "text/html", "<h1>Home</h1>")
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/")
       assert conn.status == 200
@@ -47,11 +53,13 @@ defmodule Firebird.Phoenix.RequestHandlerExtendedTest do
 
     test "active CORS pipeline adds access-control headers", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.pipeline(:api, ["cors:*"])
-      |> RequestHandler.through([:api])
-      |> RequestHandler.route("GET", "/api/data", "Api.data")
-      |> RequestHandler.template("Api.data", 200, "application/json", ~s({"ok":true}))
+
+      handler =
+        handler
+        |> RequestHandler.pipeline(:api, ["cors:*"])
+        |> RequestHandler.through([:api])
+        |> RequestHandler.route("GET", "/api/data", "Api.data")
+        |> RequestHandler.template("Api.data", 200, "application/json", ~s({"ok":true}))
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/api/data")
       assert conn.status == 200
@@ -60,12 +68,14 @@ defmodule Firebird.Phoenix.RequestHandlerExtendedTest do
 
     test "multiple active pipelines compose in order", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.pipeline(:security, ["put_secure_headers"])
-      |> RequestHandler.pipeline(:api, ["cors:*"])
-      |> RequestHandler.through([:security, :api])
-      |> RequestHandler.route("GET", "/api/items", "Item.index")
-      |> RequestHandler.template("Item.index", 200, "application/json", "[]")
+
+      handler =
+        handler
+        |> RequestHandler.pipeline(:security, ["put_secure_headers"])
+        |> RequestHandler.pipeline(:api, ["cors:*"])
+        |> RequestHandler.through([:security, :api])
+        |> RequestHandler.route("GET", "/api/items", "Item.index")
+        |> RequestHandler.template("Item.index", 200, "application/json", "[]")
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/api/items")
       assert conn.status == 200
@@ -76,11 +86,13 @@ defmodule Firebird.Phoenix.RequestHandlerExtendedTest do
 
     test "empty active pipelines skip WASM execution", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.pipeline(:api, ["cors:*"])
-      |> RequestHandler.through([])
-      |> RequestHandler.route("GET", "/test", "Test.index")
-      |> RequestHandler.template("Test.index", 200, "text/plain", "ok")
+
+      handler =
+        handler
+        |> RequestHandler.pipeline(:api, ["cors:*"])
+        |> RequestHandler.through([])
+        |> RequestHandler.route("GET", "/test", "Test.index")
+        |> RequestHandler.template("Test.index", 200, "text/plain", "ok")
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/test")
       assert conn.status == 200
@@ -90,12 +102,14 @@ defmodule Firebird.Phoenix.RequestHandlerExtendedTest do
 
     test "middleware assigns are preserved after pipeline execution", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.use_middleware(Middleware.request_id())
-      |> RequestHandler.pipeline(:browser, ["put_secure_headers"])
-      |> RequestHandler.through([:browser])
-      |> RequestHandler.route("GET", "/", "Page.index")
-      |> RequestHandler.template("Page.index", 200, "text/html", "ok")
+
+      handler =
+        handler
+        |> RequestHandler.use_middleware(Middleware.request_id())
+        |> RequestHandler.pipeline(:browser, ["put_secure_headers"])
+        |> RequestHandler.through([:browser])
+        |> RequestHandler.route("GET", "/", "Page.index")
+        |> RequestHandler.template("Page.index", 200, "text/html", "ok")
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/")
       # Middleware assign should survive pipeline execution
@@ -108,8 +122,10 @@ defmodule Firebird.Phoenix.RequestHandlerExtendedTest do
   describe "error_handler integration" do
     test "500 error uses error handler", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.route("GET", "/test", "Missing.action")
+
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/test", "Missing.action")
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/test")
       assert conn.status == 500
@@ -125,37 +141,40 @@ defmodule Firebird.Phoenix.RequestHandlerExtendedTest do
   describe "handle/4 with options" do
     test "passes headers to conn", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.use_middleware(fn conn ->
-        # Verify headers are present
-        if conn.req_headers["x-custom"] == "test" do
-          conn
-        else
-          Conn.halt(conn) |> Conn.put_status(400)
-        end
-      end)
-      |> RequestHandler.route("GET", "/test", "Test.index")
-      |> RequestHandler.template("Test.index", 200, "text/plain", "ok")
-
-      {:ok, conn} = RequestHandler.handle(handler, "GET", "/test",
-        headers: %{"x-custom" => "test"})
+
+      handler =
+        handler
+        |> RequestHandler.use_middleware(fn conn ->
+          # Verify headers are present
+          if conn.req_headers["x-custom"] == "test" do
+            conn
+          else
+            Conn.halt(conn) |> Conn.put_status(400)
+          end
+        end)
+        |> RequestHandler.route("GET", "/test", "Test.index")
+        |> RequestHandler.template("Test.index", 200, "text/plain", "ok")
+
+      {:ok, conn} =
+        RequestHandler.handle(handler, "GET", "/test", headers: %{"x-custom" => "test"})
+
       assert conn.status == 200
 
-      {:ok, conn} = RequestHandler.handle(handler, "GET", "/test",
-        headers: %{})
+      {:ok, conn} = RequestHandler.handle(handler, "GET", "/test", headers: %{})
       assert conn.status == 400
     end
 
     test "passes body to conn", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.route("POST", "/data", "Data.create")
-      |> RequestHandler.action("Data.create", fn params ->
-        {201, "text/plain", "received"}
-      end)
-
-      {:ok, conn} = RequestHandler.handle(handler, "POST", "/data",
-        body: ~s({"key":"value"}))
+
+      handler =
+        handler
+        |> RequestHandler.route("POST", "/data", "Data.create")
+        |> RequestHandler.action("Data.create", fn params ->
+          {201, "text/plain", "received"}
+        end)
+
+      {:ok, conn} = RequestHandler.handle(handler, "POST", "/data", body: ~s({"key":"value"}))
       assert conn.status == 201
     end
   end
@@ -163,11 +182,13 @@ defmodule Firebird.Phoenix.RequestHandlerExtendedTest do
   describe "action/3 with complex functions" do
     test "action receives path params", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.route("GET", "/users/:id/name", "User.name")
-      |> RequestHandler.action("User.name", fn params ->
-        {200, "text/plain", "User ##{params["id"]}"}
-      end)
+
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/users/:id/name", "User.name")
+        |> RequestHandler.action("User.name", fn params ->
+          {200, "text/plain", "User ##{params["id"]}"}
+        end)
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/users/99/name")
       assert conn.resp_body == "User #99"
@@ -175,12 +196,14 @@ defmodule Firebird.Phoenix.RequestHandlerExtendedTest do
 
     test "action function takes priority over template", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.route("GET", "/test", "Test.show")
-      |> RequestHandler.action("Test.show", fn _params ->
-        {200, "text/plain", "from action"}
-      end)
-      |> RequestHandler.template("Test.show", 200, "text/plain", "from template")
+
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/test", "Test.show")
+        |> RequestHandler.action("Test.show", fn _params ->
+          {200, "text/plain", "from action"}
+        end)
+        |> RequestHandler.template("Test.show", 200, "text/plain", "from template")
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/test")
       assert conn.resp_body == "from action"
@@ -190,9 +213,11 @@ defmodule Firebird.Phoenix.RequestHandlerExtendedTest do
   describe "handler without WASM components (fallback)" do
     test "uses pure Elixir matching when no router component", _ctx do
       {:ok, handler} = RequestHandler.new(components: %{})
-      handler = handler
-      |> RequestHandler.route("GET", "/users/:id", "UserController.show")
-      |> RequestHandler.template("UserController.show", 200, "text/plain", "user={{id}}")
+
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/users/:id", "UserController.show")
+        |> RequestHandler.template("UserController.show", 200, "text/plain", "user={{id}}")
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/users/42")
       assert conn.status == 200
@@ -201,9 +226,11 @@ defmodule Firebird.Phoenix.RequestHandlerExtendedTest do
 
     test "fallback handles wildcard routes", _ctx do
       {:ok, handler} = RequestHandler.new(components: %{})
-      handler = handler
-      |> RequestHandler.route("GET", "/files/*", "File.show")
-      |> RequestHandler.template("File.show", 200, "text/plain", "file={{glob}}")
+
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/files/*", "File.show")
+        |> RequestHandler.template("File.show", 200, "text/plain", "file={{glob}}")
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/files/a/b/c")
       assert conn.status == 200
@@ -212,9 +239,11 @@ defmodule Firebird.Phoenix.RequestHandlerExtendedTest do
 
     test "fallback handles wildcard method", _ctx do
       {:ok, handler} = RequestHandler.new(components: %{})
-      handler = handler
-      |> RequestHandler.route("*", "/health", "Health.check")
-      |> RequestHandler.template("Health.check", 200, "text/plain", "ok")
+
+      handler =
+        handler
+        |> RequestHandler.route("*", "/health", "Health.check")
+        |> RequestHandler.template("Health.check", 200, "text/plain", "ok")
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/health")
       assert conn.status == 200
@@ -235,21 +264,23 @@ defmodule Firebird.Phoenix.RequestHandlerExtendedTest do
   describe "middleware chaining" do
     test "multiple middlewares run in order", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.use_middleware(fn conn ->
-        Conn.assign(conn, :step1, true)
-      end)
-      |> RequestHandler.use_middleware(fn conn ->
-        if conn.assigns[:step1] do
-          Conn.assign(conn, :step2, true)
-        else
-          conn
-        end
-      end)
-      |> RequestHandler.route("GET", "/test", "Test.index")
-      |> RequestHandler.action("Test.index", fn _params ->
-        {200, "text/plain", "ok"}
-      end)
+
+      handler =
+        handler
+        |> RequestHandler.use_middleware(fn conn ->
+          Conn.assign(conn, :step1, true)
+        end)
+        |> RequestHandler.use_middleware(fn conn ->
+          if conn.assigns[:step1] do
+            Conn.assign(conn, :step2, true)
+          else
+            conn
+          end
+        end)
+        |> RequestHandler.route("GET", "/test", "Test.index")
+        |> RequestHandler.action("Test.index", fn _params ->
+          {200, "text/plain", "ok"}
+        end)
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/test")
       assert conn.assigns[:step1] == true
@@ -258,12 +289,14 @@ defmodule Firebird.Phoenix.RequestHandlerExtendedTest do
 
     test "early halt stops processing", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.use_middleware(fn conn ->
-        conn |> Conn.put_status(403) |> Conn.halt()
-      end)
-      |> RequestHandler.route("GET", "/secret", "Secret.show")
-      |> RequestHandler.template("Secret.show", 200, "text/plain", "secret")
+
+      handler =
+        handler
+        |> RequestHandler.use_middleware(fn conn ->
+          conn |> Conn.put_status(403) |> Conn.halt()
+        end)
+        |> RequestHandler.route("GET", "/secret", "Secret.show")
+        |> RequestHandler.template("Secret.show", 200, "text/plain", "secret")
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/secret")
       assert conn.status == 403
diff --git a/test/phoenix/request_handler_test.exs b/test/phoenix/request_handler_test.exs
index ef125a4..b65a708 100644
--- a/test/phoenix/request_handler_test.exs
+++ b/test/phoenix/request_handler_test.exs
@@ -25,17 +25,26 @@ defmodule Firebird.Phoenix.RequestHandlerTest do
   describe "route/4 and template/5" do
     test "adds routes", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.route("GET", "/users", "UserController.index")
-      |> RequestHandler.route("GET", "/users/:id", "UserController.show")
+
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/users", "UserController.index")
+        |> RequestHandler.route("GET", "/users/:id", "UserController.show")
 
       assert length(handler.routes) == 2
     end
 
     test "registers template actions", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = RequestHandler.template(handler, "UserController.show",
-        200, "application/json", ~s({"id":"{{id}}"}))
+
+      handler =
+        RequestHandler.template(
+          handler,
+          "UserController.show",
+          200,
+          "application/json",
+          ~s({"id":"{{id}}"})
+        )
 
       assert handler.templates["UserController.show"] != nil
     end
@@ -44,10 +53,16 @@ defmodule Firebird.Phoenix.RequestHandlerTest do
   describe "handle/4" do
     test "handles GET request with template", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.route("GET", "/users/:id", "UserController.show")
-      |> RequestHandler.template("UserController.show",
-          200, "application/json", ~s({"id":"{{id}}"}))
+
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/users/:id", "UserController.show")
+        |> RequestHandler.template(
+          "UserController.show",
+          200,
+          "application/json",
+          ~s({"id":"{{id}}"})
+        )
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/users/42")
       assert conn.status == 200
@@ -57,10 +72,16 @@ defmodule Firebird.Phoenix.RequestHandlerTest do
 
     test "handles POST request", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.route("POST", "/users", "UserController.create")
-      |> RequestHandler.template("UserController.create",
-          201, "application/json", ~s({"status":"created"}))
+
+      handler =
+        handler
+        |> RequestHandler.route("POST", "/users", "UserController.create")
+        |> RequestHandler.template(
+          "UserController.create",
+          201,
+          "application/json",
+          ~s({"status":"created"})
+        )
 
       {:ok, conn} = RequestHandler.handle(handler, "POST", "/users")
       assert conn.status == 201
@@ -77,11 +98,13 @@ defmodule Firebird.Phoenix.RequestHandlerTest do
 
     test "handles dynamic action functions", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.route("GET", "/hello/:name", "HelloController.show")
-      |> RequestHandler.action("HelloController.show", fn params ->
-        {200, "text/plain", "Hello #{params["name"]}!"}
-      end)
+
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/hello/:name", "HelloController.show")
+        |> RequestHandler.action("HelloController.show", fn params ->
+          {200, "text/plain", "Hello #{params["name"]}!"}
+        end)
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/hello/World")
       assert conn.status == 200
@@ -90,13 +113,20 @@ defmodule Firebird.Phoenix.RequestHandlerTest do
 
     test "handles multiple routes", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.route("GET", "/", "PageController.index")
-      |> RequestHandler.route("GET", "/about", "PageController.about")
-      |> RequestHandler.route("GET", "/users/:id", "UserController.show")
-      |> RequestHandler.template("PageController.index", 200, "text/html", "<h1>Home</h1>")
-      |> RequestHandler.template("PageController.about", 200, "text/html", "<h1>About</h1>")
-      |> RequestHandler.template("UserController.show", 200, "application/json", ~s({"id":"{{id}}"}))
+
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/", "PageController.index")
+        |> RequestHandler.route("GET", "/about", "PageController.about")
+        |> RequestHandler.route("GET", "/users/:id", "UserController.show")
+        |> RequestHandler.template("PageController.index", 200, "text/html", "<h1>Home</h1>")
+        |> RequestHandler.template("PageController.about", 200, "text/html", "<h1>About</h1>")
+        |> RequestHandler.template(
+          "UserController.show",
+          200,
+          "application/json",
+          ~s({"id":"{{id}}"})
+        )
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/")
       assert conn.resp_body =~ "Home"
@@ -120,11 +150,13 @@ defmodule Firebird.Phoenix.RequestHandlerTest do
   describe "middleware integration" do
     test "runs middleware before routing", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.use_middleware(Middleware.request_id())
-      |> RequestHandler.use_middleware(Middleware.timer())
-      |> RequestHandler.route("GET", "/", "PageController.index")
-      |> RequestHandler.template("PageController.index", 200, "text/html", "OK")
+
+      handler =
+        handler
+        |> RequestHandler.use_middleware(Middleware.request_id())
+        |> RequestHandler.use_middleware(Middleware.timer())
+        |> RequestHandler.route("GET", "/", "PageController.index")
+        |> RequestHandler.template("PageController.index", 200, "text/html", "OK")
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/")
       assert conn.assigns[:request_id] != nil
@@ -134,10 +166,12 @@ defmodule Firebird.Phoenix.RequestHandlerTest do
 
     test "middleware can halt the pipeline", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.use_middleware(Middleware.require_header("authorization"))
-      |> RequestHandler.route("GET", "/secret", "SecretController.show")
-      |> RequestHandler.template("SecretController.show", 200, "text/plain", "Secret!")
+
+      handler =
+        handler
+        |> RequestHandler.use_middleware(Middleware.require_header("authorization"))
+        |> RequestHandler.route("GET", "/secret", "SecretController.show")
+        |> RequestHandler.template("SecretController.show", 200, "text/plain", "Secret!")
 
       # Without auth header - halted
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/secret")
@@ -145,27 +179,34 @@ defmodule Firebird.Phoenix.RequestHandlerTest do
       assert conn.halted == true
 
       # With auth header - passes through
-      {:ok, conn} = RequestHandler.handle(handler, "GET", "/secret",
-        headers: %{"authorization" => "Bearer token"})
+      {:ok, conn} =
+        RequestHandler.handle(handler, "GET", "/secret",
+          headers: %{"authorization" => "Bearer token"}
+        )
+
       assert conn.status == 200
       assert conn.resp_body == "Secret!"
     end
 
     test "accept middleware filters content type", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.use_middleware(Middleware.accept("application/json"))
-      |> RequestHandler.route("GET", "/api", "ApiController.index")
-      |> RequestHandler.template("ApiController.index", 200, "application/json", "[]")
+
+      handler =
+        handler
+        |> RequestHandler.use_middleware(Middleware.accept("application/json"))
+        |> RequestHandler.route("GET", "/api", "ApiController.index")
+        |> RequestHandler.template("ApiController.index", 200, "application/json", "[]")
 
       # Wrong content type - halted
-      {:ok, conn} = RequestHandler.handle(handler, "GET", "/api",
-        headers: %{"accept" => "text/html"})
+      {:ok, conn} =
+        RequestHandler.handle(handler, "GET", "/api", headers: %{"accept" => "text/html"})
+
       assert conn.status == 406
 
       # Correct content type - passes
-      {:ok, conn} = RequestHandler.handle(handler, "GET", "/api",
-        headers: %{"accept" => "application/json"})
+      {:ok, conn} =
+        RequestHandler.handle(handler, "GET", "/api", headers: %{"accept" => "application/json"})
+
       assert conn.status == 200
     end
   end
@@ -173,9 +214,11 @@ defmodule Firebird.Phoenix.RequestHandlerTest do
   describe "pipeline integration" do
     test "defines named pipelines", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.pipeline(:api, ["accept:application/json", "cors:*"])
-      |> RequestHandler.pipeline(:browser, ["put_secure_headers"])
+
+      handler =
+        handler
+        |> RequestHandler.pipeline(:api, ["accept:application/json", "cors:*"])
+        |> RequestHandler.pipeline(:browser, ["put_secure_headers"])
 
       assert handler.pipelines[:api] == ["accept:application/json", "cors:*"]
       assert handler.pipelines[:browser] == ["put_secure_headers"]
@@ -185,17 +228,34 @@ defmodule Firebird.Phoenix.RequestHandlerTest do
   describe "RESTful API pattern" do
     test "complete CRUD handler", %{components: c} do
       {:ok, handler} = RequestHandler.new(components: c)
-      handler = handler
-      |> RequestHandler.route("GET", "/api/items", "ItemController.index")
-      |> RequestHandler.route("GET", "/api/items/:id", "ItemController.show")
-      |> RequestHandler.route("POST", "/api/items", "ItemController.create")
-      |> RequestHandler.route("PUT", "/api/items/:id", "ItemController.update")
-      |> RequestHandler.route("DELETE", "/api/items/:id", "ItemController.delete")
-      |> RequestHandler.template("ItemController.index", 200, "application/json", "[]")
-      |> RequestHandler.template("ItemController.show", 200, "application/json", ~s({"id":"{{id}}"}))
-      |> RequestHandler.template("ItemController.create", 201, "application/json", ~s({"status":"created"}))
-      |> RequestHandler.template("ItemController.update", 200, "application/json", ~s({"id":"{{id}}","status":"updated"}))
-      |> RequestHandler.template("ItemController.delete", 204, "text/plain", "")
+
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/api/items", "ItemController.index")
+        |> RequestHandler.route("GET", "/api/items/:id", "ItemController.show")
+        |> RequestHandler.route("POST", "/api/items", "ItemController.create")
+        |> RequestHandler.route("PUT", "/api/items/:id", "ItemController.update")
+        |> RequestHandler.route("DELETE", "/api/items/:id", "ItemController.delete")
+        |> RequestHandler.template("ItemController.index", 200, "application/json", "[]")
+        |> RequestHandler.template(
+          "ItemController.show",
+          200,
+          "application/json",
+          ~s({"id":"{{id}}"})
+        )
+        |> RequestHandler.template(
+          "ItemController.create",
+          201,
+          "application/json",
+          ~s({"status":"created"})
+        )
+        |> RequestHandler.template(
+          "ItemController.update",
+          200,
+          "application/json",
+          ~s({"id":"{{id}}","status":"updated"})
+        )
+        |> RequestHandler.template("ItemController.delete", 204, "text/plain", "")
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/api/items")
       assert conn.status == 200
diff --git a/test/phoenix/request_handler_wasm_template_test.exs b/test/phoenix/request_handler_wasm_template_test.exs
index b072eb2..70c8bb3 100644
--- a/test/phoenix/request_handler_wasm_template_test.exs
+++ b/test/phoenix/request_handler_wasm_template_test.exs
@@ -35,10 +35,15 @@ defmodule Firebird.Phoenix.RequestHandlerWasmTemplateTest do
 
       {:ok, handler} = RequestHandler.new(components: ctx.components)
 
-      handler = handler
-      |> RequestHandler.route("GET", "/users/:id", "UserController.show")
-      |> RequestHandler.template("UserController.show", 200, "application/json",
-          ~s({"id":"{{id}}","name":"User {{id}}"}))
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/users/:id", "UserController.show")
+        |> RequestHandler.template(
+          "UserController.show",
+          200,
+          "application/json",
+          ~s({"id":"{{id}}","name":"User {{id}}"})
+        )
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/users/42")
 
@@ -54,11 +59,13 @@ defmodule Firebird.Phoenix.RequestHandlerWasmTemplateTest do
       # (Path params with angle brackets break URL routing, so we verify escaping
       # directly through the template component that RequestHandler delegates to.)
       template_instance = ctx.components.template
-      {:ok, html} = Firebird.Phoenix.Template.render(
-        template_instance,
-        "<h1>Hello {{name}}</h1>",
-        %{"name" => "<script>alert(1)</script>"}
-      )
+
+      {:ok, html} =
+        Firebird.Phoenix.Template.render(
+          template_instance,
+          "<h1>Hello {{name}}</h1>",
+          %{"name" => "<script>alert(1)</script>"}
+        )
 
       # WASM template engine HTML-escapes dangerous input
       refute html =~ "<script>alert"
@@ -71,10 +78,15 @@ defmodule Firebird.Phoenix.RequestHandlerWasmTemplateTest do
 
       {:ok, handler} = RequestHandler.new(components: ctx.components)
 
-      handler = handler
-      |> RequestHandler.route("GET", "/health", "HealthController.check")
-      |> RequestHandler.template("HealthController.check", 200, "application/json",
-          ~s({"status":"ok"}))
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/health", "HealthController.check")
+        |> RequestHandler.template(
+          "HealthController.check",
+          200,
+          "application/json",
+          ~s({"status":"ok"})
+        )
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/health")
 
@@ -87,10 +99,15 @@ defmodule Firebird.Phoenix.RequestHandlerWasmTemplateTest do
 
       {:ok, handler} = RequestHandler.new(components: ctx.components)
 
-      handler = handler
-      |> RequestHandler.route("GET", "/orgs/:org/repos/:repo", "RepoController.show")
-      |> RequestHandler.template("RepoController.show", 200, "application/json",
-          ~s({"org":"{{org}}","repo":"{{repo}}"}))
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/orgs/:org/repos/:repo", "RepoController.show")
+        |> RequestHandler.template(
+          "RepoController.show",
+          200,
+          "application/json",
+          ~s({"org":"{{org}}","repo":"{{repo}}"})
+        )
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/orgs/acme/repos/firebird")
 
@@ -103,10 +120,15 @@ defmodule Firebird.Phoenix.RequestHandlerWasmTemplateTest do
       # Create handler with no template component
       {:ok, handler} = RequestHandler.new(components: %{})
 
-      handler = handler
-      |> RequestHandler.route("GET", "/users/:id", "UserController.show")
-      |> RequestHandler.template("UserController.show", 200, "application/json",
-          ~s({"id":"{{id}}"}))
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/users/:id", "UserController.show")
+        |> RequestHandler.template(
+          "UserController.show",
+          200,
+          "application/json",
+          ~s({"id":"{{id}}"})
+        )
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/users/99")
 
@@ -119,11 +141,12 @@ defmodule Firebird.Phoenix.RequestHandlerWasmTemplateTest do
 
       {:ok, handler} = RequestHandler.new(components: ctx.components)
 
-      handler = handler
-      |> RequestHandler.route("GET", "/items/:id", "ItemController.show")
-      |> RequestHandler.action("ItemController.show", fn _params ->
-        {200, "text/html", "<div>Item {{id}}</div>"}
-      end)
+      handler =
+        handler
+        |> RequestHandler.route("GET", "/items/:id", "ItemController.show")
+        |> RequestHandler.action("ItemController.show", fn _params ->
+          {200, "text/html", "<div>Item {{id}}</div>"}
+        end)
 
       {:ok, conn} = RequestHandler.handle(handler, "GET", "/items/7")
 
diff --git a/test/phoenix/router_compiled_test.exs b/test/phoenix/router_compiled_test.exs
index 3a63af4..339e27d 100644
--- a/test/phoenix/router_compiled_test.exs
+++ b/test/phoenix/router_compiled_test.exs
@@ -35,9 +35,10 @@ defmodule Firebird.Phoenix.RouterCompiledTest do
     end
 
     test "compiles single route", %{instance: instance} do
-      assert {:ok, 1} = Router.compile(instance, [
-        {"GET", "/test", "TestController.index"}
-      ])
+      assert {:ok, 1} =
+               Router.compile(instance, [
+                 {"GET", "/test", "TestController.index"}
+               ])
     end
   end
 
@@ -49,38 +50,42 @@ defmodule Firebird.Phoenix.RouterCompiledTest do
 
     test "matches exact path", %{instance: instance} do
       assert {:ok, %{handler: "PageController.index", params: %{}}} =
-        Router.match_compiled(instance, "GET", "/")
+               Router.match_compiled(instance, "GET", "/")
     end
 
     test "matches path with parameters", %{instance: instance} do
       assert {:ok, %{handler: "UserController.show", params: %{"id" => "42"}}} =
-        Router.match_compiled(instance, "GET", "/users/42")
+               Router.match_compiled(instance, "GET", "/users/42")
     end
 
     test "matches nested parameters", %{instance: instance} do
       assert {:ok, %{handler: "PostController.show", params: params}} =
-        Router.match_compiled(instance, "GET", "/users/5/posts/10")
+               Router.match_compiled(instance, "GET", "/users/5/posts/10")
+
       assert params["user_id"] == "5"
       assert params["post_id"] == "10"
     end
 
     test "matches by HTTP method", %{instance: instance} do
       assert {:ok, %{handler: "UserController.index"}} =
-        Router.match_compiled(instance, "GET", "/users")
+               Router.match_compiled(instance, "GET", "/users")
+
       assert {:ok, %{handler: "UserController.create"}} =
-        Router.match_compiled(instance, "POST", "/users")
+               Router.match_compiled(instance, "POST", "/users")
     end
 
     test "matches wildcard method", %{instance: instance} do
       assert {:ok, %{handler: "HealthController.check"}} =
-        Router.match_compiled(instance, "GET", "/health")
+               Router.match_compiled(instance, "GET", "/health")
+
       assert {:ok, %{handler: "HealthController.check"}} =
-        Router.match_compiled(instance, "POST", "/health")
+               Router.match_compiled(instance, "POST", "/health")
     end
 
     test "matches glob/wildcard paths", %{instance: instance} do
       assert {:ok, %{handler: "FileController.show", params: params}} =
-        Router.match_compiled(instance, "GET", "/files/images/photo.jpg")
+               Router.match_compiled(instance, "GET", "/files/images/photo.jpg")
+
       assert params["glob"] == "images/photo.jpg"
     end
 
@@ -94,14 +99,15 @@ defmodule Firebird.Phoenix.RouterCompiledTest do
 
     test "matches deeply nested API routes", %{instance: instance} do
       assert {:ok, %{handler: "Api.ProductController.show", params: %{"id" => "99"}}} =
-        Router.match_compiled(instance, "GET", "/api/v1/products/99")
+               Router.match_compiled(instance, "GET", "/api/v1/products/99")
     end
 
     test "PUT and DELETE work", %{instance: instance} do
       assert {:ok, %{handler: "UserController.update", params: %{"id" => "1"}}} =
-        Router.match_compiled(instance, "PUT", "/users/1")
+               Router.match_compiled(instance, "PUT", "/users/1")
+
       assert {:ok, %{handler: "UserController.delete", params: %{"id" => "1"}}} =
-        Router.match_compiled(instance, "DELETE", "/users/1")
+               Router.match_compiled(instance, "DELETE", "/users/1")
     end
   end
 
@@ -123,7 +129,10 @@ defmodule Firebird.Phoenix.RouterCompiledTest do
       assert length(results) == 4
 
       assert {:ok, %{handler: "UserController.index"}} = Enum.at(results, 0)
-      assert {:ok, %{handler: "UserController.show", params: %{"id" => "42"}}} = Enum.at(results, 1)
+
+      assert {:ok, %{handler: "UserController.show", params: %{"id" => "42"}}} =
+               Enum.at(results, 1)
+
       assert {:ok, %{handler: "UserController.create"}} = Enum.at(results, 2)
       assert {:ok, %{handler: "HealthController.check"}} = Enum.at(results, 3)
     end
diff --git a/test/phoenix/router_dsl_test.exs b/test/phoenix/router_dsl_test.exs
index aea4a5d..ed0af53 100644
--- a/test/phoenix/router_dsl_test.exs
+++ b/test/phoenix/router_dsl_test.exs
@@ -8,26 +8,26 @@ defmodule Firebird.Phoenix.RouterDSLTest do
     use Firebird.Phoenix.RouterDSL
 
     pipeline :browser do
-      plug "put_secure_headers"
-      plug "accept:text/html"
+      plug("put_secure_headers")
+      plug("accept:text/html")
     end
 
     pipeline :api do
-      plug "accept:application/json"
-      plug "cors:*"
+      plug("accept:application/json")
+      plug("cors:*")
     end
 
     scope "/api", :api do
-      get "/users", "UserController.index"
-      get "/users/:id", "UserController.show"
-      post "/users", "UserController.create"
-      put "/users/:id", "UserController.update"
-      delete "/users/:id", "UserController.delete"
+      get("/users", "UserController.index")
+      get("/users/:id", "UserController.show")
+      post("/users", "UserController.create")
+      put("/users/:id", "UserController.update")
+      delete("/users/:id", "UserController.delete")
     end
 
     scope "/" do
-      get "/", "PageController.index"
-      get "/about", "PageController.about"
+      get("/", "PageController.index")
+      get("/about", "PageController.about")
     end
   end
 
@@ -35,8 +35,8 @@ defmodule Firebird.Phoenix.RouterDSLTest do
     use Firebird.Phoenix.RouterDSL
 
     scope "/api" do
-      resources "/posts", "PostController"
-      resources "/comments", "CommentController", only: [:index, :show]
+      resources("/posts", "PostController")
+      resources("/comments", "CommentController", only: [:index, :show])
     end
   end
 
diff --git a/test/phoenix/router_test.exs b/test/phoenix/router_test.exs
index ee886c1..e46818d 100644
--- a/test/phoenix/router_test.exs
+++ b/test/phoenix/router_test.exs
@@ -18,10 +18,10 @@ defmodule Firebird.Phoenix.RouterTest do
       ]
 
       assert {:ok, %{handler: "PageController.index", params: %{}}} =
-        Router.match(instance, "GET", "/", routes)
+               Router.match(instance, "GET", "/", routes)
 
       assert {:ok, %{handler: "PageController.about", params: %{}}} =
-        Router.match(instance, "GET", "/about", routes)
+               Router.match(instance, "GET", "/about", routes)
     end
 
     test "matches path with parameters", %{instance: instance} do
@@ -30,10 +30,10 @@ defmodule Firebird.Phoenix.RouterTest do
       ]
 
       assert {:ok, %{handler: "UserController.show", params: %{"id" => "42"}}} =
-        Router.match(instance, "GET", "/users/42", routes)
+               Router.match(instance, "GET", "/users/42", routes)
 
       assert {:ok, %{handler: "UserController.show", params: %{"id" => "abc"}}} =
-        Router.match(instance, "GET", "/users/abc", routes)
+               Router.match(instance, "GET", "/users/abc", routes)
     end
 
     test "matches nested path parameters", %{instance: instance} do
@@ -42,7 +42,8 @@ defmodule Firebird.Phoenix.RouterTest do
       ]
 
       assert {:ok, %{handler: "PostController.show", params: params}} =
-        Router.match(instance, "GET", "/users/5/posts/10", routes)
+               Router.match(instance, "GET", "/users/5/posts/10", routes)
+
       assert params["user_id"] == "5"
       assert params["post_id"] == "10"
     end
@@ -54,10 +55,10 @@ defmodule Firebird.Phoenix.RouterTest do
       ]
 
       assert {:ok, %{handler: "UserController.index"}} =
-        Router.match(instance, "GET", "/users", routes)
+               Router.match(instance, "GET", "/users", routes)
 
       assert {:ok, %{handler: "UserController.create"}} =
-        Router.match(instance, "POST", "/users", routes)
+               Router.match(instance, "POST", "/users", routes)
     end
 
     test "matches wildcard method", %{instance: instance} do
@@ -66,11 +67,13 @@ defmodule Firebird.Phoenix.RouterTest do
       ]
 
       assert {:ok, %{handler: "HealthController.check"}} =
-        Router.match(instance, "GET", "/health", routes)
+               Router.match(instance, "GET", "/health", routes)
+
       assert {:ok, %{handler: "HealthController.check"}} =
-        Router.match(instance, "POST", "/health", routes)
+               Router.match(instance, "POST", "/health", routes)
+
       assert {:ok, %{handler: "HealthController.check"}} =
-        Router.match(instance, "DELETE", "/health", routes)
+               Router.match(instance, "DELETE", "/health", routes)
     end
 
     test "returns not_found for unmatched routes", %{instance: instance} do
@@ -88,7 +91,8 @@ defmodule Firebird.Phoenix.RouterTest do
       ]
 
       assert {:ok, %{handler: "FileController.show", params: params}} =
-        Router.match(instance, "GET", "/files/images/photo.jpg", routes)
+               Router.match(instance, "GET", "/files/images/photo.jpg", routes)
+
       assert params["glob"] == "images/photo.jpg"
     end
 
@@ -99,7 +103,7 @@ defmodule Firebird.Phoenix.RouterTest do
       ]
 
       assert {:ok, %{handler: "UserController.new"}} =
-        Router.match(instance, "GET", "/users/new", routes)
+               Router.match(instance, "GET", "/users/new", routes)
     end
 
     test "handles RESTful resource routes", %{instance: instance} do
@@ -112,19 +116,19 @@ defmodule Firebird.Phoenix.RouterTest do
       ]
 
       assert {:ok, %{handler: "Api.V1.UserController.index"}} =
-        Router.match(instance, "GET", "/api/v1/users", routes)
+               Router.match(instance, "GET", "/api/v1/users", routes)
 
       assert {:ok, %{handler: "Api.V1.UserController.show", params: %{"id" => "1"}}} =
-        Router.match(instance, "GET", "/api/v1/users/1", routes)
+               Router.match(instance, "GET", "/api/v1/users/1", routes)
 
       assert {:ok, %{handler: "Api.V1.UserController.create"}} =
-        Router.match(instance, "POST", "/api/v1/users", routes)
+               Router.match(instance, "POST", "/api/v1/users", routes)
 
       assert {:ok, %{handler: "Api.V1.UserController.update", params: %{"id" => "1"}}} =
-        Router.match(instance, "PUT", "/api/v1/users/1", routes)
+               Router.match(instance, "PUT", "/api/v1/users/1", routes)
 
       assert {:ok, %{handler: "Api.V1.UserController.delete", params: %{"id" => "1"}}} =
-        Router.match(instance, "DELETE", "/api/v1/users/1", routes)
+               Router.match(instance, "DELETE", "/api/v1/users/1", routes)
     end
 
     test "handles empty route list", %{instance: instance} do
diff --git a/test/phoenix/scaffold_test.exs b/test/phoenix/scaffold_test.exs
index 134a114..da8d8ee 100644
--- a/test/phoenix/scaffold_test.exs
+++ b/test/phoenix/scaffold_test.exs
@@ -173,9 +173,10 @@ defmodule Firebird.Phoenix.ScaffoldTest do
     test "generates at least 11 files" do
       {:ok, path} = Scaffold.generate("my_app", path: @test_dir)
 
-      file_count = Path.wildcard(Path.join(path, "**/*"))
-      |> Enum.filter(&File.regular?/1)
-      |> length()
+      file_count =
+        Path.wildcard(Path.join(path, "**/*"))
+        |> Enum.filter(&File.regular?/1)
+        |> length()
 
       # mix.exs, main module, application, router, 2 controllers,
       # 2 templates, test_helper, router_test, config, README = 12
@@ -185,8 +186,9 @@ defmodule Firebird.Phoenix.ScaffoldTest do
     test "all generated files are non-empty" do
       {:ok, path} = Scaffold.generate("my_app", path: @test_dir)
 
-      files = Path.wildcard(Path.join(path, "**/*"))
-      |> Enum.filter(&File.regular?/1)
+      files =
+        Path.wildcard(Path.join(path, "**/*"))
+        |> Enum.filter(&File.regular?/1)
 
       for file <- files do
         content = File.read!(file)
@@ -222,4 +224,3 @@ defmodule Firebird.Phoenix.ScaffoldTest do
     end
   end
 end
-
diff --git a/test/phoenix/server_advanced_test.exs b/test/phoenix/server_advanced_test.exs
index 58961b7..fb2c9c1 100644
--- a/test/phoenix/server_advanced_test.exs
+++ b/test/phoenix/server_advanced_test.exs
@@ -15,7 +15,7 @@ defmodule Firebird.Phoenix.ServerAdvancedTest do
     {"POST", "/api/submit", "ApiController.submit"},
     {"GET", "/slow", "SlowController.index"},
     {"GET", "/large", "LargeController.index"},
-    {"GET", "/special/chars", "SpecialController.chars"},
+    {"GET", "/special/chars", "SpecialController.chars"}
   ]
 
   @actions %{
@@ -25,7 +25,7 @@ defmodule Firebird.Phoenix.ServerAdvancedTest do
     "ApiController.submit" => {201, "application/json", ~s({"ok":true})},
     "SlowController.index" => {200, "text/plain", "ok"},
     "LargeController.index" => {200, "text/plain", String.duplicate("x", 10_000)},
-    "SpecialController.chars" => {200, "text/html", "<p>Special &amp; chars &lt;here&gt;</p>"},
+    "SpecialController.chars" => {200, "text/html", "<p>Special &amp; chars &lt;here&gt;</p>"}
   }
 
   setup do
@@ -98,7 +98,8 @@ defmodule Firebird.Phoenix.ServerAdvancedTest do
         Server.request(server, "GET", "/")
       end
 
-      Process.sleep(200) # Let async processing complete
+      # Let async processing complete
+      Process.sleep(200)
       stats = Server.stats(server)
       assert stats.request_count >= 5
     end
@@ -112,17 +113,19 @@ defmodule Firebird.Phoenix.ServerAdvancedTest do
 
   describe "multiple servers" do
     test "can run multiple servers on different ports" do
-      {:ok, server1} = Server.start_link(
-        port: 0,
-        routes: [{"GET", "/", "Page.index"}],
-        actions: %{"Page.index" => {200, "text/plain", "server1"}}
-      )
-
-      {:ok, server2} = Server.start_link(
-        port: 0,
-        routes: [{"GET", "/", "Page.index"}],
-        actions: %{"Page.index" => {200, "text/plain", "server2"}}
-      )
+      {:ok, server1} =
+        Server.start_link(
+          port: 0,
+          routes: [{"GET", "/", "Page.index"}],
+          actions: %{"Page.index" => {200, "text/plain", "server1"}}
+        )
+
+      {:ok, server2} =
+        Server.start_link(
+          port: 0,
+          routes: [{"GET", "/", "Page.index"}],
+          actions: %{"Page.index" => {200, "text/plain", "server2"}}
+        )
 
       port1 = Server.port(server1)
       port2 = Server.port(server2)
diff --git a/test/phoenix/server_stress_test.exs b/test/phoenix/server_stress_test.exs
index b202200..5641faa 100644
--- a/test/phoenix/server_stress_test.exs
+++ b/test/phoenix/server_stress_test.exs
@@ -10,13 +10,13 @@ defmodule Firebird.Phoenix.ServerStressTest do
   @routes [
     {"GET", "/", "Page.index"},
     {"GET", "/users/:id", "User.show"},
-    {"POST", "/data", "Data.create"},
+    {"POST", "/data", "Data.create"}
   ]
 
   @actions %{
     "Page.index" => {200, "text/html", "<h1>OK</h1>"},
     "User.show" => {200, "application/json", ~s({"id":"{{id}}"})},
-    "Data.create" => {201, "application/json", ~s({"ok":true})},
+    "Data.create" => {201, "application/json", ~s({"ok":true})}
   }
 
   setup do
@@ -28,18 +28,20 @@ defmodule Firebird.Phoenix.ServerStressTest do
   describe "high concurrency" do
     @tag timeout: 30_000
     test "handles 50 concurrent requests", %{server: server} do
-      tasks = for i <- 1..50 do
-        Task.async(fn ->
-          Server.request(server, "GET", "/users/#{i}")
-        end)
-      end
+      tasks =
+        for i <- 1..50 do
+          Task.async(fn ->
+            Server.request(server, "GET", "/users/#{i}")
+          end)
+        end
 
       results = Task.await_many(tasks, 15_000)
 
-      success = Enum.count(results, fn
-        {:ok, %{status: 200}} -> true
-        _ -> false
-      end)
+      success =
+        Enum.count(results, fn
+          {:ok, %{status: 200}} -> true
+          _ -> false
+        end)
 
       assert success == 50
     end
@@ -54,15 +56,16 @@ defmodule Firebird.Phoenix.ServerStressTest do
 
     @tag timeout: 30_000
     test "handles mixed concurrent operations", %{server: server} do
-      tasks = for i <- 1..30 do
-        Task.async(fn ->
-          case rem(i, 3) do
-            0 -> Server.request(server, "GET", "/")
-            1 -> Server.request(server, "GET", "/users/#{i}")
-            2 -> Server.request(server, "POST", "/data")
-          end
-        end)
-      end
+      tasks =
+        for i <- 1..30 do
+          Task.async(fn ->
+            case rem(i, 3) do
+              0 -> Server.request(server, "GET", "/")
+              1 -> Server.request(server, "GET", "/users/#{i}")
+              2 -> Server.request(server, "POST", "/data")
+            end
+          end)
+        end
 
       results = Task.await_many(tasks, 15_000)
 
@@ -94,12 +97,15 @@ defmodule Firebird.Phoenix.ServerStressTest do
     test "accurately tracks requests during concurrency", %{server: server} do
       initial = Server.stats(server).request_count
 
-      tasks = for _ <- 1..20 do
-        Task.async(fn -> Server.request(server, "GET", "/") end)
-      end
+      tasks =
+        for _ <- 1..20 do
+          Task.async(fn -> Server.request(server, "GET", "/") end)
+        end
+
       Task.await_many(tasks, 10_000)
 
-      Process.sleep(200) # Let async processing complete
+      # Let async processing complete
+      Process.sleep(200)
       final = Server.stats(server).request_count
       assert final >= initial + 20
     end
diff --git a/test/phoenix/server_test.exs b/test/phoenix/server_test.exs
index 3b78226..b0afe26 100644
--- a/test/phoenix/server_test.exs
+++ b/test/phoenix/server_test.exs
@@ -18,28 +18,32 @@ defmodule Firebird.Phoenix.ServerTest do
     {"PUT", "/users/:id", "UserController.update"},
     {"DELETE", "/users/:id", "UserController.delete"},
     {"GET", "/posts/:post_id/comments/:id", "CommentController.show"},
-    {"GET", "/files/*", "FileController.show"},
+    {"GET", "/files/*", "FileController.show"}
   ]
 
   @actions %{
-    "PageController.index" => {200, "text/html", "<html><body><h1>Welcome to Phoenix WASM!</h1></body></html>"},
+    "PageController.index" =>
+      {200, "text/html", "<html><body><h1>Welcome to Phoenix WASM!</h1></body></html>"},
     "HealthController.check" => {200, "application/json", ~s({"status":"ok","engine":"wasm"})},
-    "UserController.index" => {200, "application/json", ~s([{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}])},
+    "UserController.index" =>
+      {200, "application/json", ~s([{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}])},
     "UserController.show" => {200, "application/json", ~s({"id":"{{id}}","name":"User {{id}}"})},
     "UserController.create" => {201, "application/json", ~s({"status":"created"})},
     "UserController.update" => {200, "application/json", ~s({"status":"updated","id":"{{id}}"})},
     "UserController.delete" => {204, "application/json", ""},
-    "CommentController.show" => {200, "application/json", ~s({"post_id":"{{post_id}}","id":"{{id}}"})},
-    "FileController.show" => {200, "text/plain", "File served"},
+    "CommentController.show" =>
+      {200, "application/json", ~s({"post_id":"{{post_id}}","id":"{{id}}"})},
+    "FileController.show" => {200, "text/plain", "File served"}
   }
 
   setup do
     # Use port 0 for random available port
-    {:ok, server} = Server.start_link(
-      port: 0,
-      routes: @routes,
-      actions: @actions
-    )
+    {:ok, server} =
+      Server.start_link(
+        port: 0,
+        routes: @routes,
+        actions: @actions
+      )
 
     on_exit(fn ->
       if Process.alive?(server), do: Server.stop(server)
@@ -166,11 +170,12 @@ defmodule Firebird.Phoenix.ServerTest do
 
   describe "concurrent requests" do
     test "handles multiple concurrent requests", %{server: server} do
-      tasks = for i <- 1..10 do
-        Task.async(fn ->
-          Server.request(server, "GET", "/users/#{i}")
-        end)
-      end
+      tasks =
+        for i <- 1..10 do
+          Task.async(fn ->
+            Server.request(server, "GET", "/users/#{i}")
+          end)
+        end
 
       results = Task.await_many(tasks, 10_000)
 
@@ -187,7 +192,7 @@ defmodule Firebird.Phoenix.ServerTest do
         Task.async(fn -> Server.request(server, "POST", "/users") end),
         Task.async(fn -> Server.request(server, "GET", "/health") end),
         Task.async(fn -> Server.request(server, "GET", "/users/1") end),
-        Task.async(fn -> Server.request(server, "DELETE", "/users/1") end),
+        Task.async(fn -> Server.request(server, "DELETE", "/users/1") end)
       ]
 
       results = Task.await_many(tasks, 10_000)
@@ -213,6 +218,7 @@ defmodule Firebird.Phoenix.ServerTest do
         "Accept" => "application/json",
         "X-Request-Id" => "test-123"
       }
+
       {:ok, resp} = Server.request(server, "GET", "/health", headers)
       assert resp.status == 200
     end
diff --git a/test/phoenix/session_extended_test.exs b/test/phoenix/session_extended_test.exs
index ceaa4cf..2e53f60 100644
--- a/test/phoenix/session_extended_test.exs
+++ b/test/phoenix/session_extended_test.exs
@@ -43,14 +43,16 @@ defmodule Firebird.Phoenix.SessionExtendedTest do
     end
 
     test "builds cookie with all options", %{instance: instance} do
-      {:ok, cookie} = Session.build_cookie(instance, "session", "abc",
-        path: "/",
-        domain: "example.com",
-        max_age: "7200",
-        secure: true,
-        http_only: true,
-        same_site: "Lax"
-      )
+      {:ok, cookie} =
+        Session.build_cookie(instance, "session", "abc",
+          path: "/",
+          domain: "example.com",
+          max_age: "7200",
+          secure: true,
+          http_only: true,
+          same_site: "Lax"
+        )
+
       assert cookie =~ "session=abc"
       assert cookie =~ "Path=/"
       assert cookie =~ "Domain=example.com"
@@ -92,6 +94,7 @@ defmodule Firebird.Phoenix.SessionExtendedTest do
         "d" => "4",
         "e" => "5"
       }
+
       {:ok, encoded} = Session.encode_session(instance, data)
       {:ok, decoded} = Session.decode_session(instance, encoded)
       assert decoded["a"] == "1"
@@ -109,10 +112,12 @@ defmodule Firebird.Phoenix.SessionExtendedTest do
     end
 
     test "put multiple flash messages", %{instance: instance} do
-      {:ok, state} = Session.flash(instance, :put, %{}, %{
-        "info" => "Success",
-        "error" => "Warning"
-      })
+      {:ok, state} =
+        Session.flash(instance, :put, %{}, %{
+          "info" => "Success",
+          "error" => "Warning"
+        })
+
       assert state["info"] == "Success"
       assert state["error"] == "Warning"
     end
diff --git a/test/phoenix/session_test.exs b/test/phoenix/session_test.exs
index 6c6283e..90b9225 100644
--- a/test/phoenix/session_test.exs
+++ b/test/phoenix/session_test.exs
@@ -23,8 +23,7 @@ defmodule Firebird.Phoenix.SessionTest do
     end
 
     test "handles multiple cookies", %{instance: instance} do
-      assert {:ok, cookies} =
-               Session.parse_cookies(instance, "a=1; b=2; c=3; d=4")
+      assert {:ok, cookies} = Session.parse_cookies(instance, "a=1; b=2; c=3; d=4")
       assert cookies["a"] == "1"
       assert cookies["d"] == "4"
       assert map_size(cookies) == 4
@@ -35,8 +34,7 @@ defmodule Firebird.Phoenix.SessionTest do
     end
 
     test "handles cookies with spaces", %{instance: instance} do
-      assert {:ok, cookies} =
-               Session.parse_cookies(instance, "  name = value ; other = data  ")
+      assert {:ok, cookies} = Session.parse_cookies(instance, "  name = value ; other = data  ")
       assert Map.has_key?(cookies, "name")
     end
   end
@@ -63,8 +61,7 @@ defmodule Firebird.Phoenix.SessionTest do
     end
 
     test "builds cookie with SameSite", %{instance: instance} do
-      assert {:ok, cookie} =
-               Session.build_cookie(instance, "session", "abc", same_site: "Strict")
+      assert {:ok, cookie} = Session.build_cookie(instance, "session", "abc", same_site: "Strict")
       assert cookie =~ "SameSite=Strict"
     end
 
diff --git a/test/phoenix/static_test.exs b/test/phoenix/static_test.exs
index 3472012..d59c987 100644
--- a/test/phoenix/static_test.exs
+++ b/test/phoenix/static_test.exs
@@ -50,13 +50,13 @@ defmodule Firebird.Phoenix.StaticTest do
 
     test "detects image content types" do
       for {ext, expected} <- [
-        {".png", "image/png"},
-        {".jpg", "image/jpeg"},
-        {".gif", "image/gif"},
-        {".svg", "image/svg+xml"},
-        {".ico", "image/x-icon"},
-        {".webp", "image/webp"}
-      ] do
+            {".png", "image/png"},
+            {".jpg", "image/jpeg"},
+            {".gif", "image/gif"},
+            {".svg", "image/svg+xml"},
+            {".ico", "image/x-icon"},
+            {".webp", "image/webp"}
+          ] do
         static = Static.new() |> Static.put("/img/test#{ext}", "data")
         {:ok, conn} = Static.serve(static, "/img/test#{ext}")
         assert conn.resp_headers["content-type"] == expected
@@ -125,9 +125,10 @@ defmodule Firebird.Phoenix.StaticTest do
     end
 
     test "consistent ETags for same content" do
-      static = Static.new()
-      |> Static.put("/a.txt", "same content")
-      |> Static.put("/b.txt", "same content")
+      static =
+        Static.new()
+        |> Static.put("/a.txt", "same content")
+        |> Static.put("/b.txt", "same content")
 
       {:ok, conn_a} = Static.serve(static, "/a.txt")
       {:ok, conn_b} = Static.serve(static, "/b.txt")
@@ -135,9 +136,10 @@ defmodule Firebird.Phoenix.StaticTest do
     end
 
     test "different ETags for different content" do
-      static = Static.new()
-      |> Static.put("/a.txt", "content a")
-      |> Static.put("/b.txt", "content b")
+      static =
+        Static.new()
+        |> Static.put("/a.txt", "content a")
+        |> Static.put("/b.txt", "content b")
 
       {:ok, conn_a} = Static.serve(static, "/a.txt")
       {:ok, conn_b} = Static.serve(static, "/b.txt")
@@ -147,10 +149,11 @@ defmodule Firebird.Phoenix.StaticTest do
 
   describe "list/1" do
     test "lists all file paths" do
-      static = Static.new()
-      |> Static.put("/a.txt", "a")
-      |> Static.put("/b.txt", "b")
-      |> Static.put("/c.txt", "c")
+      static =
+        Static.new()
+        |> Static.put("/a.txt", "a")
+        |> Static.put("/b.txt", "b")
+        |> Static.put("/c.txt", "c")
 
       assert Static.list(static) == ["/a.txt", "/b.txt", "/c.txt"]
     end
@@ -170,9 +173,12 @@ defmodule Firebird.Phoenix.StaticTest do
 
   describe "total_size/1" do
     test "calculates total size" do
-      static = Static.new()
-      |> Static.put("/a.txt", "hello")      # 5 bytes
-      |> Static.put("/b.txt", "world!")      # 6 bytes
+      static =
+        Static.new()
+        # 5 bytes
+        |> Static.put("/a.txt", "hello")
+        # 6 bytes
+        |> Static.put("/b.txt", "world!")
 
       assert Static.total_size(static) == 11
     end
diff --git a/test/phoenix/stress_test.exs b/test/phoenix/stress_test.exs
index 0e602cc..6552df8 100644
--- a/test/phoenix/stress_test.exs
+++ b/test/phoenix/stress_test.exs
@@ -14,9 +14,10 @@ defmodule Firebird.Phoenix.StressTest do
   describe "router stress" do
     test "matches with many routes defined", %{c: c} do
       # Generate 50 routes
-      routes = for i <- 1..50 do
-        {"GET", "/resource_#{i}/:id", "Resource#{i}Controller.show"}
-      end
+      routes =
+        for i <- 1..50 do
+          {"GET", "/resource_#{i}/:id", "Resource#{i}Controller.show"}
+        end
 
       # Should still match correctly
       {:ok, match} = Firebird.Phoenix.Router.match(c.router, "GET", "/resource_25/42", routes)
@@ -37,10 +38,11 @@ defmodule Firebird.Phoenix.StressTest do
     test "consecutive matches are consistent", %{c: c} do
       routes = [{"GET", "/users/:id", "UserController.show"}]
 
-      results = for i <- 1..100 do
-        {:ok, match} = Firebird.Phoenix.Router.match(c.router, "GET", "/users/#{i}", routes)
-        match.params["id"]
-      end
+      results =
+        for i <- 1..100 do
+          {:ok, match} = Firebird.Phoenix.Router.match(c.router, "GET", "/users/#{i}", routes)
+          match.params["id"]
+        end
 
       expected = Enum.map(1..100, &Integer.to_string/1)
       assert results == expected
@@ -53,6 +55,7 @@ defmodule Firebird.Phoenix.StressTest do
       template = Enum.map(1..20, fn i -> "{{var#{i}}}" end) |> Enum.join(" ")
 
       {:ok, html} = Firebird.Phoenix.Template.render(c.template, template, vars)
+
       for i <- 1..20 do
         assert html =~ "value#{i}"
       end
@@ -63,10 +66,11 @@ defmodule Firebird.Phoenix.StressTest do
       block = "<div class=\"item\"><h2>{{title}}</h2><p>{{desc}}</p></div>"
       template = String.duplicate(block, 50)
 
-      {:ok, html} = Firebird.Phoenix.Template.render(c.template, template, %{
-        "title" => "Test",
-        "desc" => "Description"
-      })
+      {:ok, html} =
+        Firebird.Phoenix.Template.render(c.template, template, %{
+          "title" => "Test",
+          "desc" => "Description"
+        })
 
       assert String.length(html) > 1000
       assert html =~ "Test"
@@ -78,11 +82,12 @@ defmodule Firebird.Phoenix.StressTest do
       routes = [{"GET", "/items/:id", "ItemController.show"}]
       actions = %{"ItemController.show" => {200, "application/json", ~s({"id":"{{id}}"})}}
 
-      results = for i <- 1..50 do
-        raw = "GET /items/#{i} HTTP/1.1\r\nHost: localhost\r\n\r\n"
-        {:ok, resp} = Firebird.Phoenix.Endpoint.dispatch(c.endpoint, raw, routes, actions)
-        resp
-      end
+      results =
+        for i <- 1..50 do
+          raw = "GET /items/#{i} HTTP/1.1\r\nHost: localhost\r\n\r\n"
+          {:ok, resp} = Firebird.Phoenix.Endpoint.dispatch(c.endpoint, raw, routes, actions)
+          resp
+        end
 
       assert length(results) == 50
       assert Enum.all?(results, &is_binary/1)
@@ -116,7 +121,9 @@ defmodule Firebird.Phoenix.StressTest do
   describe "session stress" do
     test "sign and verify many cookies", %{c: c} do
       for i <- 1..50 do
-        {:ok, signed} = Firebird.Phoenix.Session.sign_cookie(c.session, "secret_#{i}", "data_#{i}")
+        {:ok, signed} =
+          Firebird.Phoenix.Session.sign_cookie(c.session, "secret_#{i}", "data_#{i}")
+
         {:ok, verified} = Firebird.Phoenix.Session.verify_cookie(c.session, "secret_#{i}", signed)
         assert verified == "data_#{i}"
       end
@@ -159,10 +166,11 @@ defmodule Firebird.Phoenix.StressTest do
       old = "<h1>Old</h1>"
       new = "<h1>New</h1>"
 
-      results = for _ <- 1..20 do
-        {:ok, patches} = Firebird.Phoenix.Live.diff_html(c.live, old, new)
-        patches
-      end
+      results =
+        for _ <- 1..20 do
+          {:ok, patches} = Firebird.Phoenix.Live.diff_html(c.live, old, new)
+          patches
+        end
 
       # All should be identical
       first = hd(results)
@@ -180,12 +188,13 @@ defmodule Firebird.Phoenix.StressTest do
       # Warm up the ETS cache with a single call first
       {:ok, _} = Firebird.Phoenix.Router.match(c.router, "GET", "/users/1", routes)
 
-      tasks = for i <- 1..20 do
-        Task.async(fn ->
-          path = if rem(i, 2) == 0, do: "/users/#{i}", else: "/posts/#{i}"
-          Firebird.Phoenix.Router.match(c.router, "GET", path, routes)
-        end)
-      end
+      tasks =
+        for i <- 1..20 do
+          Task.async(fn ->
+            path = if rem(i, 2) == 0, do: "/users/#{i}", else: "/posts/#{i}"
+            Firebird.Phoenix.Router.match(c.router, "GET", path, routes)
+          end)
+        end
 
       results = Task.await_many(tasks, 5000)
       assert Enum.all?(results, fn {:ok, match} -> is_map(match) end)
@@ -193,13 +202,17 @@ defmodule Firebird.Phoenix.StressTest do
 
     test "parallel template rendering", %{c: c} do
       # Warm up the ETS cache with a single call first
-      {:ok, _} = Firebird.Phoenix.Template.render(c.template, "<p>{{name}}</p>", %{"name" => "warmup"})
-
-      tasks = for i <- 1..20 do
-        Task.async(fn ->
-          Firebird.Phoenix.Template.render(c.template, "<p>{{name}}</p>", %{"name" => "User #{i}"})
-        end)
-      end
+      {:ok, _} =
+        Firebird.Phoenix.Template.render(c.template, "<p>{{name}}</p>", %{"name" => "warmup"})
+
+      tasks =
+        for i <- 1..20 do
+          Task.async(fn ->
+            Firebird.Phoenix.Template.render(c.template, "<p>{{name}}</p>", %{
+              "name" => "User #{i}"
+            })
+          end)
+        end
 
       results = Task.await_many(tasks, 5000)
       assert Enum.all?(results, fn {:ok, html} -> html =~ "User" end)
@@ -208,11 +221,12 @@ defmodule Firebird.Phoenix.StressTest do
 
   describe "middleware stress" do
     test "long middleware chain" do
-      chain = Enum.reduce(1..20, Firebird.Phoenix.Middleware.new(), fn i, acc ->
-        Firebird.Phoenix.Middleware.use(acc, fn conn ->
-          Firebird.Phoenix.Conn.assign(conn, :"step_#{i}", true)
+      chain =
+        Enum.reduce(1..20, Firebird.Phoenix.Middleware.new(), fn i, acc ->
+          Firebird.Phoenix.Middleware.use(acc, fn conn ->
+            Firebird.Phoenix.Conn.assign(conn, :"step_#{i}", true)
+          end)
         end)
-      end)
 
       conn = Firebird.Phoenix.Conn.new("GET", "/")
       {:ok, result} = Firebird.Phoenix.Middleware.run(chain, conn)
@@ -223,5 +237,3 @@ defmodule Firebird.Phoenix.StressTest do
     end
   end
 end
-
-
diff --git a/test/phoenix/telemetry_test.exs b/test/phoenix/telemetry_test.exs
index 2e2150c..8a6ab6e 100644
--- a/test/phoenix/telemetry_test.exs
+++ b/test/phoenix/telemetry_test.exs
@@ -31,6 +31,7 @@ defmodule Firebird.Phoenix.TelemetryTest do
       for _ <- 1..10 do
         Telemetry.record_request("/users", 200, 50.0)
       end
+
       metrics = Telemetry.get_metrics()
       assert metrics.request_count == 10
     end
@@ -71,6 +72,7 @@ defmodule Firebird.Phoenix.TelemetryTest do
       for _ <- 1..5 do
         Telemetry.record_wasm_call(:router, :match, 45.0)
       end
+
       Telemetry.record_wasm_call(:template, :render, 60.0)
 
       metrics = Telemetry.get_metrics()
@@ -117,7 +119,9 @@ defmodule Firebird.Phoenix.TelemetryTest do
       for _ <- 1..100 do
         Telemetry.record_request("/test", 200, 10.0)
       end
-      Process.sleep(10)  # Let some time pass
+
+      # Let some time pass
+      Process.sleep(10)
       metrics = Telemetry.get_metrics()
       assert metrics.requests_per_second > 0
     end
@@ -185,11 +189,21 @@ defmodule Firebird.Phoenix.TelemetryTest do
 
     test "sets telemetry_start assign" do
       middleware = Telemetry.middleware()
+
       conn = %Firebird.Phoenix.Conn{
-        method: "GET", path: "/test", params: %{}, body: "",
-        req_headers: %{}, resp_headers: %{}, resp_body: "",
-        status: 200, assigns: %{}, halted: false, query_string: ""
+        method: "GET",
+        path: "/test",
+        params: %{},
+        body: "",
+        req_headers: %{},
+        resp_headers: %{},
+        resp_body: "",
+        status: 200,
+        assigns: %{},
+        halted: false,
+        query_string: ""
       }
+
       result = middleware.(conn)
       assert result.assigns[:telemetry_start] != nil
     end
@@ -198,11 +212,21 @@ defmodule Firebird.Phoenix.TelemetryTest do
   describe "finish_request/1" do
     test "records metrics from conn" do
       middleware = Telemetry.middleware()
+
       conn = %Firebird.Phoenix.Conn{
-        method: "GET", path: "/test", params: %{}, body: "",
-        req_headers: %{}, resp_headers: %{}, resp_body: "",
-        status: 200, assigns: %{}, halted: false, query_string: ""
+        method: "GET",
+        path: "/test",
+        params: %{},
+        body: "",
+        req_headers: %{},
+        resp_headers: %{},
+        resp_body: "",
+        status: 200,
+        assigns: %{},
+        halted: false,
+        query_string: ""
       }
+
       conn = middleware.(conn)
       Process.sleep(1)
       Telemetry.finish_request(conn)
@@ -213,10 +237,19 @@ defmodule Firebird.Phoenix.TelemetryTest do
 
     test "handles conn without telemetry_start" do
       conn = %Firebird.Phoenix.Conn{
-        method: "GET", path: "/test", params: %{}, body: "",
-        req_headers: %{}, resp_headers: %{}, resp_body: "",
-        status: 200, assigns: %{}, halted: false, query_string: ""
+        method: "GET",
+        path: "/test",
+        params: %{},
+        body: "",
+        req_headers: %{},
+        resp_headers: %{},
+        resp_body: "",
+        status: 200,
+        assigns: %{},
+        halted: false,
+        query_string: ""
       }
+
       assert :ok = Telemetry.finish_request(conn)
     end
   end
diff --git a/test/phoenix/template_compiled_test.exs b/test/phoenix/template_compiled_test.exs
index 3cc13bd..53d0979 100644
--- a/test/phoenix/template_compiled_test.exs
+++ b/test/phoenix/template_compiled_test.exs
@@ -18,8 +18,12 @@ defmodule Firebird.Phoenix.TemplateCompiledTest do
     end
 
     test "compiles template with multiple variables", %{instance: instance} do
-      assert {:ok, count} = Template.compile(instance,
-        "<div>{{first}} {{last}} ({{role}})</div>")
+      assert {:ok, count} =
+               Template.compile(
+                 instance,
+                 "<div>{{first}} {{last}} ({{role}})</div>"
+               )
+
       assert count > 0
     end
 
@@ -43,8 +47,13 @@ defmodule Firebird.Phoenix.TemplateCompiledTest do
 
     test "renders with multiple variables", %{instance: instance} do
       {:ok, _} = Template.compile(instance, "<p>{{first}} {{last}}</p>")
-      assert {:ok, html} = Template.render_compiled(instance,
-        %{"first" => "John", "last" => "Doe"})
+
+      assert {:ok, html} =
+               Template.render_compiled(
+                 instance,
+                 %{"first" => "John", "last" => "Doe"}
+               )
+
       assert html == "<p>John Doe</p>"
     end
 
@@ -65,8 +74,13 @@ defmodule Firebird.Phoenix.TemplateCompiledTest do
 
     test "escapes HTML in assigns", %{instance: instance} do
       {:ok, _} = Template.compile(instance, "<p>{{content}}</p>")
-      assert {:ok, html} = Template.render_compiled(instance,
-        %{"content" => "<script>alert('xss')</script>"})
+
+      assert {:ok, html} =
+               Template.render_compiled(
+                 instance,
+                 %{"content" => "<script>alert('xss')</script>"}
+               )
+
       assert html =~ "&lt;script&gt;"
       refute html =~ "<script>"
     end
@@ -75,11 +89,14 @@ defmodule Firebird.Phoenix.TemplateCompiledTest do
   describe "render_compiled_batch/2" do
     test "renders batch of assigns", %{instance: instance} do
       {:ok, _} = Template.compile(instance, "<p>{{name}}</p>")
-      assert {:ok, results} = Template.render_compiled_batch(instance, [
-        %{"name" => "Alice"},
-        %{"name" => "Bob"},
-        %{"name" => "Charlie"}
-      ])
+
+      assert {:ok, results} =
+               Template.render_compiled_batch(instance, [
+                 %{"name" => "Alice"},
+                 %{"name" => "Bob"},
+                 %{"name" => "Charlie"}
+               ])
+
       assert length(results) == 3
       assert Enum.at(results, 0) == "<p>Alice</p>"
       assert Enum.at(results, 1) == "<p>Bob</p>"
@@ -88,10 +105,13 @@ defmodule Firebird.Phoenix.TemplateCompiledTest do
 
     test "renders batch with multiple variables", %{instance: instance} do
       {:ok, _} = Template.compile(instance, "{{first}} {{last}}")
-      assert {:ok, results} = Template.render_compiled_batch(instance, [
-        %{"first" => "A", "last" => "1"},
-        %{"first" => "B", "last" => "2"}
-      ])
+
+      assert {:ok, results} =
+               Template.render_compiled_batch(instance, [
+                 %{"first" => "A", "last" => "1"},
+                 %{"first" => "B", "last" => "2"}
+               ])
+
       assert Enum.at(results, 0) == "A 1"
       assert Enum.at(results, 1) == "B 2"
     end
@@ -105,11 +125,13 @@ defmodule Firebird.Phoenix.TemplateCompiledTest do
 
   describe "html_escape_batch/2" do
     test "escapes multiple strings in one call", %{instance: instance} do
-      assert {:ok, results} = Template.html_escape_batch(instance, [
-        "<script>",
-        "hello & world",
-        "safe text"
-      ])
+      assert {:ok, results} =
+               Template.html_escape_batch(instance, [
+                 "<script>",
+                 "hello & world",
+                 "safe text"
+               ])
+
       assert length(results) == 3
       assert Enum.at(results, 0) =~ "&lt;script&gt;"
       assert Enum.at(results, 1) =~ "hello &amp; world"
diff --git a/test/phoenix/template_test.exs b/test/phoenix/template_test.exs
index ba4c050..7d0b84b 100644
--- a/test/phoenix/template_test.exs
+++ b/test/phoenix/template_test.exs
@@ -13,40 +13,52 @@ defmodule Firebird.Phoenix.TemplateTest do
   describe "render/3" do
     test "renders template with variables", %{instance: instance} do
       assert {:ok, "<h1>Hello World</h1>"} =
-        Template.render(instance, "<h1>Hello {{name}}</h1>", %{"name" => "World"})
+               Template.render(instance, "<h1>Hello {{name}}</h1>", %{"name" => "World"})
     end
 
     test "renders template with multiple variables", %{instance: instance} do
-      assert {:ok, result} = Template.render(instance,
-        "<div>{{first}} {{last}}</div>",
-        %{"first" => "John", "last" => "Doe"}
-      )
+      assert {:ok, result} =
+               Template.render(
+                 instance,
+                 "<div>{{first}} {{last}}</div>",
+                 %{"first" => "John", "last" => "Doe"}
+               )
+
       assert result == "<div>John Doe</div>"
     end
 
     test "auto-escapes HTML in variables", %{instance: instance} do
-      assert {:ok, result} = Template.render(instance,
-        "<p>{{content}}</p>",
-        %{"content" => "<script>alert('xss')</script>"}
-      )
+      assert {:ok, result} =
+               Template.render(
+                 instance,
+                 "<p>{{content}}</p>",
+                 %{"content" => "<script>alert('xss')</script>"}
+               )
+
       assert result =~ "&lt;script&gt;"
       assert result =~ "&lt;/script&gt;"
       refute result =~ "<script>"
     end
 
     test "escapes ampersands", %{instance: instance} do
-      assert {:ok, result} = Template.render(instance,
-        "{{text}}",
-        %{"text" => "AT&T"}
-      )
+      assert {:ok, result} =
+               Template.render(
+                 instance,
+                 "{{text}}",
+                 %{"text" => "AT&T"}
+               )
+
       assert result == "AT&amp;T"
     end
 
     test "escapes quotes", %{instance: instance} do
-      assert {:ok, result} = Template.render(instance,
-        "{{text}}",
-        %{"text" => ~s(He said "hello")}
-      )
+      assert {:ok, result} =
+               Template.render(
+                 instance,
+                 "{{text}}",
+                 %{"text" => ~s(He said "hello")}
+               )
+
       assert result =~ "&quot;"
     end
 
@@ -55,15 +67,17 @@ defmodule Firebird.Phoenix.TemplateTest do
     end
 
     test "renders template without variables", %{instance: instance} do
-      assert {:ok, "<h1>Static</h1>"} =
-        Template.render(instance, "<h1>Static</h1>", %{})
+      assert {:ok, "<h1>Static</h1>"} = Template.render(instance, "<h1>Static</h1>", %{})
     end
 
     test "handles missing variable gracefully", %{instance: instance} do
-      assert {:ok, result} = Template.render(instance,
-        "<p>{{missing}}</p>",
-        %{}
-      )
+      assert {:ok, result} =
+               Template.render(
+                 instance,
+                 "<p>{{missing}}</p>",
+                 %{}
+               )
+
       # Variable placeholder remains since it wasn't substituted
       assert result == "<p>{{missing}}</p>"
     end
@@ -71,25 +85,33 @@ defmodule Firebird.Phoenix.TemplateTest do
 
   describe "render_raw/3" do
     test "renders raw HTML without escaping triple braces", %{instance: instance} do
-      assert {:ok, result} = Template.render_raw(instance,
-        "<div>{{{html}}}</div>",
-        %{"html" => "<strong>Bold</strong>"}
-      )
+      assert {:ok, result} =
+               Template.render_raw(
+                 instance,
+                 "<div>{{{html}}}</div>",
+                 %{"html" => "<strong>Bold</strong>"}
+               )
+
       assert result == "<div><strong>Bold</strong></div>"
     end
 
     test "still escapes double braces", %{instance: instance} do
-      assert {:ok, result} = Template.render_raw(instance,
-        "<p>{{escaped}}</p>",
-        %{"escaped" => "<em>italic</em>"}
-      )
+      assert {:ok, result} =
+               Template.render_raw(
+                 instance,
+                 "<p>{{escaped}}</p>",
+                 %{"escaped" => "<em>italic</em>"}
+               )
+
       assert result =~ "&lt;em&gt;"
     end
   end
 
   describe "html_escape/2" do
     test "escapes all special characters", %{instance: instance} do
-      assert {:ok, result} = Template.html_escape(instance, ~s(<div class="test" data-x='y'>&amp;</div>))
+      assert {:ok, result} =
+               Template.html_escape(instance, ~s(<div class="test" data-x='y'>&amp;</div>))
+
       assert result =~ "&lt;div"
       assert result =~ "&quot;test&quot;"
       assert result =~ "&#39;y&#39;"
@@ -128,8 +150,7 @@ defmodule Firebird.Phoenix.TemplateTest do
 
   describe "tag/4" do
     test "builds simple tag with content", %{instance: instance} do
-      assert {:ok, "<div>Hello</div>"} =
-        Template.tag(instance, "div", "Hello", %{})
+      assert {:ok, "<div>Hello</div>"} = Template.tag(instance, "div", "Hello", %{})
     end
 
     test "builds tag with attributes", %{instance: instance} do
@@ -172,18 +193,24 @@ defmodule Firebird.Phoenix.TemplateTest do
 
   describe "render_list/3" do
     test "renders a list of items", %{instance: instance} do
-      assert {:ok, result} = Template.render_list(instance,
-        "<li>{{item}}</li>",
-        ["Alice", "Bob", "Charlie"]
-      )
+      assert {:ok, result} =
+               Template.render_list(
+                 instance,
+                 "<li>{{item}}</li>",
+                 ["Alice", "Bob", "Charlie"]
+               )
+
       assert result == "<li>Alice</li><li>Bob</li><li>Charlie</li>"
     end
 
     test "includes index in rendering", %{instance: instance} do
-      assert {:ok, result} = Template.render_list(instance,
-        "<li>{{index}}: {{item}}</li>",
-        ["A", "B"]
-      )
+      assert {:ok, result} =
+               Template.render_list(
+                 instance,
+                 "<li>{{index}}: {{item}}</li>",
+                 ["A", "B"]
+               )
+
       assert result == "<li>0: A</li><li>1: B</li>"
     end
 
@@ -192,10 +219,13 @@ defmodule Firebird.Phoenix.TemplateTest do
     end
 
     test "escapes HTML in items", %{instance: instance} do
-      assert {:ok, result} = Template.render_list(instance,
-        "<p>{{item}}</p>",
-        ["<script>"]
-      )
+      assert {:ok, result} =
+               Template.render_list(
+                 instance,
+                 "<p>{{item}}</p>",
+                 ["<script>"]
+               )
+
       assert result =~ "&lt;script&gt;"
     end
   end
diff --git a/test/phoenix/testing_test.exs b/test/phoenix/testing_test.exs
index 6a9fb10..4d43d48 100644
--- a/test/phoenix/testing_test.exs
+++ b/test/phoenix/testing_test.exs
@@ -63,23 +63,26 @@ defmodule Firebird.Phoenix.TestingTest do
 
   describe "put_req_header/3" do
     test "adds a request header" do
-      conn = Testing.build_conn(:get, "/users")
-      |> Testing.put_req_header("accept", "application/json")
+      conn =
+        Testing.build_conn(:get, "/users")
+        |> Testing.put_req_header("accept", "application/json")
 
       assert conn.req_headers["accept"] == "application/json"
     end
 
     test "headers are case-insensitive" do
-      conn = Testing.build_conn(:get, "/users")
-      |> Testing.put_req_header("Content-Type", "text/html")
+      conn =
+        Testing.build_conn(:get, "/users")
+        |> Testing.put_req_header("Content-Type", "text/html")
 
       assert conn.req_headers["content-type"] == "text/html"
     end
 
     test "can add multiple headers" do
-      conn = Testing.build_conn(:get, "/users")
-      |> Testing.put_req_header("accept", "application/json")
-      |> Testing.put_req_header("authorization", "Bearer token123")
+      conn =
+        Testing.build_conn(:get, "/users")
+        |> Testing.put_req_header("accept", "application/json")
+        |> Testing.put_req_header("authorization", "Bearer token123")
 
       assert conn.req_headers["accept"] == "application/json"
       assert conn.req_headers["authorization"] == "Bearer token123"
@@ -88,8 +91,9 @@ defmodule Firebird.Phoenix.TestingTest do
 
   describe "put_json_body/2" do
     test "sets JSON body and content-type header" do
-      conn = Testing.build_conn(:post, "/users")
-      |> Testing.put_json_body(%{"name" => "Alice", "email" => "alice@test.com"})
+      conn =
+        Testing.build_conn(:post, "/users")
+        |> Testing.put_json_body(%{"name" => "Alice", "email" => "alice@test.com"})
 
       assert conn.body =~ "Alice"
       assert conn.body =~ "email"
@@ -97,8 +101,9 @@ defmodule Firebird.Phoenix.TestingTest do
     end
 
     test "encodes nested maps" do
-      conn = Testing.build_conn(:post, "/api")
-      |> Testing.put_json_body(%{"user" => %{"name" => "Bob"}})
+      conn =
+        Testing.build_conn(:post, "/api")
+        |> Testing.put_json_body(%{"user" => %{"name" => "Bob"}})
 
       decoded = Jason.decode!(conn.body)
       assert decoded["user"]["name"] == "Bob"
@@ -113,6 +118,7 @@ defmodule Firebird.Phoenix.TestingTest do
 
     test "raises when status doesn't match" do
       response = %{status: 404}
+
       assert_raise ExUnit.AssertionError, ~r/Expected status 200/, fn ->
         Testing.assert_status(response, 200)
       end
@@ -133,6 +139,7 @@ defmodule Firebird.Phoenix.TestingTest do
 
     test "raises when body doesn't contain string" do
       response = %{body: "Hello World"}
+
       assert_raise ExUnit.AssertionError, ~r/Expected body to contain/, fn ->
         Testing.assert_body_contains(response, "Goodbye")
       end
@@ -145,6 +152,7 @@ defmodule Firebird.Phoenix.TestingTest do
 
     test "handles missing body gracefully" do
       response = %{}
+
       assert_raise ExUnit.AssertionError, fn ->
         Testing.assert_body_contains(response, "something")
       end
@@ -176,6 +184,7 @@ defmodule Firebird.Phoenix.TestingTest do
 
     test "raises when header doesn't match" do
       response = %{headers: %{"content-type" => "text/html"}}
+
       assert_raise ExUnit.AssertionError, ~r/Expected header/, fn ->
         Testing.assert_header(response, "content-type", "application/json")
       end
@@ -209,10 +218,12 @@ defmodule Firebird.Phoenix.TestingTest do
       {:ok, components} = Testing.start_phoenix_wasm(only: [:router, :endpoint])
 
       conn = Testing.build_conn(:get, "/users/42")
-      {:ok, response} = Testing.dispatch(components, conn,
-        routes: [{"GET", "/users/:id", "UserController.show"}],
-        actions: %{"UserController.show" => {200, "application/json", ~s({"id":"{{id}}"})}}
-      )
+
+      {:ok, response} =
+        Testing.dispatch(components, conn,
+          routes: [{"GET", "/users/:id", "UserController.show"}],
+          actions: %{"UserController.show" => {200, "application/json", ~s({"id":"{{id}}"})}}
+        )
 
       assert response.status == 200
       assert response.body =~ "42"
@@ -223,10 +234,12 @@ defmodule Firebird.Phoenix.TestingTest do
       {:ok, components} = Testing.start_phoenix_wasm(only: [:router, :endpoint])
 
       conn = Testing.build_conn(:get, "/nonexistent")
-      {:ok, response} = Testing.dispatch(components, conn,
-        routes: [{"GET", "/users", "UserController.index"}],
-        actions: %{"UserController.index" => {200, "text/html", "Users"}}
-      )
+
+      {:ok, response} =
+        Testing.dispatch(components, conn,
+          routes: [{"GET", "/users", "UserController.index"}],
+          actions: %{"UserController.index" => {200, "text/html", "Users"}}
+        )
 
       assert response.status == 404
       Testing.stop_phoenix_wasm(components)
@@ -235,17 +248,18 @@ defmodule Firebird.Phoenix.TestingTest do
     test "handles POST with JSON body" do
       {:ok, components} = Testing.start_phoenix_wasm(only: [:router])
 
-      conn = Testing.build_conn(:post, "/users")
-      |> Testing.put_json_body(%{"name" => "Alice"})
+      conn =
+        Testing.build_conn(:post, "/users")
+        |> Testing.put_json_body(%{"name" => "Alice"})
 
-      {:ok, response} = Testing.dispatch(components, conn,
-        routes: [{"POST", "/users", "UserController.create"}],
-        actions: %{"UserController.create" => {201, "application/json", ~s({"created":true})}}
-      )
+      {:ok, response} =
+        Testing.dispatch(components, conn,
+          routes: [{"POST", "/users", "UserController.create"}],
+          actions: %{"UserController.create" => {201, "application/json", ~s({"created":true})}}
+        )
 
       assert response.status == 201
       Testing.stop_phoenix_wasm(components)
     end
   end
 end
-
diff --git a/test/phoenix/validator_test.exs b/test/phoenix/validator_test.exs
index 7ca4038..bb5db1a 100644
--- a/test/phoenix/validator_test.exs
+++ b/test/phoenix/validator_test.exs
@@ -16,31 +16,38 @@ defmodule Firebird.Phoenix.ValidatorTest do
 
   describe "validate/3 - required fields" do
     test "passes when required field is present", %{v: v} do
-      assert {:ok, :valid} = Validator.validate(v, %{"name" => "Alice"}, [
-        {:required, "name"}
-      ])
+      assert {:ok, :valid} =
+               Validator.validate(v, %{"name" => "Alice"}, [
+                 {:required, "name"}
+               ])
     end
 
     test "fails when required field is missing", %{v: v} do
-      assert {:ok, {:invalid, errors}} = Validator.validate(v, %{}, [
-        {:required, "name"}
-      ])
+      assert {:ok, {:invalid, errors}} =
+               Validator.validate(v, %{}, [
+                 {:required, "name"}
+               ])
+
       assert Enum.any?(errors, fn {field, _msg} -> field == "name" end)
     end
 
     test "fails when required field is empty", %{v: v} do
-      assert {:ok, {:invalid, errors}} = Validator.validate(v, %{"name" => ""}, [
-        {:required, "name"}
-      ])
+      assert {:ok, {:invalid, errors}} =
+               Validator.validate(v, %{"name" => ""}, [
+                 {:required, "name"}
+               ])
+
       assert Enum.any?(errors, fn {field, msg} -> field == "name" and msg =~ "required" end)
     end
 
     test "validates multiple required fields", %{v: v} do
-      assert {:ok, {:invalid, errors}} = Validator.validate(v, %{"name" => "Alice"}, [
-        {:required, "name"},
-        {:required, "email"},
-        {:required, "age"}
-      ])
+      assert {:ok, {:invalid, errors}} =
+               Validator.validate(v, %{"name" => "Alice"}, [
+                 {:required, "name"},
+                 {:required, "email"},
+                 {:required, "age"}
+               ])
+
       assert length(errors) == 2
       fields = Enum.map(errors, &elem(&1, 0))
       assert "email" in fields
@@ -50,195 +57,237 @@ defmodule Firebird.Phoenix.ValidatorTest do
 
   describe "validate/3 - type validation" do
     test "validates integer type", %{v: v} do
-      assert {:ok, :valid} = Validator.validate(v, %{"age" => "25"}, [
-        {:type, "age", :integer}
-      ])
+      assert {:ok, :valid} =
+               Validator.validate(v, %{"age" => "25"}, [
+                 {:type, "age", :integer}
+               ])
     end
 
     test "rejects non-integer", %{v: v} do
-      assert {:ok, {:invalid, errors}} = Validator.validate(v, %{"age" => "abc"}, [
-        {:type, "age", :integer}
-      ])
+      assert {:ok, {:invalid, errors}} =
+               Validator.validate(v, %{"age" => "abc"}, [
+                 {:type, "age", :integer}
+               ])
+
       assert Enum.any?(errors, fn {f, m} -> f == "age" and m =~ "integer" end)
     end
 
     test "validates float type", %{v: v} do
-      assert {:ok, :valid} = Validator.validate(v, %{"price" => "19.99"}, [
-        {:type, "price", :float}
-      ])
+      assert {:ok, :valid} =
+               Validator.validate(v, %{"price" => "19.99"}, [
+                 {:type, "price", :float}
+               ])
     end
 
     test "validates email type", %{v: v} do
-      assert {:ok, :valid} = Validator.validate(v, %{"email" => "alice@example.com"}, [
-        {:type, "email", :email}
-      ])
+      assert {:ok, :valid} =
+               Validator.validate(v, %{"email" => "alice@example.com"}, [
+                 {:type, "email", :email}
+               ])
     end
 
     test "rejects invalid email", %{v: v} do
-      assert {:ok, {:invalid, errors}} = Validator.validate(v, %{"email" => "not-an-email"}, [
-        {:type, "email", :email}
-      ])
+      assert {:ok, {:invalid, errors}} =
+               Validator.validate(v, %{"email" => "not-an-email"}, [
+                 {:type, "email", :email}
+               ])
+
       assert Enum.any?(errors, fn {f, m} -> f == "email" and m =~ "email" end)
     end
 
     test "validates url type", %{v: v} do
-      assert {:ok, :valid} = Validator.validate(v, %{"website" => "https://example.com"}, [
-        {:type, "website", :url}
-      ])
+      assert {:ok, :valid} =
+               Validator.validate(v, %{"website" => "https://example.com"}, [
+                 {:type, "website", :url}
+               ])
     end
 
     test "rejects invalid url", %{v: v} do
-      assert {:ok, {:invalid, errors}} = Validator.validate(v, %{"website" => "not-a-url"}, [
-        {:type, "website", :url}
-      ])
+      assert {:ok, {:invalid, errors}} =
+               Validator.validate(v, %{"website" => "not-a-url"}, [
+                 {:type, "website", :url}
+               ])
+
       assert Enum.any?(errors, fn {f, _m} -> f == "website" end)
     end
 
     test "validates boolean type", %{v: v} do
       for val <- ["true", "false", "1", "0", "yes", "no"] do
-        assert {:ok, :valid} = Validator.validate(v, %{"active" => val}, [
-          {:type, "active", :boolean}
-        ])
+        assert {:ok, :valid} =
+                 Validator.validate(v, %{"active" => val}, [
+                   {:type, "active", :boolean}
+                 ])
       end
     end
 
     test "rejects invalid boolean", %{v: v} do
-      assert {:ok, {:invalid, _}} = Validator.validate(v, %{"active" => "maybe"}, [
-        {:type, "active", :boolean}
-      ])
+      assert {:ok, {:invalid, _}} =
+               Validator.validate(v, %{"active" => "maybe"}, [
+                 {:type, "active", :boolean}
+               ])
     end
   end
 
   describe "validate/3 - length constraints" do
     test "validates min_length", %{v: v} do
-      assert {:ok, :valid} = Validator.validate(v, %{"name" => "Alice"}, [
-        {:min_length, "name", 3}
-      ])
+      assert {:ok, :valid} =
+               Validator.validate(v, %{"name" => "Alice"}, [
+                 {:min_length, "name", 3}
+               ])
     end
 
     test "rejects too short", %{v: v} do
-      assert {:ok, {:invalid, errors}} = Validator.validate(v, %{"name" => "Ab"}, [
-        {:min_length, "name", 3}
-      ])
+      assert {:ok, {:invalid, errors}} =
+               Validator.validate(v, %{"name" => "Ab"}, [
+                 {:min_length, "name", 3}
+               ])
+
       assert Enum.any?(errors, fn {f, m} -> f == "name" and m =~ "at least 3" end)
     end
 
     test "validates max_length", %{v: v} do
-      assert {:ok, :valid} = Validator.validate(v, %{"name" => "Alice"}, [
-        {:max_length, "name", 100}
-      ])
+      assert {:ok, :valid} =
+               Validator.validate(v, %{"name" => "Alice"}, [
+                 {:max_length, "name", 100}
+               ])
     end
 
     test "rejects too long", %{v: v} do
-      assert {:ok, {:invalid, errors}} = Validator.validate(v, %{"name" => String.duplicate("a", 101)}, [
-        {:max_length, "name", 100}
-      ])
+      assert {:ok, {:invalid, errors}} =
+               Validator.validate(v, %{"name" => String.duplicate("a", 101)}, [
+                 {:max_length, "name", 100}
+               ])
+
       assert Enum.any?(errors, fn {f, m} -> f == "name" and m =~ "at most 100" end)
     end
   end
 
   describe "validate/3 - numeric constraints" do
     test "validates min value", %{v: v} do
-      assert {:ok, :valid} = Validator.validate(v, %{"age" => "18"}, [
-        {:min, "age", 18}
-      ])
+      assert {:ok, :valid} =
+               Validator.validate(v, %{"age" => "18"}, [
+                 {:min, "age", 18}
+               ])
     end
 
     test "rejects below min", %{v: v} do
-      assert {:ok, {:invalid, errors}} = Validator.validate(v, %{"age" => "15"}, [
-        {:min, "age", 18}
-      ])
+      assert {:ok, {:invalid, errors}} =
+               Validator.validate(v, %{"age" => "15"}, [
+                 {:min, "age", 18}
+               ])
+
       assert Enum.any?(errors, fn {f, m} -> f == "age" and m =~ "at least" end)
     end
 
     test "validates max value", %{v: v} do
-      assert {:ok, :valid} = Validator.validate(v, %{"quantity" => "5"}, [
-        {:max, "quantity", 10}
-      ])
+      assert {:ok, :valid} =
+               Validator.validate(v, %{"quantity" => "5"}, [
+                 {:max, "quantity", 10}
+               ])
     end
 
     test "rejects above max", %{v: v} do
-      assert {:ok, {:invalid, errors}} = Validator.validate(v, %{"quantity" => "15"}, [
-        {:max, "quantity", 10}
-      ])
+      assert {:ok, {:invalid, errors}} =
+               Validator.validate(v, %{"quantity" => "15"}, [
+                 {:max, "quantity", 10}
+               ])
+
       assert Enum.any?(errors, fn {f, m} -> f == "quantity" and m =~ "at most" end)
     end
   end
 
   describe "validate/3 - inclusion validation" do
     test "validates inclusion in list", %{v: v} do
-      assert {:ok, :valid} = Validator.validate(v, %{"role" => "admin"}, [
-        {:in, "role", ["admin", "user", "moderator"]}
-      ])
+      assert {:ok, :valid} =
+               Validator.validate(v, %{"role" => "admin"}, [
+                 {:in, "role", ["admin", "user", "moderator"]}
+               ])
     end
 
     test "rejects value not in list", %{v: v} do
-      assert {:ok, {:invalid, errors}} = Validator.validate(v, %{"role" => "superuser"}, [
-        {:in, "role", ["admin", "user"]}
-      ])
+      assert {:ok, {:invalid, errors}} =
+               Validator.validate(v, %{"role" => "superuser"}, [
+                 {:in, "role", ["admin", "user"]}
+               ])
+
       assert Enum.any?(errors, fn {f, m} -> f == "role" and m =~ "one of" end)
     end
   end
 
   describe "validate/3 - format validation" do
     test "validates alpha format", %{v: v} do
-      assert {:ok, :valid} = Validator.validate(v, %{"name" => "Alice"}, [
-        {:format, "name", :alpha}
-      ])
+      assert {:ok, :valid} =
+               Validator.validate(v, %{"name" => "Alice"}, [
+                 {:format, "name", :alpha}
+               ])
     end
 
     test "rejects non-alpha", %{v: v} do
-      assert {:ok, {:invalid, errors}} = Validator.validate(v, %{"name" => "Alice123"}, [
-        {:format, "name", :alpha}
-      ])
+      assert {:ok, {:invalid, errors}} =
+               Validator.validate(v, %{"name" => "Alice123"}, [
+                 {:format, "name", :alpha}
+               ])
+
       assert Enum.any?(errors, fn {f, _m} -> f == "name" end)
     end
 
     test "validates alphanumeric format", %{v: v} do
-      assert {:ok, :valid} = Validator.validate(v, %{"code" => "ABC123"}, [
-        {:format, "code", :alphanumeric}
-      ])
+      assert {:ok, :valid} =
+               Validator.validate(v, %{"code" => "ABC123"}, [
+                 {:format, "code", :alphanumeric}
+               ])
     end
 
     test "validates numeric format", %{v: v} do
-      assert {:ok, :valid} = Validator.validate(v, %{"zipcode" => "12345"}, [
-        {:format, "zipcode", :numeric}
-      ])
+      assert {:ok, :valid} =
+               Validator.validate(v, %{"zipcode" => "12345"}, [
+                 {:format, "zipcode", :numeric}
+               ])
     end
   end
 
   describe "validate/3 - combined rules" do
     test "validates user registration form", %{v: v} do
-      assert {:ok, :valid} = Validator.validate(v, %{
-        "name" => "Alice Smith",
-        "email" => "alice@example.com",
-        "age" => "25",
-        "password" => "secretpassword"
-      }, [
-        {:required, "name"},
-        {:required, "email"},
-        {:required, "password"},
-        {:type, "email", :email},
-        {:type, "age", :integer},
-        {:min_length, "name", 2},
-        {:max_length, "name", 100},
-        {:min_length, "password", 8},
-        {:min, "age", 13},
-        {:max, "age", 150}
-      ])
+      assert {:ok, :valid} =
+               Validator.validate(
+                 v,
+                 %{
+                   "name" => "Alice Smith",
+                   "email" => "alice@example.com",
+                   "age" => "25",
+                   "password" => "secretpassword"
+                 },
+                 [
+                   {:required, "name"},
+                   {:required, "email"},
+                   {:required, "password"},
+                   {:type, "email", :email},
+                   {:type, "age", :integer},
+                   {:min_length, "name", 2},
+                   {:max_length, "name", 100},
+                   {:min_length, "password", 8},
+                   {:min, "age", 13},
+                   {:max, "age", 150}
+                 ]
+               )
     end
 
     test "returns multiple errors for invalid form", %{v: v} do
-      assert {:ok, {:invalid, errors}} = Validator.validate(v, %{
-        "name" => "A",
-        "email" => "not-email",
-        "age" => "abc"
-      }, [
-        {:required, "password"},
-        {:min_length, "name", 2},
-        {:type, "email", :email},
-        {:type, "age", :integer}
-      ])
+      assert {:ok, {:invalid, errors}} =
+               Validator.validate(
+                 v,
+                 %{
+                   "name" => "A",
+                   "email" => "not-email",
+                   "age" => "abc"
+                 },
+                 [
+                   {:required, "password"},
+                   {:min_length, "name", 2},
+                   {:type, "email", :email},
+                   {:type, "age", :integer}
+                 ]
+               )
 
       fields = Enum.map(errors, &elem(&1, 0))
       assert "password" in fields
@@ -309,19 +358,24 @@ defmodule Firebird.Phoenix.ValidatorTest do
         {:min_length, "name", 2}
       ]
 
-      {time_us, _} = :timer.tc(fn ->
-        for _ <- 1..100 do
-          Validator.validate(v, %{
-            "name" => "Alice",
-            "email" => "alice@example.com"
-          }, rules)
-        end
-      end)
+      {time_us, _} =
+        :timer.tc(fn ->
+          for _ <- 1..100 do
+            Validator.validate(
+              v,
+              %{
+                "name" => "Alice",
+                "email" => "alice@example.com"
+              },
+              rules
+            )
+          end
+        end)
 
       avg_us = time_us / 100.0
       IO.puts("\n  [Bench] Form validation: avg=#{Float.round(avg_us, 1)}µs/form")
-      assert avg_us < 1000  # Should be under 1ms per validation
+      # Should be under 1ms per validation
+      assert avg_us < 1000
     end
   end
 end
-
diff --git a/test/phoenix/view_test.exs b/test/phoenix/view_test.exs
index c495f0b..24a2eaa 100644
--- a/test/phoenix/view_test.exs
+++ b/test/phoenix/view_test.exs
@@ -21,7 +21,10 @@ defmodule Firebird.Phoenix.ViewTest do
     test "renders layout with assigns in content", %{instance: instance} do
       layout = "<html><body>{{inner_content}}</body></html>"
       content = "<h1>Hello {{name}}</h1>"
-      assert {:ok, html} = View.render_with_layout(instance, layout, content, %{"name" => "World"})
+
+      assert {:ok, html} =
+               View.render_with_layout(instance, layout, content, %{"name" => "World"})
+
       assert html =~ "<h1>Hello World</h1>"
     end
 
@@ -387,7 +390,9 @@ defmodule Firebird.Phoenix.ViewTest do
     end
 
     test "generates a link with target", %{instance: instance} do
-      assert {:ok, html} = View.link(instance, "Docs", "https://docs.example.com", target: "_blank")
+      assert {:ok, html} =
+               View.link(instance, "Docs", "https://docs.example.com", target: "_blank")
+
       assert html =~ ~s(target="_blank")
     end
 
diff --git a/test/phoenix/wasm_helper_test.exs b/test/phoenix/wasm_helper_test.exs
index e49275a..5fe3737 100644
--- a/test/phoenix/wasm_helper_test.exs
+++ b/test/phoenix/wasm_helper_test.exs
@@ -12,10 +12,12 @@ defmodule Firebird.Phoenix.WasmHelperTest do
   setup_all do
     {:ok, instance} = Firebird.load(Path.join(@fixtures_dir, "phoenix_template.wasm"))
     {:ok, router} = Firebird.load(Path.join(@fixtures_dir, "phoenix_router.wasm"))
+
     on_exit(fn ->
       Firebird.stop(instance)
       Firebird.stop(router)
     end)
+
     %{instance: instance, router: router}
   end
 
@@ -47,7 +49,9 @@ defmodule Firebird.Phoenix.WasmHelperTest do
     end
 
     test "handles special characters", %{instance: instance} do
-      assert {:ok, result} = WasmHelper.call_string(instance, "html_escape", ~s("quotes" & 'apostrophes'))
+      assert {:ok, result} =
+               WasmHelper.call_string(instance, "html_escape", ~s("quotes" & 'apostrophes'))
+
       assert String.contains?(result, "&amp;")
       assert String.contains?(result, "&quot;")
     end
@@ -160,11 +164,15 @@ defmodule Firebird.Phoenix.WasmHelperTest do
   describe "concurrent access" do
     test "handles concurrent call_string calls", %{instance: instance} do
       # Sequential calls should always work
-      results = for i <- 1..10 do
-        WasmHelper.call_string(instance, "html_escape", "item_#{i}")
-      end
+      results =
+        for i <- 1..10 do
+          WasmHelper.call_string(instance, "html_escape", "item_#{i}")
+        end
 
-      assert Enum.all?(results, fn {:ok, _} -> true; _ -> false end)
+      assert Enum.all?(results, fn
+               {:ok, _} -> true
+               _ -> false
+             end)
     end
   end
 
@@ -180,4 +188,3 @@ defmodule Firebird.Phoenix.WasmHelperTest do
     end
   end
 end
-
diff --git a/test/phoenix/wasm_module_info_test.exs b/test/phoenix/wasm_module_info_test.exs
index 466c5ef..3edaa6b 100644
--- a/test/phoenix/wasm_module_info_test.exs
+++ b/test/phoenix/wasm_module_info_test.exs
@@ -20,15 +20,38 @@ defmodule Firebird.Phoenix.WasmModuleInfoTest do
     "phoenix_session.wasm" => ["parse_cookies", "alloc_bytes"],
     "phoenix_live.wasm" => ["diff_html", "alloc_bytes"],
     "phoenix_validator.wasm" => ["validate_params"],
-    "phoenix_form.wasm" => ["build_form", "build_input", "build_textarea",
-                             "build_select", "build_checkbox", "html_escape"],
-    "phoenix_csrf.wasm" => ["generate_token", "verify_token", "sign_message",
-                             "constant_compare", "seed_rng"],
-    "phoenix_rate_limiter.wasm" => ["configure", "set_time", "check", "consume",
-                                     "reset", "reset_all", "stats"],
-    "phoenix_websocket.wasm" => ["is_upgrade", "upgrade_response",
-                                  "encode_text_frame", "decode_frame",
-                                  "serialize_channel_msg", "deserialize_channel_msg"],
+    "phoenix_form.wasm" => [
+      "build_form",
+      "build_input",
+      "build_textarea",
+      "build_select",
+      "build_checkbox",
+      "html_escape"
+    ],
+    "phoenix_csrf.wasm" => [
+      "generate_token",
+      "verify_token",
+      "sign_message",
+      "constant_compare",
+      "seed_rng"
+    ],
+    "phoenix_rate_limiter.wasm" => [
+      "configure",
+      "set_time",
+      "check",
+      "consume",
+      "reset",
+      "reset_all",
+      "stats"
+    ],
+    "phoenix_websocket.wasm" => [
+      "is_upgrade",
+      "upgrade_response",
+      "encode_text_frame",
+      "decode_frame",
+      "serialize_channel_msg",
+      "deserialize_channel_msg"
+    ]
   }
 
   describe "WASM module inventory" do
@@ -55,15 +78,16 @@ defmodule Firebird.Phoenix.WasmModuleInfoTest do
         actual_exports = Firebird.exports(instance)
 
         # exports may return a list of atoms or a map
-        export_names = cond do
-          is_map(actual_exports) -> Map.keys(actual_exports) |> Enum.map(&to_string/1)
-          is_list(actual_exports) -> Enum.map(actual_exports, &to_string/1)
-          true -> []
-        end
+        export_names =
+          cond do
+            is_map(actual_exports) -> Map.keys(actual_exports) |> Enum.map(&to_string/1)
+            is_list(actual_exports) -> Enum.map(actual_exports, &to_string/1)
+            true -> []
+          end
 
         for func <- expected_exports do
           assert func in export_names,
-            "#{file} missing export: #{func}. Available: #{inspect(export_names)}"
+                 "#{file} missing export: #{func}. Available: #{inspect(export_names)}"
         end
 
         Firebird.stop(instance)
@@ -71,21 +95,24 @@ defmodule Firebird.Phoenix.WasmModuleInfoTest do
     end
 
     test "total WASM size is under 2MB" do
-      total = Enum.reduce(@expected_modules, 0, fn {file, _}, acc ->
-        path = Path.join(@fixtures_dir, file)
-        acc + File.stat!(path).size
-      end)
+      total =
+        Enum.reduce(@expected_modules, 0, fn {file, _}, acc ->
+          path = Path.join(@fixtures_dir, file)
+          acc + File.stat!(path).size
+        end)
 
       assert total < 2 * 1024 * 1024,
-        "Total WASM size #{div(total, 1024)}KB exceeds 2MB"
+             "Total WASM size #{div(total, 1024)}KB exceeds 2MB"
 
       # Report sizes
       IO.puts("\n📦 Phoenix WASM Module Sizes:")
+
       for {file, _} <- @expected_modules |> Enum.sort() do
         path = Path.join(@fixtures_dir, file)
         size = File.stat!(path).size
         IO.puts("  #{String.pad_trailing(file, 30)} #{div(size, 1024)} KB")
       end
+
       IO.puts("  #{String.pad_trailing("TOTAL", 30)} #{div(total, 1024)} KB")
     end
   end
diff --git a/test/phoenix/websocket_test.exs b/test/phoenix/websocket_test.exs
index fd5c9ae..84046be 100644
--- a/test/phoenix/websocket_test.exs
+++ b/test/phoenix/websocket_test.exs
@@ -10,6 +10,7 @@ defmodule Firebird.Phoenix.WebSocketTest do
         "connection" => "Upgrade",
         "sec-websocket-key" => "dGhlIHNhbXBsZSBub25jZQ=="
       }
+
       assert WebSocket.upgrade_request?(headers) == true
     end
 
@@ -18,6 +19,7 @@ defmodule Firebird.Phoenix.WebSocketTest do
         "connection" => "Upgrade",
         "sec-websocket-key" => "dGhlIHNhbXBsZSBub25jZQ=="
       }
+
       assert WebSocket.upgrade_request?(headers) == false
     end
 
@@ -26,6 +28,7 @@ defmodule Firebird.Phoenix.WebSocketTest do
         "upgrade" => "websocket",
         "sec-websocket-key" => "dGhlIHNhbXBsZSBub25jZQ=="
       }
+
       assert WebSocket.upgrade_request?(headers) == false
     end
 
@@ -34,6 +37,7 @@ defmodule Firebird.Phoenix.WebSocketTest do
         "upgrade" => "websocket",
         "connection" => "Upgrade"
       }
+
       assert WebSocket.upgrade_request?(headers) == false
     end
 
@@ -47,6 +51,7 @@ defmodule Firebird.Phoenix.WebSocketTest do
         "connection" => "upgrade",
         "sec-websocket-key" => "key123"
       }
+
       assert WebSocket.upgrade_request?(headers) == true
     end
 
@@ -56,6 +61,7 @@ defmodule Firebird.Phoenix.WebSocketTest do
         "connection" => "keep-alive, Upgrade",
         "sec-websocket-key" => "key123"
       }
+
       assert WebSocket.upgrade_request?(headers) == true
     end
   end
@@ -64,8 +70,10 @@ defmodule Firebird.Phoenix.WebSocketTest do
     test "generates correct accept key" do
       client_key = "dGhlIHNhbXBsZSBub25jZQ=="
       # SHA-1(key + magic_string) |> Base64
-      expected = :crypto.hash(:sha, client_key <> "258EAFA5-E914-47DA-95CA-5AB5DC85B175")
-                 |> Base.encode64()
+      expected =
+        :crypto.hash(:sha, client_key <> "258EAFA5-E914-47DA-95CA-5AB5DC85B175")
+        |> Base.encode64()
+
       assert WebSocket.accept_key(client_key) == expected
     end
 
@@ -218,11 +226,13 @@ defmodule Firebird.Phoenix.WebSocketTest do
 
     test "decodes masked frame (client-to-server)" do
       # Client frames are masked: FIN=1, opcode=text, MASK=1, len=5
-      mask_key = <<0x37, 0xfa, 0x21, 0x3d>>
+      mask_key = <<0x37, 0xFA, 0x21, 0x3D>>
       payload = "Hello"
-      masked = for {byte, i} <- Enum.with_index(:binary.bin_to_list(payload)),
-                   into: <<>>,
-                   do: <<Bitwise.bxor(byte, :binary.at(mask_key, rem(i, 4)))>>
+
+      masked =
+        for {byte, i} <- Enum.with_index(:binary.bin_to_list(payload)),
+            into: <<>>,
+            do: <<Bitwise.bxor(byte, :binary.at(mask_key, rem(i, 4)))>>
 
       frame = <<0x81, 0x85>> <> mask_key <> masked
       assert {:ok, {:text, "Hello"}, <<>>} = WebSocket.decode_frame(frame)
@@ -240,8 +250,9 @@ defmodule Firebird.Phoenix.WebSocketTest do
     end
 
     test "encodes event with payload" do
-      frame = WebSocket.encode_channel_message("room:lobby", "new_msg",
-        %{"body" => "hello"}, ref: "2")
+      frame =
+        WebSocket.encode_channel_message("room:lobby", "new_msg", %{"body" => "hello"}, ref: "2")
+
       {:ok, {:text, json}, <<>>} = WebSocket.decode_frame(frame)
       {:ok, decoded} = Jason.decode(json)
       assert decoded["payload"]["body"] == "hello"
@@ -256,8 +267,7 @@ defmodule Firebird.Phoenix.WebSocketTest do
     end
 
     test "includes join_ref when provided" do
-      frame = WebSocket.encode_channel_message("room:1", "msg", %{},
-        ref: "5", join_ref: "3")
+      frame = WebSocket.encode_channel_message("room:1", "msg", %{}, ref: "5", join_ref: "3")
       {:ok, {:text, json}, <<>>} = WebSocket.decode_frame(frame)
       {:ok, decoded} = Jason.decode(json)
       assert decoded["join_ref"] == "3"
@@ -274,12 +284,13 @@ defmodule Firebird.Phoenix.WebSocketTest do
 
   describe "decode_channel_message/1" do
     test "decodes valid channel message" do
-      json = Jason.encode!(%{
-        "topic" => "room:lobby",
-        "event" => "new_msg",
-        "payload" => %{"body" => "hello"},
-        "ref" => "1"
-      })
+      json =
+        Jason.encode!(%{
+          "topic" => "room:lobby",
+          "event" => "new_msg",
+          "payload" => %{"body" => "hello"},
+          "ref" => "1"
+        })
 
       assert {:ok, msg} = WebSocket.decode_channel_message(json)
       assert msg.topic == "room:lobby"
diff --git a/test/phoenix/websocket_wasm_test.exs b/test/phoenix/websocket_wasm_test.exs
index 94ad642..03e1e2f 100644
--- a/test/phoenix/websocket_wasm_test.exs
+++ b/test/phoenix/websocket_wasm_test.exs
@@ -15,7 +15,9 @@ defmodule Firebird.Phoenix.WebSocketWasmTest do
 
   describe "is_upgrade?/2" do
     test "detects WebSocket upgrade request", %{ws: ws} do
-      headers = "Upgrade: websocket\nConnection: Upgrade\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ=="
+      headers =
+        "Upgrade: websocket\nConnection: Upgrade\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ=="
+
       {:ok, true, key} = WebSocketWasm.is_upgrade?(ws, headers)
       assert key == "dGhlIHNhbXBsZSBub25jZQ=="
     end
@@ -36,6 +38,7 @@ defmodule Firebird.Phoenix.WebSocketWasmTest do
         "Connection" => "Upgrade",
         "Sec-WebSocket-Key" => "testkey123"
       }
+
       {:ok, true, key} = WebSocketWasm.is_upgrade?(ws, headers)
       assert key == "testkey123"
     end
@@ -138,7 +141,8 @@ defmodule Firebird.Phoenix.WebSocketWasmTest do
       mask_bytes = [0x37, 0xFA, 0x21, 0x3D]
       payload_bytes = :binary.bin_to_list("Hello")
 
-      masked_bytes = payload_bytes
+      masked_bytes =
+        payload_bytes
         |> Enum.with_index()
         |> Enum.map(fn {b, i} -> bxor(b, Enum.at(mask_bytes, rem(i, 4))) end)
 
@@ -173,7 +177,9 @@ defmodule Firebird.Phoenix.WebSocketWasmTest do
 
   describe "Phoenix Channel messages" do
     test "serializes a join message", %{ws: ws} do
-      {:ok, json} = WebSocketWasm.serialize_channel_msg(ws, "1", "1", "room:lobby", "phx_join", ~s({}))
+      {:ok, json} =
+        WebSocketWasm.serialize_channel_msg(ws, "1", "1", "room:lobby", "phx_join", ~s({}))
+
       assert json =~ "room:lobby"
       assert json =~ "phx_join"
       assert String.starts_with?(json, "[")
@@ -181,7 +187,16 @@ defmodule Firebird.Phoenix.WebSocketWasmTest do
     end
 
     test "serializes with null join_ref", %{ws: ws} do
-      {:ok, json} = WebSocketWasm.serialize_channel_msg(ws, nil, "2", "room:lobby", "new_msg", ~s({"body":"hi"}))
+      {:ok, json} =
+        WebSocketWasm.serialize_channel_msg(
+          ws,
+          nil,
+          "2",
+          "room:lobby",
+          "new_msg",
+          ~s({"body":"hi"})
+        )
+
       assert json =~ "null"
       assert json =~ "new_msg"
     end
@@ -206,7 +221,16 @@ defmodule Firebird.Phoenix.WebSocketWasmTest do
     end
 
     test "round-trip serialization", %{ws: ws} do
-      {:ok, json} = WebSocketWasm.serialize_channel_msg(ws, "1", "5", "chat:room1", "new_msg", ~s({"text":"hello"}))
+      {:ok, json} =
+        WebSocketWasm.serialize_channel_msg(
+          ws,
+          "1",
+          "5",
+          "chat:room1",
+          "new_msg",
+          ~s({"text":"hello"})
+        )
+
       {:ok, msg} = WebSocketWasm.deserialize_channel_msg(ws, json)
       assert msg.topic == "chat:room1"
       assert msg.event == "new_msg"
diff --git a/test/phoenix_test.exs b/test/phoenix_test.exs
index 44f60b3..79682a5 100644
--- a/test/phoenix_test.exs
+++ b/test/phoenix_test.exs
@@ -22,11 +22,23 @@ defmodule Firebird.PhoenixTest do
     test "starts all 10 components when available" do
       {:ok, components} = Firebird.Phoenix.start()
       # These should all be present based on fixtures dir
-      for key <- [:router, :template, :plug, :endpoint, :view, :channel, :json, :session, :live, :controller] do
+      for key <- [
+            :router,
+            :template,
+            :plug,
+            :endpoint,
+            :view,
+            :channel,
+            :json,
+            :session,
+            :live,
+            :controller
+          ] do
         assert Map.has_key?(components, key), "Missing component: #{key}"
         assert is_pid(components[key]), "#{key} is not a pid"
         assert Process.alive?(components[key]), "#{key} is not alive"
       end
+
       Firebird.Phoenix.stop(components)
     end
 
@@ -42,20 +54,24 @@ defmodule Firebird.PhoenixTest do
     end
 
     test "starts with custom WASM paths" do
-      assert {:ok, components} = Firebird.Phoenix.start(
-        router: Path.join(@fixtures_dir, "phoenix_router.wasm"),
-        template: Path.join(@fixtures_dir, "phoenix_template.wasm"),
-        plug: Path.join(@fixtures_dir, "phoenix_plug.wasm"),
-        endpoint: Path.join(@fixtures_dir, "phoenix_endpoint.wasm")
-      )
+      assert {:ok, components} =
+               Firebird.Phoenix.start(
+                 router: Path.join(@fixtures_dir, "phoenix_router.wasm"),
+                 template: Path.join(@fixtures_dir, "phoenix_template.wasm"),
+                 plug: Path.join(@fixtures_dir, "phoenix_plug.wasm"),
+                 endpoint: Path.join(@fixtures_dir, "phoenix_endpoint.wasm")
+               )
+
       Firebird.Phoenix.stop(components)
     end
 
     test "skips components with missing WASM files" do
-      {:ok, components} = Firebird.Phoenix.start(
-        router: "/nonexistent/router.wasm",
-        only: [:router]
-      )
+      {:ok, components} =
+        Firebird.Phoenix.start(
+          router: "/nonexistent/router.wasm",
+          only: [:router]
+        )
+
       # Missing files are skipped, resulting in empty components
       refute Map.has_key?(components, :router)
       Firebird.Phoenix.stop(components)
@@ -110,13 +126,14 @@ defmodule Firebird.PhoenixTest do
         "UserController.show" => {200, "application/json", ~s({"id":"{{id}}"})}
       }
 
-      {:ok, resp} = Firebird.Phoenix.process_request(components,
-        method: "GET",
-        path: "/users/42",
-        headers: %{"host" => "localhost"},
-        routes: routes,
-        actions: actions
-      )
+      {:ok, resp} =
+        Firebird.Phoenix.process_request(components,
+          method: "GET",
+          path: "/users/42",
+          headers: %{"host" => "localhost"},
+          routes: routes,
+          actions: actions
+        )
 
       assert resp.status == 200
       assert resp.body =~ "42"
@@ -126,12 +143,13 @@ defmodule Firebird.PhoenixTest do
     test "returns 404 for unmatched routes" do
       {:ok, components} = Firebird.Phoenix.start(only: [:router, :endpoint])
 
-      {:ok, resp} = Firebird.Phoenix.process_request(components,
-        method: "GET",
-        path: "/nonexistent",
-        routes: [{"GET", "/users", "UserController.index"}],
-        actions: %{"UserController.index" => {200, "text/html", "<h1>Users</h1>"}}
-      )
+      {:ok, resp} =
+        Firebird.Phoenix.process_request(components,
+          method: "GET",
+          path: "/nonexistent",
+          routes: [{"GET", "/users", "UserController.index"}],
+          actions: %{"UserController.index" => {200, "text/html", "<h1>Users</h1>"}}
+        )
 
       assert resp.status == 404
       Firebird.Phoenix.stop(components)
@@ -143,12 +161,13 @@ defmodule Firebird.PhoenixTest do
       routes = [{"GET", "/hello", "HelloController.index"}]
       actions = %{"HelloController.index" => {200, "text/plain", "Hello!"}}
 
-      {:ok, resp} = Firebird.Phoenix.process_request(components,
-        method: "GET",
-        path: "/hello",
-        routes: routes,
-        actions: actions
-      )
+      {:ok, resp} =
+        Firebird.Phoenix.process_request(components,
+          method: "GET",
+          path: "/hello",
+          routes: routes,
+          actions: actions
+        )
 
       assert resp.status == 200
       assert resp.body == "Hello!"
@@ -157,7 +176,7 @@ defmodule Firebird.PhoenixTest do
 
     test "returns error with no router or endpoint" do
       assert {:error, :no_endpoint_or_router} =
-        Firebird.Phoenix.process_request(%{}, method: "GET", path: "/")
+               Firebird.Phoenix.process_request(%{}, method: "GET", path: "/")
     end
   end
 end
diff --git a/test/pipeline_edge_cases_test.exs b/test/pipeline_edge_cases_test.exs
index 7dda241..f9f5085 100644
--- a/test/pipeline_edge_cases_test.exs
+++ b/test/pipeline_edge_cases_test.exs
@@ -16,8 +16,10 @@ defmodule Firebird.PipelineEdgeCasesTest do
       # When no args specified, previous result is used directly
       result =
         Pipeline.new(w)
-        |> Pipeline.call(:add, [10, 20])          # => [30]
-        |> Pipeline.call(:fibonacci)               # => fib(30) using prev result
+        # => [30]
+        |> Pipeline.call(:add, [10, 20])
+        # => fib(30) using prev result
+        |> Pipeline.call(:fibonacci)
         |> Pipeline.run()
 
       assert {:ok, [_]} = result
@@ -27,9 +29,12 @@ defmodule Firebird.PipelineEdgeCasesTest do
       # First :_ gets index 0, second gets index 1 from prev result
       result =
         Pipeline.new(w)
-        |> Pipeline.call(:add, [10, 20])                # => [30]
-        |> Pipeline.transform(fn [x] -> [x, 2] end)     # => [30, 2]
-        |> Pipeline.call(:multiply, [:_, :_])            # multiply(30, 2) => [60]
+        # => [30]
+        |> Pipeline.call(:add, [10, 20])
+        # => [30, 2]
+        |> Pipeline.transform(fn [x] -> [x, 2] end)
+        # multiply(30, 2) => [60]
+        |> Pipeline.call(:multiply, [:_, :_])
         |> Pipeline.run()
 
       assert {:ok, [60]} = result
@@ -40,8 +45,10 @@ defmodule Firebird.PipelineEdgeCasesTest do
       # second :_ tries index 1 which doesn't exist, falls back to 0
       result =
         Pipeline.new(w)
-        |> Pipeline.call(:add, [3, 2])            # => [5]
-        |> Pipeline.call(:add, [:_, :_])           # add(5, 0) since second :_ is out of bounds
+        # => [5]
+        |> Pipeline.call(:add, [3, 2])
+        # add(5, 0) since second :_ is out of bounds
+        |> Pipeline.call(:add, [:_, :_])
         |> Pipeline.run()
 
       assert {:ok, [5]} = result
@@ -50,8 +57,10 @@ defmodule Firebird.PipelineEdgeCasesTest do
     test "mixed :_ and literal args", %{wasm: w} do
       result =
         Pipeline.new(w)
-        |> Pipeline.call(:add, [10, 20])          # => [30]
-        |> Pipeline.call(:multiply, [:_, 3])      # multiply(30, 3) => [90]
+        # => [30]
+        |> Pipeline.call(:add, [10, 20])
+        # multiply(30, 3) => [90]
+        |> Pipeline.call(:multiply, [:_, 3])
         |> Pipeline.run()
 
       assert {:ok, [90]} = result
@@ -60,8 +69,10 @@ defmodule Firebird.PipelineEdgeCasesTest do
     test "literal args don't advance :_ index", %{wasm: w} do
       result =
         Pipeline.new(w)
-        |> Pipeline.call(:add, [10, 20])          # => [30]
-        |> Pipeline.call(:add, [5, :_])           # add(5, 30) => [35]
+        # => [30]
+        |> Pipeline.call(:add, [10, 20])
+        # add(5, 30) => [35]
+        |> Pipeline.call(:add, [5, :_])
         |> Pipeline.run()
 
       assert {:ok, [35]} = result
@@ -172,12 +183,18 @@ defmodule Firebird.PipelineEdgeCasesTest do
     test "many chained operations", %{wasm: w} do
       result =
         Pipeline.new(w)
-        |> Pipeline.call(:add, [1, 1])            # 2
-        |> Pipeline.call(:multiply, [:_, 2])       # 4
-        |> Pipeline.call(:multiply, [:_, 2])       # 8
-        |> Pipeline.call(:multiply, [:_, 2])       # 16
-        |> Pipeline.call(:multiply, [:_, 2])       # 32
-        |> Pipeline.call(:multiply, [:_, 2])       # 64
+        # 2
+        |> Pipeline.call(:add, [1, 1])
+        # 4
+        |> Pipeline.call(:multiply, [:_, 2])
+        # 8
+        |> Pipeline.call(:multiply, [:_, 2])
+        # 16
+        |> Pipeline.call(:multiply, [:_, 2])
+        # 32
+        |> Pipeline.call(:multiply, [:_, 2])
+        # 64
+        |> Pipeline.call(:multiply, [:_, 2])
         |> Pipeline.run()
 
       assert {:ok, [64]} = result
diff --git a/test/pipeline_struct_test.exs b/test/pipeline_struct_test.exs
index 9a18cf5..dc49f42 100644
--- a/test/pipeline_struct_test.exs
+++ b/test/pipeline_struct_test.exs
@@ -135,9 +135,10 @@ defmodule Firebird.PipelineStructTest do
 
   describe "complex pipeline construction" do
     test "large pipeline with many steps" do
-      pipeline = Enum.reduce(1..100, Pipeline.new(self()), fn i, p ->
-        Pipeline.call(p, :func, [i])
-      end)
+      pipeline =
+        Enum.reduce(1..100, Pipeline.new(self()), fn i, p ->
+          Pipeline.call(p, :func, [i])
+        end)
 
       assert Pipeline.length(pipeline) == 100
     end
diff --git a/test/pipeline_test.exs b/test/pipeline_test.exs
index 603147d..03d4afa 100644
--- a/test/pipeline_test.exs
+++ b/test/pipeline_test.exs
@@ -31,6 +31,7 @@ defmodule Firebird.PipelineTest do
         Pipeline.new(w)
         |> Pipeline.call(:add, [5, 3])
         |> Pipeline.call(:multiply, [:_, 2])
+
       assert Pipeline.length(pipeline) == 2
     end
   end
@@ -48,8 +49,10 @@ defmodule Firebird.PipelineTest do
     test "chains add then multiply", %{wasm: w} do
       result =
         Pipeline.new(w)
-        |> Pipeline.call(:add, [5, 3])           # => [8]
-        |> Pipeline.call(:multiply, [:_, 2])      # => [16]
+        # => [8]
+        |> Pipeline.call(:add, [5, 3])
+        # => [16]
+        |> Pipeline.call(:multiply, [:_, 2])
         |> Pipeline.run()
 
       assert {:ok, [16]} = result
@@ -58,9 +61,12 @@ defmodule Firebird.PipelineTest do
     test "chains three operations", %{wasm: w} do
       result =
         Pipeline.new(w)
-        |> Pipeline.call(:add, [10, 20])          # => [30]
-        |> Pipeline.call(:multiply, [:_, 2])      # => [60]
-        |> Pipeline.call(:subtract, [:_, 10])     # => [50]
+        # => [30]
+        |> Pipeline.call(:add, [10, 20])
+        # => [60]
+        |> Pipeline.call(:multiply, [:_, 2])
+        # => [50]
+        |> Pipeline.call(:subtract, [:_, 10])
         |> Pipeline.run()
 
       assert {:ok, [50]} = result
@@ -69,8 +75,10 @@ defmodule Firebird.PipelineTest do
     test "fibonacci of add result", %{wasm: w} do
       result =
         Pipeline.new(w)
-        |> Pipeline.call(:add, [5, 5])            # => [10]
-        |> Pipeline.call(:fibonacci, [:_])         # => fib(10) = [55]
+        # => [10]
+        |> Pipeline.call(:add, [5, 5])
+        # => fib(10) = [55]
+        |> Pipeline.call(:fibonacci, [:_])
         |> Pipeline.run()
 
       assert {:ok, [55]} = result
@@ -79,8 +87,10 @@ defmodule Firebird.PipelineTest do
     test "factorial of small number", %{wasm: w} do
       result =
         Pipeline.new(w)
-        |> Pipeline.call(:add, [3, 2])            # => [5]
-        |> Pipeline.call(:factorial, [:_])         # => 120
+        # => [5]
+        |> Pipeline.call(:add, [3, 2])
+        # => 120
+        |> Pipeline.call(:factorial, [:_])
         |> Pipeline.run()
 
       assert {:ok, [120]} = result
@@ -135,8 +145,10 @@ defmodule Firebird.PipelineTest do
     test "transforms intermediate results", %{wasm: w} do
       result =
         Pipeline.new(w)
-        |> Pipeline.call(:add, [5, 3])            # => [8]
-        |> Pipeline.transform(fn [x] -> [x * 10] end)  # => [80]
+        # => [8]
+        |> Pipeline.call(:add, [5, 3])
+        # => [80]
+        |> Pipeline.transform(fn [x] -> [x * 10] end)
         |> Pipeline.call(:fibonacci, [:_])
         |> Pipeline.run()
 
@@ -147,9 +159,12 @@ defmodule Firebird.PipelineTest do
     test "transform can change arity", %{wasm: w} do
       result =
         Pipeline.new(w)
-        |> Pipeline.call(:add, [10, 20])          # => [30]
-        |> Pipeline.transform(fn [x] -> [x, x] end)  # => [30, 30]
-        |> Pipeline.call(:multiply, [:_, :_])     # => [900]
+        # => [30]
+        |> Pipeline.call(:add, [10, 20])
+        # => [30, 30]
+        |> Pipeline.transform(fn [x] -> [x, x] end)
+        # => [900]
+        |> Pipeline.call(:multiply, [:_, :_])
         |> Pipeline.run()
 
       assert {:ok, [900]} = result
@@ -187,9 +202,12 @@ defmodule Firebird.PipelineTest do
     test "gcd pipeline with transform", %{wasm: w} do
       result =
         Pipeline.new(w)
-        |> Pipeline.call(:add, [24, 24])          # => [48]
-        |> Pipeline.transform(fn [x] -> [x, 36] end)  # => [48, 36]
-        |> Pipeline.call(:gcd, [:_, :_])          # => gcd(48, 36) = [12]
+        # => [48]
+        |> Pipeline.call(:add, [24, 24])
+        # => [48, 36]
+        |> Pipeline.transform(fn [x] -> [x, 36] end)
+        # => gcd(48, 36) = [12]
+        |> Pipeline.call(:gcd, [:_, :_])
         |> Pipeline.run()
 
       assert {:ok, [12]} = result
@@ -198,8 +216,10 @@ defmodule Firebird.PipelineTest do
     test "is_prime check on computed value", %{wasm: w} do
       result =
         Pipeline.new(w)
-        |> Pipeline.call(:add, [4, 3])            # => [7]
-        |> Pipeline.call(:is_prime, [:_])          # => [1] (7 is prime)
+        # => [7]
+        |> Pipeline.call(:add, [4, 3])
+        # => [1] (7 is prime)
+        |> Pipeline.call(:is_prime, [:_])
         |> Pipeline.run()
 
       assert {:ok, [1]} = result
@@ -208,8 +228,10 @@ defmodule Firebird.PipelineTest do
     test "is_prime check on non-prime", %{wasm: w} do
       result =
         Pipeline.new(w)
-        |> Pipeline.call(:add, [4, 4])            # => [8]
-        |> Pipeline.call(:is_prime, [:_])          # => [0] (8 is not prime)
+        # => [8]
+        |> Pipeline.call(:add, [4, 4])
+        # => [0] (8 is not prime)
+        |> Pipeline.call(:is_prime, [:_])
         |> Pipeline.run()
 
       assert {:ok, [0]} = result
diff --git a/test/pool_call_many_test.exs b/test/pool_call_many_test.exs
new file mode 100644
index 0000000..1bfba58
--- /dev/null
+++ b/test/pool_call_many_test.exs
@@ -0,0 +1,236 @@
+defmodule Firebird.Pool.CallManyTest do
+  use ExUnit.Case
+
+  @math_wasm "fixtures/math.wasm"
+
+  describe "call_many/2" do
+    test "executes multiple calls and returns all results" do
+      {:ok, pool} = Firebird.Pool.start_link(wasm: @math_wasm, size: 2)
+
+      {:ok, results} =
+        Firebird.Pool.call_many(pool, [
+          {:add, [5, 3]},
+          {:add, [10, 20]},
+          {:add, [1, 1]}
+        ])
+
+      assert results == [[8], [30], [2]]
+      Firebird.Pool.stop(pool)
+    end
+
+    test "returns results in order" do
+      {:ok, pool} = Firebird.Pool.start_link(wasm: @math_wasm, size: 2)
+
+      {:ok, results} =
+        Firebird.Pool.call_many(pool, [
+          {:add, [1, 0]},
+          {:add, [2, 0]},
+          {:add, [3, 0]},
+          {:add, [4, 0]},
+          {:add, [5, 0]}
+        ])
+
+      assert results == [[1], [2], [3], [4], [5]]
+      Firebird.Pool.stop(pool)
+    end
+
+    test "handles single call" do
+      {:ok, pool} = Firebird.Pool.start_link(wasm: @math_wasm, size: 2)
+      {:ok, results} = Firebird.Pool.call_many(pool, [{:add, [5, 3]}])
+      assert results == [[8]]
+      Firebird.Pool.stop(pool)
+    end
+
+    test "handles empty call list" do
+      {:ok, pool} = Firebird.Pool.start_link(wasm: @math_wasm, size: 2)
+      {:ok, results} = Firebird.Pool.call_many(pool, [])
+      assert results == []
+      Firebird.Pool.stop(pool)
+    end
+
+    test "stops on first error" do
+      {:ok, pool} = Firebird.Pool.start_link(wasm: @math_wasm, size: 2)
+
+      result =
+        Firebird.Pool.call_many(pool, [
+          {:add, [5, 3]},
+          {:nonexistent_function, [1, 2]},
+          {:add, [10, 20]}
+        ])
+
+      assert {:error, _reason} = result
+      Firebird.Pool.stop(pool)
+    end
+
+    test "checks instance back in even on error" do
+      {:ok, pool} = Firebird.Pool.start_link(wasm: @math_wasm, size: 2)
+
+      # Trigger an error
+      _result =
+        Firebird.Pool.call_many(pool, [
+          {:nonexistent_function, [1]}
+        ])
+
+      # Pool should still be usable
+      {:ok, [8]} = Firebird.Pool.call(pool, :add, [5, 3])
+      Firebird.Pool.stop(pool)
+    end
+
+    test "works with mixed function calls" do
+      {:ok, pool} = Firebird.Pool.start_link(wasm: @math_wasm, size: 2)
+
+      {:ok, results} =
+        Firebird.Pool.call_many(pool, [
+          {:add, [5, 3]},
+          {:multiply, [4, 7]},
+          {:add, [100, 200]}
+        ])
+
+      assert results == [[8], [28], [300]]
+      Firebird.Pool.stop(pool)
+    end
+
+    test "works with string function names" do
+      {:ok, pool} = Firebird.Pool.start_link(wasm: @math_wasm, size: 2)
+
+      {:ok, results} =
+        Firebird.Pool.call_many(pool, [
+          {"add", [5, 3]},
+          {"multiply", [4, 7]}
+        ])
+
+      assert results == [[8], [28]]
+      Firebird.Pool.stop(pool)
+    end
+  end
+
+  describe "call_many!/2" do
+    test "returns raw results on success" do
+      {:ok, pool} = Firebird.Pool.start_link(wasm: @math_wasm, size: 2)
+
+      results =
+        Firebird.Pool.call_many!(pool, [
+          {:add, [5, 3]},
+          {:multiply, [4, 7]}
+        ])
+
+      assert results == [[8], [28]]
+      Firebird.Pool.stop(pool)
+    end
+
+    test "raises on error" do
+      {:ok, pool} = Firebird.Pool.start_link(wasm: @math_wasm, size: 2)
+
+      assert_raise RuntimeError, ~r/call_many failed/, fn ->
+        Firebird.Pool.call_many!(pool, [
+          {:nonexistent_function, [1]}
+        ])
+      end
+
+      Firebird.Pool.stop(pool)
+    end
+  end
+
+  describe "call_many_unwrapped/2" do
+    test "unwraps single-value results" do
+      {:ok, pool} = Firebird.Pool.start_link(wasm: @math_wasm, size: 2)
+
+      {:ok, results} =
+        Firebird.Pool.call_many_unwrapped(pool, [
+          {:add, [5, 3]},
+          {:multiply, [4, 7]},
+          {:add, [100, 200]}
+        ])
+
+      assert results == [8, 28, 300]
+      Firebird.Pool.stop(pool)
+    end
+
+    test "handles empty list" do
+      {:ok, pool} = Firebird.Pool.start_link(wasm: @math_wasm, size: 2)
+      {:ok, results} = Firebird.Pool.call_many_unwrapped(pool, [])
+      assert results == []
+      Firebird.Pool.stop(pool)
+    end
+
+    test "returns error on failure" do
+      {:ok, pool} = Firebird.Pool.start_link(wasm: @math_wasm, size: 2)
+
+      result =
+        Firebird.Pool.call_many_unwrapped(pool, [
+          {:nonexistent_function, [1]}
+        ])
+
+      assert {:error, _} = result
+      Firebird.Pool.stop(pool)
+    end
+  end
+
+  describe "call_many vs repeated call (correctness)" do
+    test "produces same results as individual calls" do
+      {:ok, pool} = Firebird.Pool.start_link(wasm: @math_wasm, size: 2)
+
+      calls = [
+        {:add, [1, 2]},
+        {:add, [10, 20]},
+        {:multiply, [3, 4]},
+        {:multiply, [5, 6]},
+        {:add, [0, 0]}
+      ]
+
+      # Individual calls
+      individual =
+        Enum.map(calls, fn {func, args} ->
+          {:ok, result} = Firebird.Pool.call(pool, func, args)
+          result
+        end)
+
+      # Batch call
+      {:ok, batch} = Firebird.Pool.call_many(pool, calls)
+
+      assert individual == batch
+      Firebird.Pool.stop(pool)
+    end
+  end
+
+  describe "concurrent call_many" do
+    test "multiple concurrent call_many batches work correctly" do
+      {:ok, pool} = Firebird.Pool.start_link(wasm: @math_wasm, size: 2)
+
+      tasks =
+        for i <- 1..10 do
+          Task.async(fn ->
+            {:ok, results} =
+              Firebird.Pool.call_many(pool, [
+                {:add, [i, i]},
+                {:multiply, [i, 2]}
+              ])
+
+            {i, results}
+          end)
+        end
+
+      results = Task.await_many(tasks, 5000)
+
+      for {i, [add_result, mul_result]} <- results do
+        assert add_result == [i + i], "add(#{i}, #{i}) should be #{i + i}"
+        assert mul_result == [i * 2], "multiply(#{i}, 2) should be #{i * 2}"
+      end
+
+      Firebird.Pool.stop(pool)
+    end
+  end
+
+  describe "call_many large batch" do
+    test "handles 100 calls in one batch" do
+      {:ok, pool} = Firebird.Pool.start_link(wasm: @math_wasm, size: 2)
+
+      calls = for i <- 1..100, do: {:add, [i, 1]}
+      {:ok, results} = Firebird.Pool.call_many(pool, calls)
+
+      expected = for i <- 1..100, do: [i + 1]
+      assert results == expected
+      Firebird.Pool.stop(pool)
+    end
+  end
+end
diff --git a/test/pool_call_one_test.exs b/test/pool_call_one_test.exs
index f2b9ab8..a92656f 100644
--- a/test/pool_call_one_test.exs
+++ b/test/pool_call_one_test.exs
@@ -5,9 +5,11 @@ defmodule Firebird.PoolCallOneTest do
 
   setup do
     {:ok, pool} = Firebird.Pool.start_link(wasm: @sample_path, size: 2)
+
     on_exit(fn ->
       if Process.alive?(pool), do: Firebird.Pool.stop(pool)
     end)
+
     {:ok, pool: pool}
   end
 
diff --git a/test/pool_comprehensive_edge_cases_test.exs b/test/pool_comprehensive_edge_cases_test.exs
index 9395f05..e42864e 100644
--- a/test/pool_comprehensive_edge_cases_test.exs
+++ b/test/pool_comprehensive_edge_cases_test.exs
@@ -308,18 +308,19 @@ defmodule Firebird.PoolComprehensiveEdgeCasesTest do
     test "handles burst of concurrent calls" do
       {:ok, pool} = Pool.start_link(wasm: @math_wasm, size: 4)
 
-      tasks = for i <- 1..100 do
-        Task.async(fn ->
-          {:ok, [result]} = Pool.call(pool, :add, [i, i])
-          result
-        end)
-      end
+      tasks =
+        for i <- 1..100 do
+          Task.async(fn ->
+            {:ok, [result]} = Pool.call(pool, :add, [i, i])
+            result
+          end)
+        end
 
       results = Task.await_many(tasks, 30_000)
       assert length(results) == 100
 
       for i <- 1..100 do
-        assert i * 2 in results
+        assert (i * 2) in results
       end
 
       Pool.stop(pool)
@@ -328,16 +329,18 @@ defmodule Firebird.PoolComprehensiveEdgeCasesTest do
     test "handles concurrent mixed function calls" do
       {:ok, pool} = Pool.start_link(wasm: @math_wasm, size: 4)
 
-      tasks = for i <- 1..30 do
-        Task.async(fn ->
-          case rem(i, 3) do
-            0 -> {:ok, _} = Pool.call(pool, :add, [i, i])
-            1 -> {:ok, _} = Pool.call(pool, :multiply, [i, 2])
-            2 -> {:ok, _} = Pool.call(pool, :fibonacci, [rem(i, 15)])
-          end
-          :ok
-        end)
-      end
+      tasks =
+        for i <- 1..30 do
+          Task.async(fn ->
+            case rem(i, 3) do
+              0 -> {:ok, _} = Pool.call(pool, :add, [i, i])
+              1 -> {:ok, _} = Pool.call(pool, :multiply, [i, 2])
+              2 -> {:ok, _} = Pool.call(pool, :fibonacci, [rem(i, 15)])
+            end
+
+            :ok
+          end)
+        end
 
       results = Task.await_many(tasks, 30_000)
       assert Enum.all?(results, &(&1 == :ok))
@@ -348,22 +351,24 @@ defmodule Firebird.PoolComprehensiveEdgeCasesTest do
     test "concurrent calls with errors don't crash pool" do
       {:ok, pool} = Pool.start_link(wasm: @math_wasm, size: 2)
 
-      tasks = for i <- 1..20 do
-        Task.async(fn ->
-          if rem(i, 4) == 0 do
-            Pool.call(pool, :nonexistent, [i])
-          else
-            Pool.call(pool, :add, [i, i])
-          end
-        end)
-      end
+      tasks =
+        for i <- 1..20 do
+          Task.async(fn ->
+            if rem(i, 4) == 0 do
+              Pool.call(pool, :nonexistent, [i])
+            else
+              Pool.call(pool, :add, [i, i])
+            end
+          end)
+        end
 
       results = Task.await_many(tasks, 30_000)
       assert length(results) == 20
 
       successes = Enum.count(results, &match?({:ok, _}, &1))
       errors = Enum.count(results, &match?({:error, _}, &1))
-      assert successes == 15  # 20 - 5 error calls (i=4,8,12,16,20)
+      # 20 - 5 error calls (i=4,8,12,16,20)
+      assert successes == 15
       assert errors == 5
 
       Pool.stop(pool)
@@ -386,12 +391,13 @@ defmodule Firebird.PoolComprehensiveEdgeCasesTest do
     test "Go WASM pool handles concurrent calls" do
       {:ok, pool} = Pool.start_link(wasm: @go_wasm, size: 2, wasi: true)
 
-      tasks = for i <- 1..10 do
-        Task.async(fn ->
-          {:ok, [result]} = Pool.call(pool, :add, [i, i])
-          result
-        end)
-      end
+      tasks =
+        for i <- 1..10 do
+          Task.async(fn ->
+            {:ok, [result]} = Pool.call(pool, :add, [i, i])
+            result
+          end)
+        end
 
       results = Task.await_many(tasks, 30_000)
       expected = for i <- 1..10, do: i * 2
diff --git a/test/pool_edge_cases_test.exs b/test/pool_edge_cases_test.exs
index 835b02f..0ca101a 100644
--- a/test/pool_edge_cases_test.exs
+++ b/test/pool_edge_cases_test.exs
@@ -17,12 +17,13 @@ defmodule Firebird.PoolEdgeCasesTest do
     test "handles 100 concurrent calls" do
       {:ok, pool} = Firebird.Pool.start_link(wasm_path: @fixture_path, pool_size: 4)
 
-      tasks = for i <- 1..100 do
-        Task.async(fn ->
-          {:ok, [result]} = Firebird.Pool.call(pool, :add, [i, i])
-          result
-        end)
-      end
+      tasks =
+        for i <- 1..100 do
+          Task.async(fn ->
+            {:ok, [result]} = Firebird.Pool.call(pool, :add, [i, i])
+            result
+          end)
+        end
 
       results = Task.await_many(tasks, 10_000)
       expected = for i <- 1..100, do: i * 2
@@ -65,9 +66,11 @@ defmodule Firebird.PoolEdgeCasesTest do
 
     test "raises on nonexistent function" do
       {:ok, pool} = Firebird.Pool.start_link(wasm_path: @fixture_path, pool_size: 1)
+
       assert_raise RuntimeError, ~r/pool call failed/, fn ->
         Firebird.Pool.call!(pool, :nope, [1])
       end
+
       Firebird.Pool.stop(pool)
     end
   end
@@ -89,10 +92,11 @@ defmodule Firebird.PoolEdgeCasesTest do
     test "fibonacci through pool" do
       {:ok, pool} = Firebird.Pool.start_link(wasm_path: @fixture_path, pool_size: 2)
 
-      results = for n <- 0..10 do
-        {:ok, [result]} = Firebird.Pool.call(pool, :fibonacci, [n])
-        result
-      end
+      results =
+        for n <- 0..10 do
+          {:ok, [result]} = Firebird.Pool.call(pool, :fibonacci, [n])
+          result
+        end
 
       expected = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
       assert results == expected
diff --git a/test/pool_idle_checkout_test.exs b/test/pool_idle_checkout_test.exs
index 70465fc..7967d5e 100644
--- a/test/pool_idle_checkout_test.exs
+++ b/test/pool_idle_checkout_test.exs
@@ -81,10 +81,11 @@ defmodule Firebird.PoolIdleCheckoutTest do
     test "with_memory tracks busy correctly" do
       {:ok, pool} = Firebird.Pool.start_link(wasm: @fixture_path, size: 2)
 
-      {:ok, result} = Firebird.Pool.with_memory(pool, fn pid, _mem ->
-        {:ok, [r]} = Firebird.call(pid, :add, [10, 20])
-        r
-      end)
+      {:ok, result} =
+        Firebird.Pool.with_memory(pool, fn pid, _mem ->
+          {:ok, [r]} = Firebird.call(pid, :add, [10, 20])
+          r
+        end)
 
       assert result == 30
 
diff --git a/test/pool_memory_test.exs b/test/pool_memory_test.exs
index c4a0fc4..94a71e5 100644
--- a/test/pool_memory_test.exs
+++ b/test/pool_memory_test.exs
@@ -19,12 +19,13 @@ defmodule Firebird.PoolMemoryTest do
     test "provides instance and memory allocator to callback" do
       {:ok, pool} = start_pool("rust_math.wasm")
 
-      {:ok, result} = Firebird.Pool.with_memory(pool, fn pid, mem ->
-        assert is_pid(pid)
-        assert %Firebird.Memory{} = mem
-        assert mem.instance == pid
-        :got_both
-      end)
+      {:ok, result} =
+        Firebird.Pool.with_memory(pool, fn pid, mem ->
+          assert is_pid(pid)
+          assert %Firebird.Memory{} = mem
+          assert mem.instance == pid
+          :got_both
+        end)
 
       assert result == :got_both
       Firebird.Pool.stop(pool)
@@ -33,11 +34,12 @@ defmodule Firebird.PoolMemoryTest do
     test "can write and read i32 values through memory" do
       {:ok, pool} = start_pool("rust_math.wasm")
 
-      {:ok, result} = Firebird.Pool.with_memory(pool, fn _pid, mem ->
-        {mem, ptr} = Firebird.Memory.write_i32(mem, 42)
-        {:ok, val} = Firebird.Memory.read_i32(mem, ptr)
-        val
-      end)
+      {:ok, result} =
+        Firebird.Pool.with_memory(pool, fn _pid, mem ->
+          {mem, ptr} = Firebird.Memory.write_i32(mem, 42)
+          {:ok, val} = Firebird.Memory.read_i32(mem, ptr)
+          val
+        end)
 
       assert result == 42
       Firebird.Pool.stop(pool)
@@ -46,13 +48,14 @@ defmodule Firebird.PoolMemoryTest do
     test "can write and read i32 arrays through memory" do
       {:ok, pool} = start_pool("rust_math.wasm")
 
-      {:ok, result} = Firebird.Pool.with_memory(pool, fn _pid, mem ->
-        values = [10, 20, 30, 40, 50]
-        {mem, ptr, count} = Firebird.Memory.write_i32_array(mem, values)
-        assert count == 5
-        {:ok, read_back} = Firebird.Memory.read_i32_array(mem, ptr, count)
-        read_back
-      end)
+      {:ok, result} =
+        Firebird.Pool.with_memory(pool, fn _pid, mem ->
+          values = [10, 20, 30, 40, 50]
+          {mem, ptr, count} = Firebird.Memory.write_i32_array(mem, values)
+          assert count == 5
+          {:ok, read_back} = Firebird.Memory.read_i32_array(mem, ptr, count)
+          read_back
+        end)
 
       assert result == [10, 20, 30, 40, 50]
       Firebird.Pool.stop(pool)
@@ -61,12 +64,13 @@ defmodule Firebird.PoolMemoryTest do
     test "can write and read strings through memory" do
       {:ok, pool} = start_pool("rust_math.wasm")
 
-      {:ok, result} = Firebird.Pool.with_memory(pool, fn _pid, mem ->
-        {mem, ptr, len} = Firebird.Memory.write_string(mem, "hello world")
-        assert len == 11
-        {:ok, str} = Firebird.Memory.read_string(mem, ptr, len)
-        str
-      end)
+      {:ok, result} =
+        Firebird.Pool.with_memory(pool, fn _pid, mem ->
+          {mem, ptr, len} = Firebird.Memory.write_string(mem, "hello world")
+          assert len == 11
+          {:ok, str} = Firebird.Memory.read_string(mem, ptr, len)
+          str
+        end)
 
       assert result == "hello world"
       Firebird.Pool.stop(pool)
@@ -75,11 +79,12 @@ defmodule Firebird.PoolMemoryTest do
     test "can write and read f64 values through memory" do
       {:ok, pool} = start_pool("rust_math.wasm")
 
-      {:ok, result} = Firebird.Pool.with_memory(pool, fn _pid, mem ->
-        {mem, ptr} = Firebird.Memory.write_f64(mem, 3.14159)
-        {:ok, val} = Firebird.Memory.read_f64(mem, ptr)
-        val
-      end)
+      {:ok, result} =
+        Firebird.Pool.with_memory(pool, fn _pid, mem ->
+          {mem, ptr} = Firebird.Memory.write_f64(mem, 3.14159)
+          {:ok, val} = Firebird.Memory.read_f64(mem, ptr)
+          val
+        end)
 
       assert_in_delta result, 3.14159, 0.00001
       Firebird.Pool.stop(pool)
@@ -88,9 +93,10 @@ defmodule Firebird.PoolMemoryTest do
     test "handles callback errors gracefully" do
       {:ok, pool} = start_pool("rust_math.wasm")
 
-      result = Firebird.Pool.with_memory(pool, fn _pid, _mem ->
-        raise "intentional error"
-      end)
+      result =
+        Firebird.Pool.with_memory(pool, fn _pid, _mem ->
+          raise "intentional error"
+        end)
 
       assert {:error, "intentional error"} = result
 
@@ -103,15 +109,17 @@ defmodule Firebird.PoolMemoryTest do
       {:ok, pool} = start_pool("rust_math.wasm")
 
       # First call writes data
-      {:ok, _} = Firebird.Pool.with_memory(pool, fn _pid, mem ->
-        {_mem, _ptr, _len} = Firebird.Memory.write_string(mem, "first call data")
-        :ok
-      end)
+      {:ok, _} =
+        Firebird.Pool.with_memory(pool, fn _pid, mem ->
+          {_mem, _ptr, _len} = Firebird.Memory.write_string(mem, "first call data")
+          :ok
+        end)
 
       # Second call gets a fresh allocator (same base offset)
-      {:ok, info} = Firebird.Pool.with_memory(pool, fn _pid, mem ->
-        Firebird.Memory.info(mem)
-      end)
+      {:ok, info} =
+        Firebird.Pool.with_memory(pool, fn _pid, mem ->
+          Firebird.Memory.info(mem)
+        end)
 
       assert info.allocated_bytes == 0
       Firebird.Pool.stop(pool)
@@ -120,11 +128,12 @@ defmodule Firebird.PoolMemoryTest do
     test "accepts memory options" do
       {:ok, pool} = start_pool("rust_math.wasm")
 
-      {:ok, info} = Firebird.Pool.with_memory(pool, [base_offset: 4096, alignment: 16], fn _pid, mem ->
-        assert mem.base_offset == 4096
-        assert mem.alignment == 16
-        Firebird.Memory.info(mem)
-      end)
+      {:ok, info} =
+        Firebird.Pool.with_memory(pool, [base_offset: 4096, alignment: 16], fn _pid, mem ->
+          assert mem.base_offset == 4096
+          assert mem.alignment == 16
+          Firebird.Memory.info(mem)
+        end)
 
       assert info.base_offset == 4096
       assert info.alignment == 16
@@ -134,17 +143,20 @@ defmodule Firebird.PoolMemoryTest do
     test "concurrent with_memory calls work correctly" do
       {:ok, pool} = start_pool("rust_math.wasm", size: 4)
 
-      tasks = for i <- 1..20 do
-        Task.async(fn ->
-          {:ok, result} = Firebird.Pool.with_memory(pool, fn _pid, mem ->
-            values = Enum.to_list(1..i)
-            {mem, ptr, count} = Firebird.Memory.write_i32_array(mem, values)
-            {:ok, read_back} = Firebird.Memory.read_i32_array(mem, ptr, count)
-            read_back
+      tasks =
+        for i <- 1..20 do
+          Task.async(fn ->
+            {:ok, result} =
+              Firebird.Pool.with_memory(pool, fn _pid, mem ->
+                values = Enum.to_list(1..i)
+                {mem, ptr, count} = Firebird.Memory.write_i32_array(mem, values)
+                {:ok, read_back} = Firebird.Memory.read_i32_array(mem, ptr, count)
+                read_back
+              end)
+
+            result
           end)
-          result
-        end)
-      end
+        end
 
       results = Task.await_many(tasks, 10_000)
 
@@ -160,15 +172,16 @@ defmodule Firebird.PoolMemoryTest do
     test "works with Go WASM modules" do
       {:ok, pool} = start_pool("go_math.wasm", wasi: true)
 
-      {:ok, result} = Firebird.Pool.with_memory(pool, fn pid, mem ->
-        # Use the Go module for a regular call, but verify memory works
-        {mem, ptr} = Firebird.Memory.write_i32(mem, 99)
-        {:ok, val} = Firebird.Memory.read_i32(mem, ptr)
+      {:ok, result} =
+        Firebird.Pool.with_memory(pool, fn pid, mem ->
+          # Use the Go module for a regular call, but verify memory works
+          {mem, ptr} = Firebird.Memory.write_i32(mem, 99)
+          {:ok, val} = Firebird.Memory.read_i32(mem, ptr)
 
-        # Also verify the module itself works
-        {:ok, [sum]} = Firebird.call(pid, :add, [5, 3])
-        {val, sum}
-      end)
+          # Also verify the module itself works
+          {:ok, [sum]} = Firebird.call(pid, :add, [5, 3])
+          {val, sum}
+        end)
 
       assert result == {99, 8}
       Firebird.Pool.stop(pool)
@@ -209,10 +222,11 @@ defmodule Firebird.PoolMemoryTest do
       if File.exists?(path) do
         {:ok, pool} = Firebird.Pool.start_link(wasm: path, size: 2)
 
-        {:ok, results} = Firebird.Pool.run_memory_batch(pool, [
-          %{function: :hash_djb2, strings: ["hello"], result: :i32},
-          %{function: :hash_djb2, strings: ["world"], result: :i32},
-        ])
+        {:ok, results} =
+          Firebird.Pool.run_memory_batch(pool, [
+            %{function: :hash_djb2, strings: ["hello"], result: :i32},
+            %{function: :hash_djb2, strings: ["world"], result: :i32}
+          ])
 
         assert length(results) == 2
         assert Enum.all?(results, &is_integer/1)
@@ -236,9 +250,10 @@ defmodule Firebird.PoolMemoryTest do
     test "returns error on failing call" do
       {:ok, pool} = start_pool("rust_math.wasm")
 
-      result = Firebird.Pool.run_memory_batch(pool, [
-        %{function: :nonexistent, strings: ["test"], result: :raw}
-      ])
+      result =
+        Firebird.Pool.run_memory_batch(pool, [
+          %{function: :nonexistent, strings: ["test"], result: :raw}
+        ])
 
       assert {:error, _} = result
       Firebird.Pool.stop(pool)
@@ -253,11 +268,13 @@ defmodule Firebird.PoolMemoryTest do
       {:ok, [8]} = Firebird.Pool.call(pool, :add, [5, 3])
 
       # Memory call
-      {:ok, result} = Firebird.Pool.with_memory(pool, fn _pid, mem ->
-        {_mem, ptr} = Firebird.Memory.write_i32(mem, 42)
-        {:ok, val} = Firebird.Memory.read_i32(mem, ptr)
-        val
-      end)
+      {:ok, result} =
+        Firebird.Pool.with_memory(pool, fn _pid, mem ->
+          {_mem, ptr} = Firebird.Memory.write_i32(mem, 42)
+          {:ok, val} = Firebird.Memory.read_i32(mem, ptr)
+          val
+        end)
+
       assert result == 42
 
       # Regular call still works
@@ -270,10 +287,11 @@ defmodule Firebird.PoolMemoryTest do
       {:ok, pool} = start_pool("rust_math.wasm", size: 2)
 
       # Do some memory work
-      {:ok, _} = Firebird.Pool.with_memory(pool, fn _pid, mem ->
-        {_mem, _ptr, _len} = Firebird.Memory.write_string(mem, "test data")
-        :ok
-      end)
+      {:ok, _} =
+        Firebird.Pool.with_memory(pool, fn _pid, mem ->
+          {_mem, _ptr, _len} = Firebird.Memory.write_string(mem, "test data")
+          :ok
+        end)
 
       status = Firebird.Pool.status(pool)
       assert status.pool_size == 2
diff --git a/test/pool_parallel_startup_test.exs b/test/pool_parallel_startup_test.exs
index a0e1ce1..efceacb 100644
--- a/test/pool_parallel_startup_test.exs
+++ b/test/pool_parallel_startup_test.exs
@@ -33,26 +33,32 @@ defmodule Firebird.PoolParallelStartupTest do
 
     test "parallel startup is faster than sequential for larger pools" do
       # Measure parallel pool startup (current implementation)
-      {parallel_us, {:ok, pool1}} = :timer.tc(fn ->
-        Firebird.Pool.start_link(wasm: "fixtures/math.wasm", size: 6)
-      end)
+      {parallel_us, {:ok, pool1}} =
+        :timer.tc(fn ->
+          Firebird.Pool.start_link(wasm: "fixtures/math.wasm", size: 6)
+        end)
 
       status = Firebird.Pool.status(pool1)
       assert status.alive == 6
       Firebird.Pool.stop(pool1)
 
       # Measure sequential startup by creating instances one at a time
-      {sequential_us, pids} = :timer.tc(fn ->
-        {:ok, compiled} = Firebird.Preloader.compile("fixtures/math.wasm")
-        for _ <- 1..6 do
-          {:ok, pid} = Firebird.Preloader.instantiate(compiled)
-          pid
-        end
-      end)
+      {sequential_us, pids} =
+        :timer.tc(fn ->
+          {:ok, compiled} = Firebird.Preloader.compile("fixtures/math.wasm")
+
+          for _ <- 1..6 do
+            {:ok, pid} = Firebird.Preloader.instantiate(compiled)
+            pid
+          end
+        end)
+
       Enum.each(pids, &Firebird.stop/1)
 
       # Log timings for visibility (parallel should generally be faster)
-      IO.puts("\n  Pool startup (6 instances): parallel=#{parallel_us}μs, sequential=#{sequential_us}μs")
+      IO.puts(
+        "\n  Pool startup (6 instances): parallel=#{parallel_us}μs, sequential=#{sequential_us}μs"
+      )
 
       # The parallel path should at minimum work correctly
       assert parallel_us > 0
@@ -60,11 +66,12 @@ defmodule Firebird.PoolParallelStartupTest do
     end
 
     test "pool with WASI modules starts correctly in parallel" do
-      {:ok, pool} = Firebird.Pool.start_link(
-        wasm: "fixtures/go_math.wasm",
-        size: 4,
-        wasi: true
-      )
+      {:ok, pool} =
+        Firebird.Pool.start_link(
+          wasm: "fixtures/go_math.wasm",
+          size: 4,
+          wasi: true
+        )
 
       status = Firebird.Pool.status(pool)
       assert status.alive == 4
@@ -78,13 +85,14 @@ defmodule Firebird.PoolParallelStartupTest do
       {:ok, pool} = Firebird.Pool.start_link(wasm: "fixtures/math.wasm", size: 4)
 
       # Run concurrent calls to verify instances don't share state
-      tasks = for i <- 1..20 do
-        Task.async(fn ->
-          {:ok, [result]} = Firebird.Pool.call(pool, :add, [i, i])
-          assert result == i * 2
-          result
-        end)
-      end
+      tasks =
+        for i <- 1..20 do
+          Task.async(fn ->
+            {:ok, [result]} = Firebird.Pool.call(pool, :add, [i, i])
+            assert result == i * 2
+            result
+          end)
+        end
 
       results = Task.await_many(tasks, 5000)
       assert length(results) == 20
diff --git a/test/pool_recovery_test.exs b/test/pool_recovery_test.exs
index 6d5497d..ab736a8 100644
--- a/test/pool_recovery_test.exs
+++ b/test/pool_recovery_test.exs
@@ -58,6 +58,7 @@ defmodule Firebird.PoolRecoveryTest do
 
       # Kill all instances
       state = :sys.get_state(pool)
+
       for i <- 0..2 do
         Process.exit(elem(state.instances, i), :kill)
       end
@@ -110,7 +111,9 @@ defmodule Firebird.PoolRecoveryTest do
             end
 
             case Firebird.Pool.call(pool, :add, [i, i]) do
-              {:ok, [result]} -> result
+              {:ok, [result]} ->
+                result
+
               {:error, _} ->
                 # Retry once on error (instance may have been mid-replacement)
                 Process.sleep(20)
@@ -128,9 +131,12 @@ defmodule Firebird.PoolRecoveryTest do
     end
 
     test "pool with named registration recovers correctly" do
-      {:ok, _pool} = Firebird.Pool.start_link(
-        wasm_path: @fixture_path, pool_size: 2, name: :recovery_test_pool
-      )
+      {:ok, _pool} =
+        Firebird.Pool.start_link(
+          wasm_path: @fixture_path,
+          pool_size: 2,
+          name: :recovery_test_pool
+        )
 
       assert {:ok, [8]} = Firebird.Pool.call(:recovery_test_pool, :add, [5, 3])
 
diff --git a/test/pool_test.exs b/test/pool_test.exs
index 1f279c7..1785c40 100644
--- a/test/pool_test.exs
+++ b/test/pool_test.exs
@@ -28,7 +28,9 @@ defmodule Firebird.PoolTest do
     end
 
     test "starts with a registered name" do
-      {:ok, pool} = Firebird.Pool.start_link(wasm_path: @fixture_path, pool_size: 1, name: :test_pool)
+      {:ok, pool} =
+        Firebird.Pool.start_link(wasm_path: @fixture_path, pool_size: 1, name: :test_pool)
+
       assert {:ok, [5]} = Firebird.Pool.call(:test_pool, :add, [2, 3])
       Firebird.Pool.stop(pool)
     end
diff --git a/test/preloader_direct_compile_test.exs b/test/preloader_direct_compile_test.exs
index 96e56bc..2c49e68 100644
--- a/test/preloader_direct_compile_test.exs
+++ b/test/preloader_direct_compile_test.exs
@@ -118,20 +118,22 @@ defmodule Firebird.PreloaderDirectCompileTest do
       iterations = 5
 
       # Direct compile (new approach)
-      {direct_time, _} = :timer.tc(fn ->
-        for _ <- 1..iterations do
-          {:ok, _} = Firebird.Preloader.compile(bytes)
-        end
-      end)
+      {direct_time, _} =
+        :timer.tc(fn ->
+          for _ <- 1..iterations do
+            {:ok, _} = Firebird.Preloader.compile(bytes)
+          end
+        end)
 
       # Bootstrap approach (old approach simulation)
-      {bootstrap_time, _} = :timer.tc(fn ->
-        for _ <- 1..iterations do
-          {:ok, pid} = Wasmex.start_link(%{bytes: bytes})
-          {:ok, _module} = Wasmex.module(pid)
-          GenServer.stop(pid, :normal)
-        end
-      end)
+      {bootstrap_time, _} =
+        :timer.tc(fn ->
+          for _ <- 1..iterations do
+            {:ok, pid} = Wasmex.start_link(%{bytes: bytes})
+            {:ok, _module} = Wasmex.module(pid)
+            GenServer.stop(pid, :normal)
+          end
+        end)
 
       direct_avg = div(direct_time, iterations)
       bootstrap_avg = div(bootstrap_time, iterations)
@@ -139,7 +141,7 @@ defmodule Firebird.PreloaderDirectCompileTest do
       # Direct compile should be at least as fast (typically 1.2-1.5x faster)
       # We use a generous threshold to avoid flaky CI failures
       assert direct_avg <= bootstrap_avg * 1.5,
-        "Direct compile (#{direct_avg}μs) should not be much slower than bootstrap (#{bootstrap_avg}μs)"
+             "Direct compile (#{direct_avg}μs) should not be much slower than bootstrap (#{bootstrap_avg}μs)"
     end
   end
 end
diff --git a/test/preloader_test.exs b/test/preloader_test.exs
index 2537f45..9c85b76 100644
--- a/test/preloader_test.exs
+++ b/test/preloader_test.exs
@@ -185,9 +185,13 @@ defmodule Firebird.PreloaderTest do
     test "concurrent execution uses precompilation" do
       args_list = for n <- 1..20, do: [n, n]
 
-      {:ok, results} = Firebird.WasmRunner.run_concurrent(
-        @wat_wasm, :add, args_list, concurrency: 2
-      )
+      {:ok, results} =
+        Firebird.WasmRunner.run_concurrent(
+          @wat_wasm,
+          :add,
+          args_list,
+          concurrency: 2
+        )
 
       assert length(results) == 20
       expected = for n <- 1..20, do: n + n
@@ -225,7 +229,7 @@ defmodule Firebird.PreloaderTest do
       # but it should never be significantly worse.
       # We use a generous threshold since CI environments vary.
       assert avg_warm <= avg_cold * 3,
-        "Precompiled (#{avg_warm}μs) should not be much slower than cold (#{avg_cold}μs)"
+             "Precompiled (#{avg_warm}μs) should not be much slower than cold (#{avg_cold}μs)"
     end
   end
 end
diff --git a/test/profiler_comprehensive_test.exs b/test/profiler_comprehensive_test.exs
index 55ec734..f66266d 100644
--- a/test/profiler_comprehensive_test.exs
+++ b/test/profiler_comprehensive_test.exs
@@ -27,20 +27,22 @@ defmodule Firebird.ProfilerComprehensiveTest do
     end
 
     test "profiles with custom iterations and warmup" do
-      result = Profiler.profile(@rust_wasm, :add, [5, 3],
-        iterations: 20,
-        warmup: 3
-      )
+      result =
+        Profiler.profile(@rust_wasm, :add, [5, 3],
+          iterations: 20,
+          warmup: 3
+        )
 
       assert result.count == 20
       assert result.avg_us > 0
     end
 
     test "profiles fibonacci function" do
-      result = Profiler.profile(@rust_wasm, :fibonacci, [10],
-        iterations: 30,
-        warmup: 5
-      )
+      result =
+        Profiler.profile(@rust_wasm, :fibonacci, [10],
+          iterations: 30,
+          warmup: 5
+        )
 
       assert result.function == "fibonacci"
       assert result.avg_us > 0
@@ -48,21 +50,23 @@ defmodule Firebird.ProfilerComprehensiveTest do
     end
 
     test "profiles multiply function" do
-      result = Profiler.profile(@rust_wasm, :multiply, [7, 6],
-        iterations: 25,
-        warmup: 5
-      )
+      result =
+        Profiler.profile(@rust_wasm, :multiply, [7, 6],
+          iterations: 25,
+          warmup: 5
+        )
 
       assert result.function == "multiply"
       assert result.count == 25
     end
 
     test "profiles Go WASM function with WASI" do
-      result = Profiler.profile(@go_wasm, :add, [5, 3],
-        wasi: true,
-        iterations: 15,
-        warmup: 3
-      )
+      result =
+        Profiler.profile(@go_wasm, :add, [5, 3],
+          wasi: true,
+          iterations: 15,
+          warmup: 3
+        )
 
       assert result.function == "add"
       assert result.avg_us > 0
@@ -70,20 +74,22 @@ defmodule Firebird.ProfilerComprehensiveTest do
     end
 
     test "min_us <= median_us <= max_us" do
-      result = Profiler.profile(@rust_wasm, :add, [10, 20],
-        iterations: 50,
-        warmup: 5
-      )
+      result =
+        Profiler.profile(@rust_wasm, :add, [10, 20],
+          iterations: 50,
+          warmup: 5
+        )
 
       assert result.min_us <= result.median_us
       assert result.median_us <= result.max_us
     end
 
     test "total_us is approximately avg_us * count" do
-      result = Profiler.profile(@rust_wasm, :add, [1, 2],
-        iterations: 50,
-        warmup: 5
-      )
+      result =
+        Profiler.profile(@rust_wasm, :add, [1, 2],
+          iterations: 50,
+          warmup: 5
+        )
 
       # total should be close to avg * count (they are computed from same data)
       expected_total = result.avg_us * result.count
@@ -91,19 +97,21 @@ defmodule Firebird.ProfilerComprehensiveTest do
     end
 
     test "stddev_us is 0 or positive" do
-      result = Profiler.profile(@rust_wasm, :add, [5, 3],
-        iterations: 30,
-        warmup: 5
-      )
+      result =
+        Profiler.profile(@rust_wasm, :add, [5, 3],
+          iterations: 30,
+          warmup: 5
+        )
 
       assert result.stddev_us >= 0
     end
 
     test "profiles with minimal iterations" do
-      result = Profiler.profile(@rust_wasm, :add, [1, 2],
-        iterations: 1,
-        warmup: 0
-      )
+      result =
+        Profiler.profile(@rust_wasm, :add, [1, 2],
+          iterations: 1,
+          warmup: 0
+        )
 
       assert result.count == 1
       assert result.avg_us > 0
@@ -202,6 +210,7 @@ defmodule Firebird.ProfilerComprehensiveTest do
       result = Profiler.profile_module(@rust_wasm, iterations: 10)
 
       summary = result.summary
+
       if summary.fastest != nil do
         assert summary.fastest_us <= summary.slowest_us
       end
@@ -229,16 +238,17 @@ defmodule Firebird.ProfilerComprehensiveTest do
 
   describe "compare_implementations/4" do
     test "compares Rust vs Go WASM implementations" do
-      result = Profiler.compare_implementations(
-        %{
-          rust: {@rust_wasm, []},
-          go: {@go_wasm, [wasi: true]}
-        },
-        :add,
-        [5, 3],
-        iterations: 20,
-        warmup: 3
-      )
+      result =
+        Profiler.compare_implementations(
+          %{
+            rust: {@rust_wasm, []},
+            go: {@go_wasm, [wasi: true]}
+          },
+          :add,
+          [5, 3],
+          iterations: 20,
+          warmup: 3
+        )
 
       assert is_map(result)
       assert result.function == :add
@@ -253,16 +263,17 @@ defmodule Firebird.ProfilerComprehensiveTest do
     test "compares WASM vs native Elixir function" do
       native_add = fn args -> Enum.sum(args) end
 
-      result = Profiler.compare_implementations(
-        %{
-          rust: {@rust_wasm, []},
-          native: native_add
-        },
-        :add,
-        [5, 3],
-        iterations: 20,
-        warmup: 3
-      )
+      result =
+        Profiler.compare_implementations(
+          %{
+            rust: {@rust_wasm, []},
+            native: native_add
+          },
+          :add,
+          [5, 3],
+          iterations: 20,
+          warmup: 3
+        )
 
       assert Map.has_key?(result.results, :rust)
       assert Map.has_key?(result.results, :native)
@@ -270,16 +281,17 @@ defmodule Firebird.ProfilerComprehensiveTest do
     end
 
     test "rankings are sorted by avg_us ascending" do
-      result = Profiler.compare_implementations(
-        %{
-          rust: {@rust_wasm, []},
-          go: {@go_wasm, [wasi: true]}
-        },
-        :add,
-        [5, 3],
-        iterations: 15,
-        warmup: 3
-      )
+      result =
+        Profiler.compare_implementations(
+          %{
+            rust: {@rust_wasm, []},
+            go: {@go_wasm, [wasi: true]}
+          },
+          :add,
+          [5, 3],
+          iterations: 15,
+          warmup: 3
+        )
 
       rankings = result.rankings
       assert length(rankings) == 2
@@ -294,13 +306,14 @@ defmodule Firebird.ProfilerComprehensiveTest do
     end
 
     test "each result has expected stat keys" do
-      result = Profiler.compare_implementations(
-        %{rust: {@rust_wasm, []}},
-        :add,
-        [5, 3],
-        iterations: 10,
-        warmup: 2
-      )
+      result =
+        Profiler.compare_implementations(
+          %{rust: {@rust_wasm, []}},
+          :add,
+          [5, 3],
+          iterations: 10,
+          warmup: 2
+        )
 
       rust_stats = result.results.rust
       assert Map.has_key?(rust_stats, :avg_us)
@@ -312,16 +325,17 @@ defmodule Firebird.ProfilerComprehensiveTest do
     end
 
     test "fastest field matches the implementation with lowest avg_us" do
-      result = Profiler.compare_implementations(
-        %{
-          rust: {@rust_wasm, []},
-          go: {@go_wasm, [wasi: true]}
-        },
-        :add,
-        [5, 3],
-        iterations: 15,
-        warmup: 3
-      )
+      result =
+        Profiler.compare_implementations(
+          %{
+            rust: {@rust_wasm, []},
+            go: {@go_wasm, [wasi: true]}
+          },
+          :add,
+          [5, 3],
+          iterations: 15,
+          warmup: 3
+        )
 
       fastest_name = result.fastest
       fastest_avg = result.results[fastest_name].avg_us
@@ -334,13 +348,14 @@ defmodule Firebird.ProfilerComprehensiveTest do
     end
 
     test "single implementation comparison" do
-      result = Profiler.compare_implementations(
-        %{rust: {@rust_wasm, []}},
-        :fibonacci,
-        [10],
-        iterations: 10,
-        warmup: 2
-      )
+      result =
+        Profiler.compare_implementations(
+          %{rust: {@rust_wasm, []}},
+          :fibonacci,
+          [10],
+          iterations: 10,
+          warmup: 2
+        )
 
       assert result.fastest == :rust
       assert length(result.rankings) == 1
@@ -362,10 +377,11 @@ defmodule Firebird.ProfilerComprehensiveTest do
     end
 
     test "measures throughput for Go WASM function" do
-      result = Profiler.throughput(@go_wasm, :add, [5, 3],
-        duration_ms: 200,
-        wasi: true
-      )
+      result =
+        Profiler.throughput(@go_wasm, :add, [5, 3],
+          duration_ms: 200,
+          wasi: true
+        )
 
       assert result.total_calls > 0
       assert result.calls_per_second > 0
@@ -408,16 +424,17 @@ defmodule Firebird.ProfilerComprehensiveTest do
 
   describe "format/1 integration with real profiling data" do
     test "formats real comparison results" do
-      result = Profiler.compare_implementations(
-        %{
-          rust: {@rust_wasm, []},
-          go: {@go_wasm, [wasi: true]}
-        },
-        :add,
-        [5, 3],
-        iterations: 10,
-        warmup: 2
-      )
+      result =
+        Profiler.compare_implementations(
+          %{
+            rust: {@rust_wasm, []},
+            go: {@go_wasm, [wasi: true]}
+          },
+          :add,
+          [5, 3],
+          iterations: 10,
+          warmup: 2
+        )
 
       output = Profiler.format(result)
       assert is_binary(output)
@@ -441,20 +458,22 @@ defmodule Firebird.ProfilerComprehensiveTest do
 
   describe "edge cases" do
     test "profile with iterations: 1 works" do
-      result = Profiler.profile(@rust_wasm, :add, [5, 3],
-        iterations: 1,
-        warmup: 0
-      )
+      result =
+        Profiler.profile(@rust_wasm, :add, [5, 3],
+          iterations: 1,
+          warmup: 0
+        )
 
       assert result.count == 1
       assert result.stddev_us == 0.0
     end
 
     test "profile with warmup: 0 works" do
-      result = Profiler.profile(@rust_wasm, :add, [5, 3],
-        iterations: 5,
-        warmup: 0
-      )
+      result =
+        Profiler.profile(@rust_wasm, :add, [5, 3],
+          iterations: 5,
+          warmup: 0
+        )
 
       assert result.count == 5
       assert result.avg_us > 0
@@ -470,13 +489,14 @@ defmodule Firebird.ProfilerComprehensiveTest do
     test "compare_implementations with only native function" do
       native = fn args -> Enum.sum(args) end
 
-      result = Profiler.compare_implementations(
-        %{native: native},
-        :add,
-        [5, 3],
-        iterations: 10,
-        warmup: 2
-      )
+      result =
+        Profiler.compare_implementations(
+          %{native: native},
+          :add,
+          [5, 3],
+          iterations: 10,
+          warmup: 2
+        )
 
       assert result.fastest == :native
       assert result.results.native.avg_us >= 0
@@ -489,6 +509,7 @@ defmodule Firebird.ProfilerComprehensiveTest do
 
       # Should not crash - some entries might have :error key
       assert is_map(result.profiles)
+
       for {_name, profile} <- result.profiles do
         assert Map.has_key?(profile, :function) or Map.has_key?(profile, :error)
       end
diff --git a/test/profiler_test.exs b/test/profiler_test.exs
index cf9cb31..8a6552e 100644
--- a/test/profiler_test.exs
+++ b/test/profiler_test.exs
@@ -11,12 +11,32 @@ defmodule Firebird.ProfilerTest do
         iterations: 100,
         fastest: :rust,
         results: %{
-          rust: %{function: "rust/add", avg_us: 10.0, p50_us: 9.5, p99_us: 15.0,
-                  min_us: 8, max_us: 20, median_us: 9.5, p95_us: 14.0,
-                  stddev_us: 2.0, total_us: 1000, count: 100},
-          go: %{function: "go/add", avg_us: 25.0, p50_us: 24.0, p99_us: 35.0,
-                min_us: 20, max_us: 40, median_us: 24.0, p95_us: 33.0,
-                stddev_us: 5.0, total_us: 2500, count: 100}
+          rust: %{
+            function: "rust/add",
+            avg_us: 10.0,
+            p50_us: 9.5,
+            p99_us: 15.0,
+            min_us: 8,
+            max_us: 20,
+            median_us: 9.5,
+            p95_us: 14.0,
+            stddev_us: 2.0,
+            total_us: 1000,
+            count: 100
+          },
+          go: %{
+            function: "go/add",
+            avg_us: 25.0,
+            p50_us: 24.0,
+            p99_us: 35.0,
+            min_us: 20,
+            max_us: 40,
+            median_us: 24.0,
+            p95_us: 33.0,
+            stddev_us: 5.0,
+            total_us: 2500,
+            count: 100
+          }
         },
         rankings: [{:rust, 1, 10.0}, {:go, 2, 25.0}]
       }
@@ -56,12 +76,32 @@ defmodule Firebird.ProfilerTest do
         wasm_path: "test/math.wasm",
         function_count: 2,
         profiles: %{
-          "add" => %{function: "add", avg_us: 10.0, min_us: 8, max_us: 20,
-                     median_us: 9.5, p50_us: 9.5, p95_us: 14.0, p99_us: 15.0,
-                     stddev_us: 2.0, total_us: 1000, count: 100},
-          "mul" => %{function: "mul", avg_us: 12.0, min_us: 9, max_us: 22,
-                     median_us: 11.0, p50_us: 11.0, p95_us: 16.0, p99_us: 18.0,
-                     stddev_us: 3.0, total_us: 1200, count: 100}
+          "add" => %{
+            function: "add",
+            avg_us: 10.0,
+            min_us: 8,
+            max_us: 20,
+            median_us: 9.5,
+            p50_us: 9.5,
+            p95_us: 14.0,
+            p99_us: 15.0,
+            stddev_us: 2.0,
+            total_us: 1000,
+            count: 100
+          },
+          "mul" => %{
+            function: "mul",
+            avg_us: 12.0,
+            min_us: 9,
+            max_us: 22,
+            median_us: 11.0,
+            p50_us: 11.0,
+            p95_us: 16.0,
+            p99_us: 18.0,
+            stddev_us: 3.0,
+            total_us: 1200,
+            count: 100
+          }
         },
         summary: %{
           avg_call_us: 11.0,
@@ -87,9 +127,19 @@ defmodule Firebird.ProfilerTest do
         wasm_path: "test/broken.wasm",
         function_count: 2,
         profiles: %{
-          "good" => %{function: "good", avg_us: 10.0, min_us: 8, max_us: 20,
-                      median_us: 9.5, p50_us: 9.5, p95_us: 14.0, p99_us: 15.0,
-                      stddev_us: 2.0, total_us: 1000, count: 100},
+          "good" => %{
+            function: "good",
+            avg_us: 10.0,
+            min_us: 8,
+            max_us: 20,
+            median_us: 9.5,
+            p50_us: 9.5,
+            p95_us: 14.0,
+            p99_us: 15.0,
+            stddev_us: 2.0,
+            total_us: 1000,
+            count: 100
+          },
           "bad" => %{function: "bad", error: "call failed with default args"}
         },
         summary: %{
diff --git a/test/quick_test.exs b/test/quick_test.exs
index 1d238f2..4c7e910 100644
--- a/test/quick_test.exs
+++ b/test/quick_test.exs
@@ -5,19 +5,28 @@ defmodule Firebird.QuickTest do
 
   describe "eval_wat/3" do
     test "evaluates simple WAT expression" do
-      assert {:ok, [42]} = Firebird.Quick.eval_wat("""
-      (module
-        (func (export "answer") (result i32)
-          i32.const 42))
-      """, "answer")
+      assert {:ok, [42]} =
+               Firebird.Quick.eval_wat(
+                 """
+                 (module
+                   (func (export "answer") (result i32)
+                     i32.const 42))
+                 """,
+                 "answer"
+               )
     end
 
     test "evaluates WAT with arguments" do
-      assert {:ok, [8]} = Firebird.Quick.eval_wat("""
-      (module
-        (func (export "add") (param i32 i32) (result i32)
-          local.get 0 local.get 1 i32.add))
-      """, "add", [5, 3])
+      assert {:ok, [8]} =
+               Firebird.Quick.eval_wat(
+                 """
+                 (module
+                   (func (export "add") (param i32 i32) (result i32)
+                     local.get 0 local.get 1 i32.add))
+                 """,
+                 "add",
+                 [5, 3]
+               )
     end
 
     test "returns error for invalid WAT" do
@@ -25,11 +34,16 @@ defmodule Firebird.QuickTest do
     end
 
     test "returns error for missing function" do
-      result = Firebird.Quick.eval_wat("""
-      (module
-        (func (export "add") (param i32 i32) (result i32)
-          local.get 0 local.get 1 i32.add))
-      """, "nonexistent", [])
+      result =
+        Firebird.Quick.eval_wat(
+          """
+          (module
+            (func (export "add") (param i32 i32) (result i32)
+              local.get 0 local.get 1 i32.add))
+          """,
+          "nonexistent",
+          []
+        )
 
       assert {:error, _} = result
     end
@@ -37,11 +51,15 @@ defmodule Firebird.QuickTest do
 
   describe "eval_wat!/3" do
     test "returns results directly" do
-      assert [42] = Firebird.Quick.eval_wat!("""
-      (module
-        (func (export "answer") (result i32)
-          i32.const 42))
-      """, "answer")
+      assert [42] =
+               Firebird.Quick.eval_wat!(
+                 """
+                 (module
+                   (func (export "answer") (result i32)
+                     i32.const 42))
+                 """,
+                 "answer"
+               )
     end
 
     test "raises on error" do
@@ -53,8 +71,12 @@ defmodule Firebird.QuickTest do
 
   describe "wat_fn/3" do
     test "creates a callable function" do
-      add = Firebird.Quick.wat_fn("add", "(param i32 i32) (result i32)",
-        "local.get 0 local.get 1 i32.add")
+      add =
+        Firebird.Quick.wat_fn(
+          "add",
+          "(param i32 i32) (result i32)",
+          "local.get 0 local.get 1 i32.add"
+        )
 
       assert is_function(add)
       assert {:ok, [8]} = add.([5, 3])
@@ -63,8 +85,12 @@ defmodule Firebird.QuickTest do
     end
 
     test "creates different functions" do
-      double = Firebird.Quick.wat_fn("double", "(param i32) (result i32)",
-        "local.get 0 i32.const 2 i32.mul")
+      double =
+        Firebird.Quick.wat_fn(
+          "double",
+          "(param i32) (result i32)",
+          "local.get 0 i32.const 2 i32.mul"
+        )
 
       assert {:ok, [10]} = double.([5])
       assert {:ok, [0]} = double.([0])
diff --git a/test/runtime_comprehensive_test.exs b/test/runtime_comprehensive_test.exs
index aa0cec8..baebc3e 100644
--- a/test/runtime_comprehensive_test.exs
+++ b/test/runtime_comprehensive_test.exs
@@ -156,9 +156,11 @@ defmodule Firebird.RuntimeComprehensiveTest do
     end
 
     test "raises with 'Available functions' for unknown function", %{pid: pid} do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.Runtime.call!(pid, :addd, [1, 2])
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.Runtime.call!(pid, :addd, [1, 2])
+        end
+
       assert error.message =~ "WASM call"
       assert error.message =~ "addd"
       # Should suggest 'add' via jaro_distance
@@ -166,9 +168,11 @@ defmodule Firebird.RuntimeComprehensiveTest do
     end
 
     test "raises with suggestion for misspelled function", %{pid: pid} do
-      error = assert_raise RuntimeError, fn ->
-        Firebird.Runtime.call!(pid, :multiplly, [2, 3])
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.Runtime.call!(pid, :multiplly, [2, 3])
+        end
+
       assert error.message =~ "Did you mean"
     end
 
@@ -177,17 +181,21 @@ defmodule Firebird.RuntimeComprehensiveTest do
       Firebird.Runtime.stop(pid2)
       Process.sleep(10)
 
-      error = assert_raise RuntimeError, fn ->
-        Firebird.Runtime.call!(pid2, :add, [1, 2])
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.Runtime.call!(pid2, :add, [1, 2])
+        end
+
       assert error.message =~ "no longer alive"
     end
 
     test "raises with argument info for existing function with wrong args", %{pid: pid} do
       # Try calling a 2-arg function with 3 args
-      error = assert_raise RuntimeError, fn ->
-        Firebird.Runtime.call!(pid, :add, [1, 2, 3])
-      end
+      error =
+        assert_raise RuntimeError, fn ->
+          Firebird.Runtime.call!(pid, :add, [1, 2, 3])
+        end
+
       assert error.message =~ "add"
     end
   end
@@ -281,6 +289,7 @@ defmodule Firebird.RuntimeComprehensiveTest do
         {:add, [4, 40]},
         {:add, [5, 50]}
       ]
+
       {:ok, results} = Firebird.Runtime.call_many(pid, calls)
       assert results == [[11], [22], [33], [44], [55]]
     end
@@ -292,6 +301,7 @@ defmodule Firebird.RuntimeComprehensiveTest do
         {:fibonacci, [10]},
         {:add, [100, 200]}
       ]
+
       {:ok, results} = Firebird.Runtime.call_many(pid, calls)
       assert results == [[8], [28], [55], [300]]
     end
@@ -307,6 +317,7 @@ defmodule Firebird.RuntimeComprehensiveTest do
         {:nonexistent_func, [42]},
         {:add, [3, 4]}
       ]
+
       result = Firebird.Runtime.call_many(pid, calls)
       assert {:error, {:call_error, "nonexistent_func", _}} = result
     end
@@ -346,6 +357,7 @@ defmodule Firebird.RuntimeComprehensiveTest do
       {:ok, pid} = Firebird.Runtime.load(@rust_wasm_abs)
 
       func_exports = Firebird.Runtime.exports(pid) |> Enum.map(&Atom.to_string/1) |> MapSet.new()
+
       all_func_exports =
         Firebird.Runtime.all_exports(pid)
         |> Enum.filter(fn {_, type} -> type == :function end)
@@ -522,9 +534,10 @@ defmodule Firebird.RuntimeComprehensiveTest do
 
     test "all exported functions report as existing", %{pid: pid} do
       exports = Firebird.Runtime.exports(pid)
+
       for func <- exports do
         assert Firebird.Runtime.function_exists?(pid, func),
-          "Expected function_exists? to return true for #{func}"
+               "Expected function_exists? to return true for #{func}"
       end
     end
   end
@@ -557,6 +570,7 @@ defmodule Firebird.RuntimeComprehensiveTest do
 
     test "fibonacci sequence values", %{pid: pid} do
       expected = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+
       for {expected_val, n} <- Enum.with_index(expected) do
         {:ok, [result]} = Firebird.Runtime.call(pid, :fibonacci, [n])
         assert result == expected_val, "fib(#{n}) expected #{expected_val}, got #{result}"
@@ -619,8 +633,9 @@ defmodule Firebird.RuntimeComprehensiveTest do
       for {a, b} <- [{0, 0}, {1, 2}, {-5, 3}, {100, 200}, {-10, -20}] do
         {:ok, [rust_result]} = Firebird.Runtime.call(rust, :add, [a, b])
         {:ok, [go_result]} = Firebird.Runtime.call(go, :add, [a, b])
+
         assert rust_result == go_result,
-          "add(#{a}, #{b}): Rust=#{rust_result} Go=#{go_result}"
+               "add(#{a}, #{b}): Rust=#{rust_result} Go=#{go_result}"
       end
 
       Firebird.Runtime.stop(rust)
@@ -634,8 +649,9 @@ defmodule Firebird.RuntimeComprehensiveTest do
       for n <- [0, 1, 2, 5, 10, 15, 20] do
         {:ok, [rust_result]} = Firebird.Runtime.call(rust, :fibonacci, [n])
         {:ok, [go_result]} = Firebird.Runtime.call(go, :fibonacci, [n])
+
         assert rust_result == go_result,
-          "fibonacci(#{n}): Rust=#{rust_result} Go=#{go_result}"
+               "fibonacci(#{n}): Rust=#{rust_result} Go=#{go_result}"
       end
 
       Firebird.Runtime.stop(rust)
diff --git a/test/runtime_edge_cases_test.exs b/test/runtime_edge_cases_test.exs
index cbf3b4d..50af1fd 100644
--- a/test/runtime_edge_cases_test.exs
+++ b/test/runtime_edge_cases_test.exs
@@ -20,7 +20,8 @@ defmodule Firebird.RuntimeEdgeCasesTest do
     end
 
     test "load_file with missing file" do
-      assert {:error, {:file_error, :enoent, _}} = Firebird.Runtime.load_file("/no/such/file.wasm")
+      assert {:error, {:file_error, :enoent, _}} =
+               Firebird.Runtime.load_file("/no/such/file.wasm")
     end
 
     test "load_file with valid file" do
@@ -53,11 +54,13 @@ defmodule Firebird.RuntimeEdgeCasesTest do
     end
 
     test "call_many stops on first error", %{pid: pid} do
-      result = Firebird.Runtime.call_many(pid, [
-        {:add, [1, 2]},
-        {:nonexistent, [1]},
-        {:add, [3, 4]}
-      ])
+      result =
+        Firebird.Runtime.call_many(pid, [
+          {:add, [1, 2]},
+          {:nonexistent, [1]},
+          {:add, [3, 4]}
+        ])
+
       assert {:error, _} = result
     end
 
diff --git a/test/runtime_extended_test.exs b/test/runtime_extended_test.exs
index 844a0cd..50c1c42 100644
--- a/test/runtime_extended_test.exs
+++ b/test/runtime_extended_test.exs
@@ -12,7 +12,8 @@ defmodule Firebird.RuntimeExtendedTest do
     end
 
     test "returns error for non-existent file" do
-      assert {:error, {:file_error, :enoent, _}} = Firebird.Runtime.load_file("/no/such/file.wasm")
+      assert {:error, {:file_error, :enoent, _}} =
+               Firebird.Runtime.load_file("/no/such/file.wasm")
     end
   end
 
@@ -151,6 +152,7 @@ defmodule Firebird.RuntimeExtendedTest do
         {:multiply, [3, 4]},
         {:add, [10, 20]}
       ]
+
       assert {:ok, [[3], [12], [30]]} = Firebird.Runtime.call_many(pid, calls)
     end
 
@@ -164,6 +166,7 @@ defmodule Firebird.RuntimeExtendedTest do
         {:nonexistent, [1]},
         {:add, [3, 4]}
       ]
+
       assert {:error, _} = Firebird.Runtime.call_many(pid, calls)
     end
   end
@@ -177,6 +180,7 @@ defmodule Firebird.RuntimeExtendedTest do
         {:ok, bytes} -> assert is_binary(bytes)
         {:error, _} -> :ok
       end
+
       Firebird.Runtime.stop(pid)
     end
   end
diff --git a/test/rust_algorithms_test.exs b/test/rust_algorithms_test.exs
index 6e71d85..81301b3 100644
--- a/test/rust_algorithms_test.exs
+++ b/test/rust_algorithms_test.exs
@@ -17,7 +17,8 @@ defmodule RustAlgorithmsTest do
     end
 
     test "multi-digit palindromes", %{wasm: w} do
-      palindromes = [11, 121, 1221, 12321, 1234321, 1001]
+      palindromes = [11, 121, 1221, 12321, 1_234_321, 1001]
+
       for n <- palindromes do
         {:ok, [1]} = Firebird.call(w, :is_palindrome, [n])
       end
@@ -74,7 +75,7 @@ defmodule RustAlgorithmsTest do
       {:ok, [0]} = Firebird.call(w, :digit_sum, [0])
       {:ok, [5]} = Firebird.call(w, :digit_sum, [5])
       {:ok, [6]} = Firebird.call(w, :digit_sum, [123])
-      {:ok, [45]} = Firebird.call(w, :digit_sum, [123456789])
+      {:ok, [45]} = Firebird.call(w, :digit_sum, [123_456_789])
     end
 
     test "negative numbers use absolute value", %{wasm: w} do
@@ -101,7 +102,8 @@ defmodule RustAlgorithmsTest do
 
   describe "is_prime/1" do
     test "primes", %{wasm: w} do
-      primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 97, 101, 104729]
+      primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 97, 101, 104_729]
+
       for p <- primes do
         {:ok, [1]} = Firebird.call(w, :is_prime, [p])
       end
@@ -117,6 +119,7 @@ defmodule RustAlgorithmsTest do
   describe "nth_prime/1" do
     test "first 10 primes", %{wasm: w} do
       expected = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
+
       for {prime, i} <- Enum.with_index(expected, 1) do
         {:ok, [^prime]} = Firebird.call(w, :nth_prime, [i])
       end
@@ -130,13 +133,13 @@ defmodule RustAlgorithmsTest do
   describe "matrix_mul_2x2_c11/8" do
     test "identity matrix multiplication", %{wasm: w} do
       # [[1,0],[0,1]] * [[5,6],[7,8]] = [[5,6],[7,8]]
-      {:ok, [5]} = Firebird.call(w, :matrix_mul_2x2_c11, [1,0,0,1, 5,6,7,8])
+      {:ok, [5]} = Firebird.call(w, :matrix_mul_2x2_c11, [1, 0, 0, 1, 5, 6, 7, 8])
     end
 
     test "general multiplication", %{wasm: w} do
       # [[1,2],[3,4]] * [[5,6],[7,8]] = [[19,22],[43,50]]
-      {:ok, [19]} = Firebird.call(w, :matrix_mul_2x2_c11, [1,2,3,4, 5,6,7,8])
-      {:ok, [22]} = Firebird.call(w, :matrix_mul_2x2_c12, [1,2,3,4, 5,6,7,8])
+      {:ok, [19]} = Firebird.call(w, :matrix_mul_2x2_c11, [1, 2, 3, 4, 5, 6, 7, 8])
+      {:ok, [22]} = Firebird.call(w, :matrix_mul_2x2_c12, [1, 2, 3, 4, 5, 6, 7, 8])
     end
   end
 
diff --git a/test/rust_math_comprehensive_test.exs b/test/rust_math_comprehensive_test.exs
index e9fe7ad..3f8fcf3 100644
--- a/test/rust_math_comprehensive_test.exs
+++ b/test/rust_math_comprehensive_test.exs
@@ -36,14 +36,17 @@ defmodule Firebird.RustMathComprehensiveTest do
 
     test "divide", %{wasm: w} do
       assert {:ok, [5]} = Firebird.call(w, :divide, [10, 2])
-      assert {:ok, [3]} = Firebird.call(w, :divide, [7, 2])  # integer division
-      assert {:ok, [0]} = Firebird.call(w, :divide, [10, 0])  # safe div by zero
+      # integer division
+      assert {:ok, [3]} = Firebird.call(w, :divide, [7, 2])
+      # safe div by zero
+      assert {:ok, [0]} = Firebird.call(w, :divide, [10, 0])
     end
 
     test "modulo", %{wasm: w} do
       assert {:ok, [1]} = Firebird.call(w, :modulo, [7, 2])
       assert {:ok, [0]} = Firebird.call(w, :modulo, [10, 5])
-      assert {:ok, [0]} = Firebird.call(w, :modulo, [10, 0])  # safe mod by zero
+      # safe mod by zero
+      assert {:ok, [0]} = Firebird.call(w, :modulo, [10, 0])
     end
   end
 
@@ -83,12 +86,35 @@ defmodule Firebird.RustMathComprehensiveTest do
       assert {:ok, [1]} = Firebird.call(w, :factorial, [1])
       assert {:ok, [2]} = Firebird.call(w, :factorial, [2])
       assert {:ok, [120]} = Firebird.call(w, :factorial, [5])
-      assert {:ok, [3628800]} = Firebird.call(w, :factorial, [10])
-      assert {:ok, [479001600]} = Firebird.call(w, :factorial, [12])
+      assert {:ok, [3_628_800]} = Firebird.call(w, :factorial, [10])
+      assert {:ok, [479_001_600]} = Firebird.call(w, :factorial, [12])
     end
 
     test "fibonacci sequence", %{wasm: w} do
-      expected = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]
+      expected = [
+        0,
+        1,
+        1,
+        2,
+        3,
+        5,
+        8,
+        13,
+        21,
+        34,
+        55,
+        89,
+        144,
+        233,
+        377,
+        610,
+        987,
+        1597,
+        2584,
+        4181,
+        6765
+      ]
+
       for {expected_val, n} <- Enum.with_index(expected) do
         assert {:ok, [^expected_val]} = Firebird.call(w, :fibonacci, [n])
       end
@@ -117,11 +143,11 @@ defmodule Firebird.RustMathComprehensiveTest do
     end
 
     test "is_prime", %{wasm: w} do
-      primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 97, 101, 1009, 104729]
-      non_primes = [0, 1, 4, 6, 8, 9, 10, 15, 21, 100, 1000, 104730]
+      primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 97, 101, 1009, 104_729]
+      non_primes = [0, 1, 4, 6, 8, 9, 10, 15, 21, 100, 1000, 104_730]
 
-      for p <- primes, do: assert {:ok, [1]} = Firebird.call(w, :is_prime, [p])
-      for n <- non_primes, do: assert {:ok, [0]} = Firebird.call(w, :is_prime, [n])
+      for p <- primes, do: assert({:ok, [1]} = Firebird.call(w, :is_prime, [p]))
+      for n <- non_primes, do: assert({:ok, [0]} = Firebird.call(w, :is_prime, [n]))
     end
 
     test "count_primes", %{wasm: w} do
@@ -153,7 +179,7 @@ defmodule Firebird.RustMathComprehensiveTest do
       assert {:ok, [3]} = Firebird.call(w, :isqrt, [10])
       assert {:ok, [10]} = Firebird.call(w, :isqrt, [100])
       assert {:ok, [31]} = Firebird.call(w, :isqrt, [1000])
-      assert {:ok, [1000]} = Firebird.call(w, :isqrt, [1000000])
+      assert {:ok, [1000]} = Firebird.call(w, :isqrt, [1_000_000])
     end
   end
 
@@ -193,7 +219,7 @@ defmodule Firebird.RustMathComprehensiveTest do
       {:ok, [result]} = Firebird.call(w, :sqrt_f64, [100.0])
       assert_in_delta result, 10.0, 0.0001
 
-      {:ok, [result]} = Firebird.call(w, :sqrt_f64, [1000000.0])
+      {:ok, [result]} = Firebird.call(w, :sqrt_f64, [1_000_000.0])
       assert_in_delta result, 1000.0, 0.0001
     end
   end
@@ -203,12 +229,30 @@ defmodule Firebird.RustMathComprehensiveTest do
       exports = Firebird.exports(w)
       assert length(exports) == 22
 
-      expected = [:add, :subtract, :multiply, :divide, :modulo,
-                  :abs_val, :max_val, :min_val, :clamp,
-                  :factorial, :fibonacci, :gcd, :lcm, :power,
-                  :is_prime, :count_primes, :sum_range,
-                  :collatz_steps, :isqrt,
-                  :add_f64, :multiply_f64, :sqrt_f64]
+      expected = [
+        :add,
+        :subtract,
+        :multiply,
+        :divide,
+        :modulo,
+        :abs_val,
+        :max_val,
+        :min_val,
+        :clamp,
+        :factorial,
+        :fibonacci,
+        :gcd,
+        :lcm,
+        :power,
+        :is_prime,
+        :count_primes,
+        :sum_range,
+        :collatz_steps,
+        :isqrt,
+        :add_f64,
+        :multiply_f64,
+        :sqrt_f64
+      ]
 
       for func <- expected do
         assert func in exports, "#{func} should be exported"
diff --git a/test/sandbox_edge_cases_test.exs b/test/sandbox_edge_cases_test.exs
index ab31f2e..2f245ef 100644
--- a/test/sandbox_edge_cases_test.exs
+++ b/test/sandbox_edge_cases_test.exs
@@ -293,10 +293,11 @@ defmodule Firebird.SandboxEdgeCasesTest do
     test "sequential calls from same process" do
       {:ok, sandbox} = Sandbox.start(@rust_wasm)
 
-      results = for i <- 1..20 do
-        {:ok, [result]} = Sandbox.call(sandbox, :add, [i, i])
-        result
-      end
+      results =
+        for i <- 1..20 do
+          {:ok, [result]} = Sandbox.call(sandbox, :add, [i, i])
+          result
+        end
 
       expected = for i <- 1..20, do: i * 2
       assert results == expected
@@ -308,6 +309,7 @@ defmodule Firebird.SandboxEdgeCasesTest do
       {:ok, sandbox} = Sandbox.start(@rust_wasm, max_calls: 100)
 
       n = 15
+
       for _ <- 1..n do
         Sandbox.call(sandbox, :add, [1, 2])
       end
@@ -333,18 +335,20 @@ defmodule Firebird.SandboxEdgeCasesTest do
     test "start_link sandbox dies with parent" do
       test_pid = self()
 
-      parent = spawn(fn ->
-        {:ok, sandbox} = Sandbox.start_link(@rust_wasm)
-        send(test_pid, {:sandbox, sandbox})
-        # Keep alive until told to die
+      parent =
+        spawn(fn ->
+          {:ok, sandbox} = Sandbox.start_link(@rust_wasm)
+          send(test_pid, {:sandbox, sandbox})
+          # Keep alive until told to die
+          receive do
+            :die -> :ok
+          end
+        end)
+
+      sandbox =
         receive do
-          :die -> :ok
+          {:sandbox, pid} -> pid
         end
-      end)
-
-      sandbox = receive do
-        {:sandbox, pid} -> pid
-      end
 
       assert Process.alive?(sandbox)
 
@@ -500,11 +504,12 @@ defmodule Firebird.SandboxEdgeCasesTest do
     end
 
     test "all sandbox options together" do
-      {:ok, sandbox} = Sandbox.start(@rust_wasm,
-        max_calls: 100,
-        timeout: 5000,
-        max_memory: 100_000_000
-      )
+      {:ok, sandbox} =
+        Sandbox.start(@rust_wasm,
+          max_calls: 100,
+          timeout: 5000,
+          max_memory: 100_000_000
+        )
 
       {:ok, [8]} = Sandbox.call(sandbox, :add, [5, 3])
 
diff --git a/test/sigils_test.exs b/test/sigils_test.exs
index ed7c0f3..308134a 100644
--- a/test/sigils_test.exs
+++ b/test/sigils_test.exs
@@ -13,13 +13,14 @@ defmodule Firebird.SigilsTest do
     end
 
     test "compiles module with export function" do
-      bytes = wat!("""
-      (module
-        (func (export "add") (param i32 i32) (result i32)
-          local.get 0
-          local.get 1
-          i32.add))
-      """)
+      bytes =
+        wat!("""
+        (module
+          (func (export "add") (param i32 i32) (result i32)
+            local.get 0
+            local.get 1
+            i32.add))
+        """)
 
       assert is_binary(bytes)
       {:ok, instance} = Firebird.load(bytes)
@@ -28,17 +29,18 @@ defmodule Firebird.SigilsTest do
     end
 
     test "compiles module with multiple functions" do
-      bytes = wat!("""
-      (module
-        (func (export "add") (param i32 i32) (result i32)
-          local.get 0
-          local.get 1
-          i32.add)
-        (func (export "sub") (param i32 i32) (result i32)
-          local.get 0
-          local.get 1
-          i32.sub))
-      """)
+      bytes =
+        wat!("""
+        (module
+          (func (export "add") (param i32 i32) (result i32)
+            local.get 0
+            local.get 1
+            i32.add)
+          (func (export "sub") (param i32 i32) (result i32)
+            local.get 0
+            local.get 1
+            i32.sub))
+        """)
 
       {:ok, instance} = Firebird.load(bytes)
       {:ok, [8]} = Firebird.call(instance, :add, [5, 3])
@@ -47,13 +49,14 @@ defmodule Firebird.SigilsTest do
     end
 
     test "compiles module with i64 types" do
-      bytes = wat!("""
-      (module
-        (func (export "add64") (param i64 i64) (result i64)
-          local.get 0
-          local.get 1
-          i64.add))
-      """)
+      bytes =
+        wat!("""
+        (module
+          (func (export "add64") (param i64 i64) (result i64)
+            local.get 0
+            local.get 1
+            i64.add))
+        """)
 
       assert is_binary(bytes)
       {:ok, instance} = Firebird.load(bytes)
@@ -63,16 +66,17 @@ defmodule Firebird.SigilsTest do
     end
 
     test "compiles module with locals" do
-      bytes = wat!("""
-      (module
-        (func (export "double") (param i32) (result i32)
-          (local $tmp i32)
-          local.get 0
-          i32.const 2
-          i32.mul
-          local.set $tmp
-          local.get $tmp))
-      """)
+      bytes =
+        wat!("""
+        (module
+          (func (export "double") (param i32) (result i32)
+            (local $tmp i32)
+            local.get 0
+            i32.const 2
+            i32.mul
+            local.set $tmp
+            local.get $tmp))
+        """)
 
       {:ok, instance} = Firebird.load(bytes)
       {:ok, [10]} = Firebird.call(instance, :double, [5])
@@ -86,10 +90,11 @@ defmodule Firebird.SigilsTest do
     end
 
     test "compiles module with memory" do
-      bytes = wat!("""
-      (module
-        (memory (export "memory") 1))
-      """)
+      bytes =
+        wat!("""
+        (module
+          (memory (export "memory") 1))
+        """)
 
       assert is_binary(bytes)
     end
@@ -103,11 +108,12 @@ defmodule Firebird.SigilsTest do
     end
 
     test "compiles WAT with function at runtime" do
-      {:ok, bytes} = wat("""
-      (module
-        (func (export "const_42") (result i32)
-          i32.const 42))
-      """)
+      {:ok, bytes} =
+        wat("""
+        (module
+          (func (export "const_42") (result i32)
+            i32.const 42))
+        """)
 
       {:ok, instance} = Firebird.load(bytes)
       {:ok, [42]} = Firebird.call(instance, :const_42, [])
diff --git a/test/stream_edge_cases_test.exs b/test/stream_edge_cases_test.exs
index 669fd35..002db75 100644
--- a/test/stream_edge_cases_test.exs
+++ b/test/stream_edge_cases_test.exs
@@ -14,9 +14,10 @@ defmodule Firebird.StreamEdgeCasesTest do
   # ---------------------------------------------------------------------------
   describe "map/3 edge cases" do
     test "maps over an empty enumerable", %{wasm: wasm} do
-      results = []
-      |> Firebird.Stream.map(wasm, :add)
-      |> Enum.to_list()
+      results =
+        []
+        |> Firebird.Stream.map(wasm, :add)
+        |> Enum.to_list()
 
       assert results == []
     end
@@ -31,60 +32,68 @@ defmodule Firebird.StreamEdgeCasesTest do
 
     test "handles single integer input (wraps in list)", %{wasm: wasm} do
       # fibonacci takes 1 arg; single integer is wrapped as [n]
-      results = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-      |> Firebird.Stream.map(wasm, :fibonacci)
-      |> Enum.to_list()
+      results =
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+        |> Firebird.Stream.map(wasm, :fibonacci)
+        |> Enum.to_list()
 
       assert results == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
     end
 
     test "handles tuples with more than 2 elements", %{wasm: wasm} do
       # clamp takes 3 args: (value, min, max)
-      results = [{5, 0, 10}, {-5, 0, 10}, {15, 0, 10}]
-      |> Firebird.Stream.map(wasm, :clamp)
-      |> Enum.to_list()
+      results =
+        [{5, 0, 10}, {-5, 0, 10}, {15, 0, 10}]
+        |> Firebird.Stream.map(wasm, :clamp)
+        |> Enum.to_list()
 
       assert results == [5, 0, 10]
     end
 
     test "handles zero values correctly", %{wasm: wasm} do
-      results = [{0, 0}]
-      |> Firebird.Stream.map(wasm, :add)
-      |> Enum.to_list()
+      results =
+        [{0, 0}]
+        |> Firebird.Stream.map(wasm, :add)
+        |> Enum.to_list()
 
       assert results == [0]
     end
 
     test "handles negative numbers", %{wasm: wasm} do
-      results = [{-5, 3}, {10, -7}, {-3, -4}]
-      |> Firebird.Stream.map(wasm, :add)
-      |> Enum.to_list()
+      results =
+        [{-5, 3}, {10, -7}, {-3, -4}]
+        |> Firebird.Stream.map(wasm, :add)
+        |> Enum.to_list()
 
       assert results == [-2, 3, -7]
     end
 
     test "stream can be consumed multiple times (re-evaluated)", %{wasm: wasm} do
-      stream = [1, 2, 3]
-      |> Firebird.Stream.map(wasm, :fibonacci)
+      stream =
+        [1, 2, 3]
+        |> Firebird.Stream.map(wasm, :fibonacci)
 
       assert Enum.to_list(stream) == [1, 1, 2]
       assert Enum.to_list(stream) == [1, 1, 2]
     end
 
     test "works with Stream.take", %{wasm: wasm} do
-      results = Stream.iterate(1, &(&1 + 1))
-      |> Firebird.Stream.map(wasm, :fibonacci)
-      |> Enum.take(5)
+      results =
+        Stream.iterate(1, &(&1 + 1))
+        |> Firebird.Stream.map(wasm, :fibonacci)
+        |> Enum.take(5)
 
       assert results == [1, 1, 2, 3, 5]
     end
 
     test "works with Stream.zip", %{wasm: wasm} do
-      fibs = [1, 2, 3, 4, 5]
-      |> Firebird.Stream.map(wasm, :fibonacci)
+      fibs =
+        [1, 2, 3, 4, 5]
+        |> Firebird.Stream.map(wasm, :fibonacci)
 
-      doubled = [1, 2, 3, 4, 5]
-      |> Firebird.Stream.map(wasm, :fibonacci)
+      doubled =
+        [1, 2, 3, 4, 5]
+        |> Firebird.Stream.map(wasm, :fibonacci)
 
       result = Stream.zip(fibs, doubled) |> Enum.to_list()
       assert result == [{1, 1}, {1, 1}, {2, 2}, {3, 3}, {5, 5}]
@@ -96,9 +105,10 @@ defmodule Firebird.StreamEdgeCasesTest do
   # ---------------------------------------------------------------------------
   describe "map_raw/3 edge cases" do
     test "returns empty list for empty input", %{wasm: wasm} do
-      results = []
-      |> Firebird.Stream.map_raw(wasm, :add)
-      |> Enum.to_list()
+      results =
+        []
+        |> Firebird.Stream.map_raw(wasm, :add)
+        |> Enum.to_list()
 
       assert results == []
     end
@@ -112,9 +122,10 @@ defmodule Firebird.StreamEdgeCasesTest do
     end
 
     test "wraps results in lists", %{wasm: wasm} do
-      results = [{1, 2}, {3, 4}]
-      |> Firebird.Stream.map_raw(wasm, :add)
-      |> Enum.to_list()
+      results =
+        [{1, 2}, {3, 4}]
+        |> Firebird.Stream.map_raw(wasm, :add)
+        |> Enum.to_list()
 
       assert results == [[3], [7]]
     end
@@ -126,26 +137,30 @@ defmodule Firebird.StreamEdgeCasesTest do
   describe "filter/3 edge cases" do
     test "returns empty list when all filtered out", %{wasm: wasm} do
       # 0 and 1 are not prime
-      results = [0, 1]
-      |> Firebird.Stream.filter(wasm, :is_prime)
-      |> Enum.to_list()
+      results =
+        [0, 1]
+        |> Firebird.Stream.filter(wasm, :is_prime)
+        |> Enum.to_list()
 
       assert results == []
     end
 
     test "keeps all when all pass predicate", %{wasm: wasm} do
       primes = [2, 3, 5, 7, 11, 13]
-      results = primes
-      |> Firebird.Stream.filter(wasm, :is_prime)
-      |> Enum.to_list()
+
+      results =
+        primes
+        |> Firebird.Stream.filter(wasm, :is_prime)
+        |> Enum.to_list()
 
       assert results == primes
     end
 
     test "empty input returns empty", %{wasm: wasm} do
-      results = []
-      |> Firebird.Stream.filter(wasm, :is_prime)
-      |> Enum.to_list()
+      results =
+        []
+        |> Firebird.Stream.filter(wasm, :is_prime)
+        |> Enum.to_list()
 
       assert results == []
     end
@@ -160,17 +175,19 @@ defmodule Firebird.StreamEdgeCasesTest do
 
     test "filter is lazy - only evaluates needed elements", %{wasm: wasm} do
       # Take first 3 primes from a large range
-      results = 2..1000
-      |> Firebird.Stream.filter(wasm, :is_prime)
-      |> Enum.take(3)
+      results =
+        2..1000
+        |> Firebird.Stream.filter(wasm, :is_prime)
+        |> Enum.take(3)
 
       assert results == [2, 3, 5]
     end
 
     test "filter correctly handles boundary value (2 is prime)", %{wasm: wasm} do
-      results = [2]
-      |> Firebird.Stream.filter(wasm, :is_prime)
-      |> Enum.to_list()
+      results =
+        [2]
+        |> Firebird.Stream.filter(wasm, :is_prime)
+        |> Enum.to_list()
 
       assert results == [2]
     end
@@ -181,22 +198,25 @@ defmodule Firebird.StreamEdgeCasesTest do
   # ---------------------------------------------------------------------------
   describe "reduce/4 edge cases" do
     test "reduces empty list returns initial value", %{wasm: wasm} do
-      result = []
-      |> Firebird.Stream.reduce(wasm, :add, 0)
+      result =
+        []
+        |> Firebird.Stream.reduce(wasm, :add, 0)
 
       assert result == 0
     end
 
     test "reduces single element", %{wasm: wasm} do
-      result = [42]
-      |> Firebird.Stream.reduce(wasm, :add, 0)
+      result =
+        [42]
+        |> Firebird.Stream.reduce(wasm, :add, 0)
 
       assert result == 42
     end
 
     test "reduces with non-zero initial value", %{wasm: wasm} do
-      result = [1, 2, 3]
-      |> Firebird.Stream.reduce(wasm, :add, 100)
+      result =
+        [1, 2, 3]
+        |> Firebird.Stream.reduce(wasm, :add, 100)
 
       assert result == 106
     end
@@ -210,17 +230,19 @@ defmodule Firebird.StreamEdgeCasesTest do
 
     test "reduces with multiply and initial 1", %{wasm: wasm} do
       # Factorial-like: 1 * 1 * 2 * 3 * 4 * 5 = 120
-      result = [1, 2, 3, 4, 5]
-      |> Firebird.Stream.reduce(wasm, :multiply, 1)
+      result =
+        [1, 2, 3, 4, 5]
+        |> Firebird.Stream.reduce(wasm, :multiply, 1)
 
       assert result == 120
     end
 
     test "reduces large range", %{wasm: wasm} do
       # Sum of 1..100 = 5050
-      result = 1..100
-      |> Enum.to_list()
-      |> Firebird.Stream.reduce(wasm, :add, 0)
+      result =
+        1..100
+        |> Enum.to_list()
+        |> Firebird.Stream.reduce(wasm, :add, 0)
 
       assert result == 5050
     end
@@ -231,9 +253,10 @@ defmodule Firebird.StreamEdgeCasesTest do
   # ---------------------------------------------------------------------------
   describe "map_ok/3 edge cases" do
     test "returns empty list for empty input", %{wasm: wasm} do
-      results = []
-      |> Firebird.Stream.map_ok(wasm, :add)
-      |> Enum.to_list()
+      results =
+        []
+        |> Firebird.Stream.map_ok(wasm, :add)
+        |> Enum.to_list()
 
       assert results == []
     end
@@ -247,28 +270,33 @@ defmodule Firebird.StreamEdgeCasesTest do
 
       # Actually map_ok calls Firebird.call which may error. Let's test with fibonacci
       # which takes 1 arg - pass both valid 1-element lists and invalid 2-element lists
-      inputs = [[5], [10], [1, 2]]  # last one is 2 args -> error for fibonacci
-      results = inputs
-      |> Firebird.Stream.map_ok(wasm, :fibonacci)
-      |> Enum.to_list()
+      # last one is 2 args -> error for fibonacci
+      inputs = [[5], [10], [1, 2]]
+
+      results =
+        inputs
+        |> Firebird.Stream.map_ok(wasm, :fibonacci)
+        |> Enum.to_list()
 
       # Only the valid calls should appear (fibonacci(5)=5, fibonacci(10)=55)
       assert results == [5, 55]
     end
 
     test "returns all results when all succeed", %{wasm: wasm} do
-      results = [1, 2, 3, 4, 5]
-      |> Firebird.Stream.map_ok(wasm, :fibonacci)
-      |> Enum.to_list()
+      results =
+        [1, 2, 3, 4, 5]
+        |> Firebird.Stream.map_ok(wasm, :fibonacci)
+        |> Enum.to_list()
 
       assert results == [1, 1, 2, 3, 5]
     end
 
     test "handles all errors (returns empty)", %{wasm: wasm} do
       # Calling fibonacci with 2 args always errors
-      results = [[1, 2], [3, 4], [5, 6]]
-      |> Firebird.Stream.map_ok(wasm, :fibonacci)
-      |> Enum.to_list()
+      results =
+        [[1, 2], [3, 4], [5, 6]]
+        |> Firebird.Stream.map_ok(wasm, :fibonacci)
+        |> Enum.to_list()
 
       assert results == []
     end
@@ -317,11 +345,12 @@ defmodule Firebird.StreamEdgeCasesTest do
   describe "composability edge cases" do
     test "chained maps", %{wasm: wasm} do
       # fibonacci then add with self (double fib)
-      results = 1..5
-      |> Firebird.Stream.map(wasm, :fibonacci)
-      |> Enum.map(fn x -> {x, x} end)
-      |> Firebird.Stream.map(wasm, :add)
-      |> Enum.to_list()
+      results =
+        1..5
+        |> Firebird.Stream.map(wasm, :fibonacci)
+        |> Enum.map(fn x -> {x, x} end)
+        |> Firebird.Stream.map(wasm, :add)
+        |> Enum.to_list()
 
       # fib(1..5) = [1, 1, 2, 3, 5]
       # doubled = [2, 2, 4, 6, 10]
@@ -330,55 +359,61 @@ defmodule Firebird.StreamEdgeCasesTest do
 
     test "filter then reduce", %{wasm: wasm} do
       # Sum of primes from 1 to 20
-      result = 1..20
-      |> Firebird.Stream.filter(wasm, :is_prime)
-      |> Enum.to_list()
-      |> Firebird.Stream.reduce(wasm, :add, 0)
+      result =
+        1..20
+        |> Firebird.Stream.filter(wasm, :is_prime)
+        |> Enum.to_list()
+        |> Firebird.Stream.reduce(wasm, :add, 0)
 
       # Primes: 2, 3, 5, 7, 11, 13, 17, 19 = 77
       assert result == 77
     end
 
     test "map with Enum.count", %{wasm: wasm} do
-      count = 1..10
-      |> Firebird.Stream.map(wasm, :fibonacci)
-      |> Enum.count()
+      count =
+        1..10
+        |> Firebird.Stream.map(wasm, :fibonacci)
+        |> Enum.count()
 
       assert count == 10
     end
 
     test "map with Enum.max", %{wasm: wasm} do
-      max_fib = 1..10
-      |> Firebird.Stream.map(wasm, :fibonacci)
-      |> Enum.max()
+      max_fib =
+        1..10
+        |> Firebird.Stream.map(wasm, :fibonacci)
+        |> Enum.max()
 
       # fib(10) = 55
       assert max_fib == 55
     end
 
     test "map with Enum.min", %{wasm: wasm} do
-      min_fib = 1..10
-      |> Firebird.Stream.map(wasm, :fibonacci)
-      |> Enum.min()
+      min_fib =
+        1..10
+        |> Firebird.Stream.map(wasm, :fibonacci)
+        |> Enum.min()
 
       # fib(1) = 1, fib(2) = 1 -> min = 1
       assert min_fib == 1
     end
 
     test "map with Enum.uniq", %{wasm: wasm} do
-      unique_fibs = 0..6
-      |> Firebird.Stream.map(wasm, :fibonacci)
-      |> Enum.uniq()
+      unique_fibs =
+        0..6
+        |> Firebird.Stream.map(wasm, :fibonacci)
+        |> Enum.uniq()
 
       # fib(0..6) = [0, 1, 1, 2, 3, 5, 8] -> uniq = [0, 1, 2, 3, 5, 8]
       assert unique_fibs == [0, 1, 2, 3, 5, 8]
     end
 
     test "filter then map then take", %{wasm: wasm} do
-      results = 1..100
-      |> Firebird.Stream.filter(wasm, :is_prime)
-      |> Firebird.Stream.map(wasm, :fibonacci)
-      |> Enum.take(4)
+      results =
+        1..100
+        |> Firebird.Stream.filter(wasm, :is_prime)
+        |> Firebird.Stream.map(wasm, :fibonacci)
+        |> Enum.take(4)
 
       # First 4 primes: 2, 3, 5, 7
       # fib(2)=1, fib(3)=2, fib(5)=5, fib(7)=13
@@ -391,24 +426,27 @@ defmodule Firebird.StreamEdgeCasesTest do
   # ---------------------------------------------------------------------------
   describe "string function names" do
     test "map/3 accepts string function name", %{wasm: wasm} do
-      results = [{1, 2}, {3, 4}]
-      |> Firebird.Stream.map(wasm, "add")
-      |> Enum.to_list()
+      results =
+        [{1, 2}, {3, 4}]
+        |> Firebird.Stream.map(wasm, "add")
+        |> Enum.to_list()
 
       assert results == [3, 7]
     end
 
     test "filter/3 accepts string function name", %{wasm: wasm} do
-      results = [2, 4, 5, 6, 7]
-      |> Firebird.Stream.filter(wasm, "is_prime")
-      |> Enum.to_list()
+      results =
+        [2, 4, 5, 6, 7]
+        |> Firebird.Stream.filter(wasm, "is_prime")
+        |> Enum.to_list()
 
       assert results == [2, 5, 7]
     end
 
     test "reduce/4 accepts string function name", %{wasm: wasm} do
-      result = [1, 2, 3, 4, 5]
-      |> Firebird.Stream.reduce(wasm, "add", 0)
+      result =
+        [1, 2, 3, 4, 5]
+        |> Firebird.Stream.reduce(wasm, "add", 0)
 
       assert result == 15
     end
diff --git a/test/stream_test.exs b/test/stream_test.exs
index eab7686..b2ffbac 100644
--- a/test/stream_test.exs
+++ b/test/stream_test.exs
@@ -11,32 +11,36 @@ defmodule Firebird.StreamTest do
 
   describe "map/3" do
     test "maps single-arg function over stream", %{wasm: wasm} do
-      results = [0, 1, 2, 3, 4, 5]
-      |> Firebird.Stream.map(wasm, :fibonacci)
-      |> Enum.to_list()
+      results =
+        [0, 1, 2, 3, 4, 5]
+        |> Firebird.Stream.map(wasm, :fibonacci)
+        |> Enum.to_list()
 
       assert results == [0, 1, 1, 2, 3, 5]
     end
 
     test "maps two-arg function with tuples", %{wasm: wasm} do
-      results = [{1, 2}, {3, 4}, {5, 6}]
-      |> Firebird.Stream.map(wasm, :add)
-      |> Enum.to_list()
+      results =
+        [{1, 2}, {3, 4}, {5, 6}]
+        |> Firebird.Stream.map(wasm, :add)
+        |> Enum.to_list()
 
       assert results == [3, 7, 11]
     end
 
     test "maps two-arg function with lists", %{wasm: wasm} do
-      results = [[1, 2], [3, 4], [5, 6]]
-      |> Firebird.Stream.map(wasm, :add)
-      |> Enum.to_list()
+      results =
+        [[1, 2], [3, 4], [5, 6]]
+        |> Firebird.Stream.map(wasm, :add)
+        |> Enum.to_list()
 
       assert results == [3, 7, 11]
     end
 
     test "is lazy", %{wasm: wasm} do
-      stream = 1..1000
-      |> Firebird.Stream.map(wasm, :fibonacci)
+      stream =
+        1..1000
+        |> Firebird.Stream.map(wasm, :fibonacci)
 
       # Taking only 3 should not evaluate all 1000
       results = Enum.take(stream, 3)
@@ -44,9 +48,10 @@ defmodule Firebird.StreamTest do
     end
 
     test "works with ranges", %{wasm: wasm} do
-      results = 1..5
-      |> Firebird.Stream.map(wasm, :fibonacci)
-      |> Enum.to_list()
+      results =
+        1..5
+        |> Firebird.Stream.map(wasm, :fibonacci)
+        |> Enum.to_list()
 
       assert results == [1, 1, 2, 3, 5]
     end
@@ -54,9 +59,10 @@ defmodule Firebird.StreamTest do
 
   describe "map_raw/3" do
     test "returns raw result lists", %{wasm: wasm} do
-      results = [0, 1, 2]
-      |> Firebird.Stream.map_raw(wasm, :fibonacci)
-      |> Enum.to_list()
+      results =
+        [0, 1, 2]
+        |> Firebird.Stream.map_raw(wasm, :fibonacci)
+        |> Enum.to_list()
 
       assert results == [[0], [1], [1]]
     end
@@ -65,9 +71,10 @@ defmodule Firebird.StreamTest do
   describe "filter/3" do
     test "filters using WASM predicate", %{wasm: wasm} do
       # is_prime returns 1 for primes, 0 for non-primes
-      results = 1..20
-      |> Firebird.Stream.filter(wasm, :is_prime)
-      |> Enum.to_list()
+      results =
+        1..20
+        |> Firebird.Stream.filter(wasm, :is_prime)
+        |> Enum.to_list()
 
       assert 2 in results
       assert 3 in results
@@ -80,15 +87,17 @@ defmodule Firebird.StreamTest do
 
   describe "reduce/4" do
     test "reduces with WASM function", %{wasm: wasm} do
-      result = 1..10
-      |> Firebird.Stream.reduce(wasm, :add, 0)
+      result =
+        1..10
+        |> Firebird.Stream.reduce(wasm, :add, 0)
 
       assert result == 55
     end
 
     test "reduces with multiply", %{wasm: wasm} do
-      result = [2, 3, 4]
-      |> Firebird.Stream.reduce(wasm, :multiply, 1)
+      result =
+        [2, 3, 4]
+        |> Firebird.Stream.reduce(wasm, :multiply, 1)
 
       assert result == 24
     end
@@ -97,9 +106,10 @@ defmodule Firebird.StreamTest do
   describe "map_ok/3" do
     test "keeps only successful results", %{wasm: wasm} do
       # All valid inputs should work
-      results = [1, 2, 3]
-      |> Firebird.Stream.map_ok(wasm, :fibonacci)
-      |> Enum.to_list()
+      results =
+        [1, 2, 3]
+        |> Firebird.Stream.map_ok(wasm, :fibonacci)
+        |> Enum.to_list()
 
       assert results == [1, 1, 2]
     end
@@ -107,10 +117,11 @@ defmodule Firebird.StreamTest do
 
   describe "composability" do
     test "stream operations compose", %{wasm: wasm} do
-      result = 1..10
-      |> Firebird.Stream.filter(wasm, :is_prime)
-      |> Firebird.Stream.map(wasm, :fibonacci)
-      |> Enum.to_list()
+      result =
+        1..10
+        |> Firebird.Stream.filter(wasm, :is_prime)
+        |> Firebird.Stream.map(wasm, :fibonacci)
+        |> Enum.to_list()
 
       # Primes 1-10: 2, 3, 5, 7
       # fib(2)=1, fib(3)=2, fib(5)=5, fib(7)=13
@@ -118,9 +129,10 @@ defmodule Firebird.StreamTest do
     end
 
     test "works with Enum functions", %{wasm: wasm} do
-      sum = 1..5
-      |> Firebird.Stream.map(wasm, :fibonacci)
-      |> Enum.sum()
+      sum =
+        1..5
+        |> Firebird.Stream.map(wasm, :fibonacci)
+        |> Enum.sum()
 
       # fib(1..5) = [1, 1, 2, 3, 5], sum = 12
       assert sum == 12
diff --git a/test/string_wasm_test.exs b/test/string_wasm_test.exs
index e55057c..4fde62b 100644
--- a/test/string_wasm_test.exs
+++ b/test/string_wasm_test.exs
@@ -116,13 +116,13 @@ defmodule Firebird.StringWasmTest do
     defmodule StringUtils do
       use Firebird.WasmModule, path: Path.join(__DIR__, "../fixtures/string_utils.wasm")
 
-      wasm_func :alloc_bytes, [:i32], [:i32]
-      wasm_func :free_bytes, [:i32, :i32]
-      wasm_func :string_length, [:i32, :i32], [:i32]
-      wasm_func :to_uppercase, [:i32, :i32], [:i32]
-      wasm_func :count_byte, [:i32, :i32, :i32], [:i32]
-      wasm_func :sum_bytes, [:i32, :i32], [:i32]
-      wasm_func :reverse_bytes, [:i32, :i32], [:i32]
+      wasm_func(:alloc_bytes, [:i32], [:i32])
+      wasm_func(:free_bytes, [:i32, :i32])
+      wasm_func(:string_length, [:i32, :i32], [:i32])
+      wasm_func(:to_uppercase, [:i32, :i32], [:i32])
+      wasm_func(:count_byte, [:i32, :i32, :i32], [:i32])
+      wasm_func(:sum_bytes, [:i32, :i32], [:i32])
+      wasm_func(:reverse_bytes, [:i32, :i32], [:i32])
     end
 
     setup do
diff --git a/test/target/advanced_wasm_test.exs b/test/target/advanced_wasm_test.exs
index de294d6..868b937 100644
--- a/test/target/advanced_wasm_test.exs
+++ b/test/target/advanced_wasm_test.exs
@@ -29,20 +29,21 @@ defmodule Firebird.Target.AdvancedWasmTest do
 
   describe "cond expressions" do
     setup do
-      instance = compile_and_load("""
-      defmodule CondTest do
-        @wasm true
-        def grade(score) do
-          cond do
-            score >= 90 -> 4
-            score >= 80 -> 3
-            score >= 70 -> 2
-            score >= 60 -> 1
-            true -> 0
+      instance =
+        compile_and_load("""
+        defmodule CondTest do
+          @wasm true
+          def grade(score) do
+            cond do
+              score >= 90 -> 4
+              score >= 80 -> 3
+              score >= 70 -> 2
+              score >= 60 -> 1
+              true -> 0
+            end
           end
         end
-      end
-      """)
+        """)
 
       on_exit(fn -> safe_stop(instance) end)
       {:ok, inst: instance}
@@ -67,23 +68,24 @@ defmodule Firebird.Target.AdvancedWasmTest do
 
   describe "case expressions" do
     setup do
-      instance = compile_and_load("""
-      defmodule CaseTest do
-        @wasm true
-        def day_type(day) do
-          case day do
-            1 -> 10
-            2 -> 10
-            3 -> 10
-            4 -> 10
-            5 -> 10
-            6 -> 20
-            7 -> 20
-            _ -> 0
+      instance =
+        compile_and_load("""
+        defmodule CaseTest do
+          @wasm true
+          def day_type(day) do
+            case day do
+              1 -> 10
+              2 -> 10
+              3 -> 10
+              4 -> 10
+              5 -> 10
+              6 -> 20
+              7 -> 20
+              _ -> 0
+            end
           end
         end
-      end
-      """)
+        """)
 
       on_exit(fn -> safe_stop(instance) end)
       {:ok, inst: instance}
@@ -110,18 +112,19 @@ defmodule Firebird.Target.AdvancedWasmTest do
 
   describe "zero-arity functions" do
     setup do
-      instance = compile_and_load("""
-      defmodule ZeroArity do
-        @wasm true
-        def answer, do: 42
+      instance =
+        compile_and_load("""
+        defmodule ZeroArity do
+          @wasm true
+          def answer, do: 42
 
-        @wasm true
-        def zero, do: 0
+          @wasm true
+          def zero, do: 0
 
-        @wasm true
-        def negative, do: 0 - 1
-      end
-      """)
+          @wasm true
+          def negative, do: 0 - 1
+        end
+        """)
 
       on_exit(fn -> safe_stop(instance) end)
       {:ok, inst: instance}
@@ -136,21 +139,22 @@ defmodule Firebird.Target.AdvancedWasmTest do
 
   describe "nested function calls" do
     setup do
-      instance = compile_and_load("""
-      defmodule NestedCalls do
-        @wasm true
-        def double(n), do: n * 2
+      instance =
+        compile_and_load("""
+        defmodule NestedCalls do
+          @wasm true
+          def double(n), do: n * 2
 
-        @wasm true
-        def triple(n), do: n * 3
+          @wasm true
+          def triple(n), do: n * 3
 
-        @wasm true
-        def double_then_triple(n), do: triple(double(n))
+          @wasm true
+          def double_then_triple(n), do: triple(double(n))
 
-        @wasm true
-        def add_doubles(a, b), do: double(a) + double(b)
-      end
-      """)
+          @wasm true
+          def add_doubles(a, b), do: double(a) + double(b)
+        end
+        """)
 
       on_exit(fn -> safe_stop(instance) end)
       {:ok, inst: instance}
@@ -173,38 +177,39 @@ defmodule Firebird.Target.AdvancedWasmTest do
 
   describe "complex recursive patterns" do
     setup do
-      instance = compile_and_load("""
-      defmodule ComplexRecursion do
-        @wasm true
-        def ackermann(0, n), do: n + 1
-        def ackermann(m, 0), do: ackermann(m - 1, 1)
-        def ackermann(m, n), do: ackermann(m - 1, ackermann(m, n - 1))
-
-        @wasm true
-        def count_digits(0), do: 1
-        def count_digits(n) do
-          if n < 0 do
-            count_digits(0 - n)
-          else
-            if n < 10 do
-              1
+      instance =
+        compile_and_load("""
+        defmodule ComplexRecursion do
+          @wasm true
+          def ackermann(0, n), do: n + 1
+          def ackermann(m, 0), do: ackermann(m - 1, 1)
+          def ackermann(m, n), do: ackermann(m - 1, ackermann(m, n - 1))
+
+          @wasm true
+          def count_digits(0), do: 1
+          def count_digits(n) do
+            if n < 0 do
+              count_digits(0 - n)
             else
-              1 + count_digits(div(n, 10))
+              if n < 10 do
+                1
+              else
+                1 + count_digits(div(n, 10))
+              end
             end
           end
-        end
 
-        @wasm true
-        def sum_of_digits(0), do: 0
-        def sum_of_digits(n) do
-          if n < 0 do
-            sum_of_digits(0 - n)
-          else
-            rem(n, 10) + sum_of_digits(div(n, 10))
+          @wasm true
+          def sum_of_digits(0), do: 0
+          def sum_of_digits(n) do
+            if n < 0 do
+              sum_of_digits(0 - n)
+            else
+              rem(n, 10) + sum_of_digits(div(n, 10))
+            end
           end
         end
-      end
-      """)
+        """)
 
       on_exit(fn -> safe_stop(instance) end)
       {:ok, inst: instance}
@@ -250,21 +255,22 @@ defmodule Firebird.Target.AdvancedWasmTest do
 
   describe "multi-function modules with cross-calls" do
     setup do
-      instance = compile_and_load("""
-      defmodule CrossCalls do
-        @wasm true
-        def square(n), do: n * n
+      instance =
+        compile_and_load("""
+        defmodule CrossCalls do
+          @wasm true
+          def square(n), do: n * n
 
-        @wasm true
-        def cube(n), do: n * square(n)
+          @wasm true
+          def cube(n), do: n * square(n)
 
-        @wasm true
-        def sum_of_squares(a, b), do: square(a) + square(b)
+          @wasm true
+          def sum_of_squares(a, b), do: square(a) + square(b)
 
-        @wasm true
-        def hypotenuse_sq(a, b), do: sum_of_squares(a, b)
-      end
-      """)
+          @wasm true
+          def hypotenuse_sq(a, b), do: sum_of_squares(a, b)
+        end
+        """)
 
       on_exit(fn -> safe_stop(instance) end)
       {:ok, inst: instance}
@@ -288,29 +294,30 @@ defmodule Firebird.Target.AdvancedWasmTest do
 
   describe "boolean logic compilation" do
     setup do
-      instance = compile_and_load("""
-      defmodule BoolLogic do
-        @wasm true
-        def is_positive(n) do
-          if n > 0, do: 1, else: 0
-        end
+      instance =
+        compile_and_load("""
+        defmodule BoolLogic do
+          @wasm true
+          def is_positive(n) do
+            if n > 0, do: 1, else: 0
+          end
 
-        @wasm true
-        def is_in_range(n, lo, hi) do
-          if n >= lo and n <= hi, do: 1, else: 0
-        end
+          @wasm true
+          def is_in_range(n, lo, hi) do
+            if n >= lo and n <= hi, do: 1, else: 0
+          end
 
-        @wasm true
-        def is_outside(n, lo, hi) do
-          if n < lo or n > hi, do: 1, else: 0
-        end
+          @wasm true
+          def is_outside(n, lo, hi) do
+            if n < lo or n > hi, do: 1, else: 0
+          end
 
-        @wasm true
-        def bool_not(n) do
-          if not (n > 0), do: 1, else: 0
+          @wasm true
+          def bool_not(n) do
+            if not (n > 0), do: 1, else: 0
+          end
         end
-      end
-      """)
+        """)
 
       on_exit(fn -> safe_stop(instance) end)
       {:ok, inst: instance}
@@ -345,12 +352,13 @@ defmodule Firebird.Target.AdvancedWasmTest do
 
   describe "WAT output quality" do
     test "simple module produces compact WAT" do
-      {:ok, result} = Target.compile_source("""
-      defmodule WatQuality do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      {:ok, result} =
+        Target.compile_source("""
+        defmodule WatQuality do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
       assert String.contains?(result.wat, "(module")
       assert String.contains?(result.wat, "(func $add")
@@ -362,32 +370,34 @@ defmodule Firebird.Target.AdvancedWasmTest do
     end
 
     test "WASM binary is smaller than WAT" do
-      {:ok, result} = Target.compile_source("""
-      defmodule SizeCheck do
-        @wasm true
-        def add(a, b), do: a + b
-
-        @wasm true
-        def mul(a, b), do: a * b
-      end
-      """)
+      {:ok, result} =
+        Target.compile_source("""
+        defmodule SizeCheck do
+          @wasm true
+          def add(a, b), do: a + b
+
+          @wasm true
+          def mul(a, b), do: a * b
+        end
+        """)
 
       assert byte_size(result.wasm) < byte_size(result.wat)
     end
 
     test "all exported functions appear in WAT" do
-      {:ok, result} = Target.compile_source("""
-      defmodule ExportCheck do
-        @wasm true
-        def add(a, b), do: a + b
+      {:ok, result} =
+        Target.compile_source("""
+        defmodule ExportCheck do
+          @wasm true
+          def add(a, b), do: a + b
 
-        @wasm true
-        def sub(a, b), do: a - b
+          @wasm true
+          def sub(a, b), do: a - b
 
-        @wasm true
-        def mul(a, b), do: a * b
-      end
-      """)
+          @wasm true
+          def mul(a, b), do: a * b
+        end
+        """)
 
       assert String.contains?(result.wat, "(export \"add\")")
       assert String.contains?(result.wat, "(export \"sub\")")
diff --git a/test/target/benchmark_comparison_test.exs b/test/target/benchmark_comparison_test.exs
index 86bb915..6993490 100644
--- a/test/target/benchmark_comparison_test.exs
+++ b/test/target/benchmark_comparison_test.exs
@@ -28,7 +28,7 @@ defmodule Firebird.Target.BenchmarkComparisonTest do
 
       for r <- results do
         assert r.correct,
-          "Benchmark #{r.name}: WASM result #{inspect(r.wasm_result)} != BEAM result #{inspect(r.beam_result)}"
+               "Benchmark #{r.name}: WASM result #{inspect(r.wasm_result)} != BEAM result #{inspect(r.beam_result)}"
       end
     end
 
@@ -60,21 +60,25 @@ defmodule Firebird.Target.BenchmarkComparisonTest do
 
       for r <- results do
         assert r.wasm.p95 >= r.wasm.median,
-          "#{r.name}: WASM p95 (#{r.wasm.p95}) < median (#{r.wasm.median})"
+               "#{r.name}: WASM p95 (#{r.wasm.p95}) < median (#{r.wasm.median})"
+
         assert r.wasm.median >= r.wasm.min,
-          "#{r.name}: WASM median (#{r.wasm.median}) < min (#{r.wasm.min})"
+               "#{r.name}: WASM median (#{r.wasm.median}) < min (#{r.wasm.min})"
       end
     end
   end
 
   describe "custom compare_function" do
     test "arithmetic comparison" do
-      result = Benchmark.compare_function(
-        @math_source, :add, [42, 58],
-        beam_fn: fn a, b -> a + b end,
-        iterations: 10,
-        warmup: 3
-      )
+      result =
+        Benchmark.compare_function(
+          @math_source,
+          :add,
+          [42, 58],
+          beam_fn: fn a, b -> a + b end,
+          iterations: 10,
+          warmup: 3
+        )
 
       assert result.correct
       assert result.wasm_result == 100
@@ -83,31 +87,40 @@ defmodule Firebird.Target.BenchmarkComparisonTest do
     end
 
     test "recursive comparison" do
-      result = Benchmark.compare_function(
-        @math_source, :factorial, [10],
-        beam_fn: fn n -> Enum.reduce(1..max(n, 1), 1, &*/2) end,
-        iterations: 10,
-        warmup: 3
-      )
+      result =
+        Benchmark.compare_function(
+          @math_source,
+          :factorial,
+          [10],
+          beam_fn: fn n -> Enum.reduce(1..max(n, 1), 1, &*/2) end,
+          iterations: 10,
+          warmup: 3
+        )
 
       assert result.correct
       assert result.wasm_result == 3_628_800
     end
 
     test "different arg sizes affect timing" do
-      small = Benchmark.compare_function(
-        @math_source, :fibonacci, [5],
-        beam_fn: fn n -> fib(n) end,
-        iterations: 10,
-        warmup: 3
-      )
-
-      large = Benchmark.compare_function(
-        @math_source, :fibonacci, [15],
-        beam_fn: fn n -> fib(n) end,
-        iterations: 10,
-        warmup: 3
-      )
+      small =
+        Benchmark.compare_function(
+          @math_source,
+          :fibonacci,
+          [5],
+          beam_fn: fn n -> fib(n) end,
+          iterations: 10,
+          warmup: 3
+        )
+
+      large =
+        Benchmark.compare_function(
+          @math_source,
+          :fibonacci,
+          [15],
+          beam_fn: fn n -> fib(n) end,
+          iterations: 10,
+          warmup: 3
+        )
 
       assert small.correct
       assert large.correct
diff --git a/test/target/benchmark_comprehensive_test.exs b/test/target/benchmark_comprehensive_test.exs
index 25c60c2..7308610 100644
--- a/test/target/benchmark_comprehensive_test.exs
+++ b/test/target/benchmark_comprehensive_test.exs
@@ -17,12 +17,15 @@ defmodule Firebird.Target.BenchmarkComprehensiveTest do
 
   describe "compare_function/4" do
     test "compares a simple arithmetic function" do
-      result = Benchmark.compare_function(
-        @math_source, :add, [10, 20],
-        beam_fn: fn a, b -> a + b end,
-        iterations: 10,
-        warmup: 2
-      )
+      result =
+        Benchmark.compare_function(
+          @math_source,
+          :add,
+          [10, 20],
+          beam_fn: fn a, b -> a + b end,
+          iterations: 10,
+          warmup: 2
+        )
 
       assert result.correct == true
       assert result.wasm_result == 30
@@ -34,12 +37,15 @@ defmodule Firebird.Target.BenchmarkComprehensiveTest do
     end
 
     test "compares a recursive function" do
-      result = Benchmark.compare_function(
-        @math_source, :factorial, [10],
-        beam_fn: fn n -> Enum.reduce(1..n, 1, &(&1 * &2)) end,
-        iterations: 10,
-        warmup: 2
-      )
+      result =
+        Benchmark.compare_function(
+          @math_source,
+          :factorial,
+          [10],
+          beam_fn: fn n -> Enum.reduce(1..n, 1, &(&1 * &2)) end,
+          iterations: 10,
+          warmup: 2
+        )
 
       assert result.correct == true
       assert result.wasm_result == 3_628_800
@@ -47,12 +53,15 @@ defmodule Firebird.Target.BenchmarkComprehensiveTest do
     end
 
     test "includes timing statistics" do
-      result = Benchmark.compare_function(
-        @math_source, :add, [1, 2],
-        beam_fn: fn a, b -> a + b end,
-        iterations: 20,
-        warmup: 5
-      )
+      result =
+        Benchmark.compare_function(
+          @math_source,
+          :add,
+          [1, 2],
+          beam_fn: fn a, b -> a + b end,
+          iterations: 20,
+          warmup: 5
+        )
 
       # Check WASM stats
       assert is_float(result.wasm.avg) or is_integer(result.wasm.avg)
@@ -67,12 +76,15 @@ defmodule Firebird.Target.BenchmarkComprehensiveTest do
     end
 
     test "name field formats correctly" do
-      result = Benchmark.compare_function(
-        @math_source, :add, [5, 3],
-        beam_fn: fn a, b -> a + b end,
-        iterations: 5,
-        warmup: 1
-      )
+      result =
+        Benchmark.compare_function(
+          @math_source,
+          :add,
+          [5, 3],
+          beam_fn: fn a, b -> a + b end,
+          iterations: 5,
+          warmup: 1
+        )
 
       assert result.name == "add(5, 3)"
     end
@@ -164,7 +176,8 @@ defmodule Firebird.Target.BenchmarkComprehensiveTest do
 
       assert is_binary(csv)
       lines = String.split(csv, "\n")
-      assert length(lines) >= 2  # header + at least one row
+      # header + at least one row
+      assert length(lines) >= 2
 
       header = hd(lines)
       assert String.contains?(header, "name")
diff --git a/test/target/benchmark_test.exs b/test/target/benchmark_test.exs
index ea8247f..e70af5f 100644
--- a/test/target/benchmark_test.exs
+++ b/test/target/benchmark_test.exs
@@ -24,12 +24,15 @@ defmodule Firebird.Target.BenchmarkTest do
 
   describe "compare_function/4" do
     test "compares add function" do
-      result = Benchmark.compare_function(
-        @math_source, :add, [10, 20],
-        beam_fn: fn a, b -> a + b end,
-        iterations: 10,
-        warmup: 2
-      )
+      result =
+        Benchmark.compare_function(
+          @math_source,
+          :add,
+          [10, 20],
+          beam_fn: fn a, b -> a + b end,
+          iterations: 10,
+          warmup: 2
+        )
 
       assert result.correct == true
       assert result.wasm_result == 30
@@ -52,12 +55,15 @@ defmodule Firebird.Target.BenchmarkTest do
     end
 
     test "compares multiply function" do
-      result = Benchmark.compare_function(
-        @math_source, :multiply, [7, 8],
-        beam_fn: fn a, b -> a * b end,
-        iterations: 10,
-        warmup: 2
-      )
+      result =
+        Benchmark.compare_function(
+          @math_source,
+          :multiply,
+          [7, 8],
+          beam_fn: fn a, b -> a * b end,
+          iterations: 10,
+          warmup: 2
+        )
 
       assert result.correct == true
       assert result.wasm_result == 56
@@ -65,12 +71,15 @@ defmodule Firebird.Target.BenchmarkTest do
     end
 
     test "compares fibonacci function" do
-      result = Benchmark.compare_function(
-        @math_source, :fibonacci, [10],
-        beam_fn: fn n -> fib(n) end,
-        iterations: 10,
-        warmup: 2
-      )
+      result =
+        Benchmark.compare_function(
+          @math_source,
+          :fibonacci,
+          [10],
+          beam_fn: fn n -> fib(n) end,
+          iterations: 10,
+          warmup: 2
+        )
 
       assert result.correct == true
       assert result.wasm_result == 55
@@ -78,12 +87,15 @@ defmodule Firebird.Target.BenchmarkTest do
     end
 
     test "compares factorial function" do
-      result = Benchmark.compare_function(
-        @math_source, :factorial, [10],
-        beam_fn: fn n -> fact(n) end,
-        iterations: 10,
-        warmup: 2
-      )
+      result =
+        Benchmark.compare_function(
+          @math_source,
+          :factorial,
+          [10],
+          beam_fn: fn n -> fact(n) end,
+          iterations: 10,
+          warmup: 2
+        )
 
       assert result.correct == true
       assert result.wasm_result == 3_628_800
@@ -91,12 +103,15 @@ defmodule Firebird.Target.BenchmarkTest do
     end
 
     test "name includes function and args" do
-      result = Benchmark.compare_function(
-        @math_source, :add, [5, 3],
-        beam_fn: fn a, b -> a + b end,
-        iterations: 5,
-        warmup: 1
-      )
+      result =
+        Benchmark.compare_function(
+          @math_source,
+          :add,
+          [5, 3],
+          beam_fn: fn a, b -> a + b end,
+          iterations: 5,
+          warmup: 1
+        )
 
       assert result.name == "add(5, 3)"
     end
@@ -122,6 +137,7 @@ defmodule Firebird.Target.BenchmarkTest do
       results = Benchmark.run_suite(iterations: 5, warmup: 1, filter: "fibonacci")
 
       assert length(results) > 0
+
       Enum.each(results, fn r ->
         assert String.contains?(r.name, "fibonacci")
       end)
@@ -143,8 +159,26 @@ defmodule Firebird.Target.BenchmarkTest do
           correct: true,
           wasm_result: 3,
           beam_result: 3,
-          wasm: %{avg: 1.5, min: 1, max: 3, median: 1.5, p95: 2.5, p99: 2.9, stddev: 0.5, total: 15},
-          beam: %{avg: 0.5, min: 0, max: 1, median: 0.5, p95: 1.0, p99: 1.0, stddev: 0.3, total: 5},
+          wasm: %{
+            avg: 1.5,
+            min: 1,
+            max: 3,
+            median: 1.5,
+            p95: 2.5,
+            p99: 2.9,
+            stddev: 0.5,
+            total: 15
+          },
+          beam: %{
+            avg: 0.5,
+            min: 0,
+            max: 1,
+            median: 0.5,
+            p95: 1.0,
+            p99: 1.0,
+            stddev: 0.3,
+            total: 5
+          },
           speedup: 0.333,
           iterations: 10
         }
@@ -175,8 +209,26 @@ defmodule Firebird.Target.BenchmarkTest do
           correct: true,
           wasm_result: 1,
           beam_result: 1,
-          wasm: %{avg: 1.0, min: 1, max: 1, median: 1.0, p95: 1.0, p99: 1.0, stddev: 0.0, total: 1},
-          beam: %{avg: 1.0, min: 1, max: 1, median: 1.0, p95: 1.0, p99: 1.0, stddev: 0.0, total: 1},
+          wasm: %{
+            avg: 1.0,
+            min: 1,
+            max: 1,
+            median: 1.0,
+            p95: 1.0,
+            p99: 1.0,
+            stddev: 0.0,
+            total: 1
+          },
+          beam: %{
+            avg: 1.0,
+            min: 1,
+            max: 1,
+            median: 1.0,
+            p95: 1.0,
+            p99: 1.0,
+            stddev: 0.0,
+            total: 1
+          },
           speedup: 1.0,
           iterations: 1
         },
@@ -187,8 +239,26 @@ defmodule Firebird.Target.BenchmarkTest do
           correct: false,
           wasm_result: 1,
           beam_result: 2,
-          wasm: %{avg: 1.0, min: 1, max: 1, median: 1.0, p95: 1.0, p99: 1.0, stddev: 0.0, total: 1},
-          beam: %{avg: 1.0, min: 1, max: 1, median: 1.0, p95: 1.0, p99: 1.0, stddev: 0.0, total: 1},
+          wasm: %{
+            avg: 1.0,
+            min: 1,
+            max: 1,
+            median: 1.0,
+            p95: 1.0,
+            p99: 1.0,
+            stddev: 0.0,
+            total: 1
+          },
+          beam: %{
+            avg: 1.0,
+            min: 1,
+            max: 1,
+            median: 1.0,
+            p95: 1.0,
+            p99: 1.0,
+            stddev: 0.0,
+            total: 1
+          },
           speedup: 1.0,
           iterations: 1
         }
@@ -211,8 +281,26 @@ defmodule Firebird.Target.BenchmarkTest do
           correct: true,
           wasm_result: 3,
           beam_result: 3,
-          wasm: %{avg: 1.0, min: 1, max: 1, median: 1.0, p95: 1.0, p99: 1.0, stddev: 0.0, total: 1},
-          beam: %{avg: 1.0, min: 1, max: 1, median: 1.0, p95: 1.0, p99: 1.0, stddev: 0.0, total: 1},
+          wasm: %{
+            avg: 1.0,
+            min: 1,
+            max: 1,
+            median: 1.0,
+            p95: 1.0,
+            p99: 1.0,
+            stddev: 0.0,
+            total: 1
+          },
+          beam: %{
+            avg: 1.0,
+            min: 1,
+            max: 1,
+            median: 1.0,
+            p95: 1.0,
+            p99: 1.0,
+            stddev: 0.0,
+            total: 1
+          },
           speedup: 1.0,
           iterations: 10
         }
@@ -236,8 +324,26 @@ defmodule Firebird.Target.BenchmarkTest do
           correct: true,
           wasm_result: 55,
           beam_result: 55,
-          wasm: %{avg: 5.0, min: 4, max: 7, median: 5.0, p95: 6.5, p99: 7.0, stddev: 1.0, total: 50},
-          beam: %{avg: 2.0, min: 1, max: 3, median: 2.0, p95: 3.0, p99: 3.0, stddev: 0.5, total: 20},
+          wasm: %{
+            avg: 5.0,
+            min: 4,
+            max: 7,
+            median: 5.0,
+            p95: 6.5,
+            p99: 7.0,
+            stddev: 1.0,
+            total: 50
+          },
+          beam: %{
+            avg: 2.0,
+            min: 1,
+            max: 3,
+            median: 2.0,
+            p95: 3.0,
+            p99: 3.0,
+            stddev: 0.5,
+            total: 20
+          },
           speedup: 0.4,
           iterations: 10
         }
diff --git a/test/target/compilation_edge_cases_test.exs b/test/target/compilation_edge_cases_test.exs
index d690d2c..48736a5 100644
--- a/test/target/compilation_edge_cases_test.exs
+++ b/test/target/compilation_edge_cases_test.exs
@@ -11,6 +11,7 @@ defmodule Firebird.Target.CompilationEdgeCasesTest do
       defmodule EmptyMod do
       end
       """
+
       # Should not crash, may fail gracefully
       result = Firebird.Compiler.compile_source(source)
       # Either succeeds with empty module or returns error
@@ -20,12 +21,13 @@ defmodule Firebird.Target.CompilationEdgeCasesTest do
 
   describe "single function modules" do
     test "identity function" do
-      assert {:ok, result} = Firebird.Compiler.compile_source("""
-      defmodule Identity do
-        @wasm true
-        def id(x), do: x
-      end
-      """)
+      assert {:ok, result} =
+               Firebird.Compiler.compile_source("""
+               defmodule Identity do
+                 @wasm true
+                 def id(x), do: x
+               end
+               """)
 
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [42]} = Firebird.call(inst, "id", [42])
@@ -35,12 +37,13 @@ defmodule Firebird.Target.CompilationEdgeCasesTest do
     end
 
     test "constant function" do
-      assert {:ok, result} = Firebird.Compiler.compile_source("""
-      defmodule Const do
-        @wasm true
-        def always_42(_x), do: 42
-      end
-      """)
+      assert {:ok, result} =
+               Firebird.Compiler.compile_source("""
+               defmodule Const do
+                 @wasm true
+                 def always_42(_x), do: 42
+               end
+               """)
 
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [42]} = Firebird.call(inst, "always_42", [0])
@@ -49,12 +52,13 @@ defmodule Firebird.Target.CompilationEdgeCasesTest do
     end
 
     test "zero-arg function" do
-      assert {:ok, result} = Firebird.Compiler.compile_source("""
-      defmodule ZeroArg do
-        @wasm true
-        def zero(), do: 0
-      end
-      """)
+      assert {:ok, result} =
+               Firebird.Compiler.compile_source("""
+               defmodule ZeroArg do
+                 @wasm true
+                 def zero(), do: 0
+               end
+               """)
 
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [0]} = Firebird.call(inst, "zero", [])
@@ -64,17 +68,18 @@ defmodule Firebird.Target.CompilationEdgeCasesTest do
 
   describe "multi-clause edge cases" do
     test "many clauses" do
-      assert {:ok, result} = Firebird.Compiler.compile_source("""
-      defmodule ManyClauses do
-        @wasm true
-        def classify(0), do: 0
-        def classify(1), do: 1
-        def classify(2), do: 2
-        def classify(3), do: 3
-        def classify(4), do: 4
-        def classify(_n), do: 99
-      end
-      """)
+      assert {:ok, result} =
+               Firebird.Compiler.compile_source("""
+               defmodule ManyClauses do
+                 @wasm true
+                 def classify(0), do: 0
+                 def classify(1), do: 1
+                 def classify(2), do: 2
+                 def classify(3), do: 3
+                 def classify(4), do: 4
+                 def classify(_n), do: 99
+               end
+               """)
 
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [0]} = Firebird.call(inst, "classify", [0])
@@ -86,12 +91,13 @@ defmodule Firebird.Target.CompilationEdgeCasesTest do
 
   describe "arithmetic edge cases" do
     test "large numbers" do
-      assert {:ok, result} = Firebird.Compiler.compile_source("""
-      defmodule LargeNums do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      assert {:ok, result} =
+               Firebird.Compiler.compile_source("""
+               defmodule LargeNums do
+                 @wasm true
+                 def add(a, b), do: a + b
+               end
+               """)
 
       {:ok, inst} = Firebird.load(result.wasm)
       # WASM i64 can handle large numbers
@@ -100,12 +106,13 @@ defmodule Firebird.Target.CompilationEdgeCasesTest do
     end
 
     test "negative results" do
-      assert {:ok, result} = Firebird.Compiler.compile_source("""
-      defmodule NegResult do
-        @wasm true
-        def sub(a, b), do: a - b
-      end
-      """)
+      assert {:ok, result} =
+               Firebird.Compiler.compile_source("""
+               defmodule NegResult do
+                 @wasm true
+                 def sub(a, b), do: a - b
+               end
+               """)
 
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [-10]} = Firebird.call(inst, "sub", [0, 10])
@@ -114,15 +121,16 @@ defmodule Firebird.Target.CompilationEdgeCasesTest do
     end
 
     test "division and remainder" do
-      assert {:ok, result} = Firebird.Compiler.compile_source("""
-      defmodule DivRem do
-        @wasm true
-        def integer_div(a, b), do: div(a, b)
+      assert {:ok, result} =
+               Firebird.Compiler.compile_source("""
+               defmodule DivRem do
+                 @wasm true
+                 def integer_div(a, b), do: div(a, b)
 
-        @wasm true
-        def remainder(a, b), do: rem(a, b)
-      end
-      """)
+                 @wasm true
+                 def remainder(a, b), do: rem(a, b)
+               end
+               """)
 
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [3]} = Firebird.call(inst, "integer_div", [10, 3])
@@ -134,26 +142,27 @@ defmodule Firebird.Target.CompilationEdgeCasesTest do
 
   describe "deeply nested expressions" do
     test "nested if/else" do
-      assert {:ok, result} = Firebird.Compiler.compile_source("""
-      defmodule DeepNest do
-        @wasm true
-        def classify(n) do
-          if n > 0 do
-            if n > 10 do
-              if n > 100 do
-                3
-              else
-                2
-              end
-            else
-              1
-            end
-          else
-            0
-          end
-        end
-      end
-      """)
+      assert {:ok, result} =
+               Firebird.Compiler.compile_source("""
+               defmodule DeepNest do
+                 @wasm true
+                 def classify(n) do
+                   if n > 0 do
+                     if n > 10 do
+                       if n > 100 do
+                         3
+                       else
+                         2
+                       end
+                     else
+                       1
+                     end
+                   else
+                     0
+                   end
+                 end
+               end
+               """)
 
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [0]} = Firebird.call(inst, "classify", [-5])
@@ -166,15 +175,16 @@ defmodule Firebird.Target.CompilationEdgeCasesTest do
 
   describe "multiple functions in one module" do
     test "functions can call each other" do
-      assert {:ok, result} = Firebird.Compiler.compile_source("""
-      defmodule MultiFunc do
-        @wasm true
-        def double(n), do: n * 2
+      assert {:ok, result} =
+               Firebird.Compiler.compile_source("""
+               defmodule MultiFunc do
+                 @wasm true
+                 def double(n), do: n * 2
 
-        @wasm true
-        def quadruple(n), do: double(double(n))
-      end
-      """)
+                 @wasm true
+                 def quadruple(n), do: double(double(n))
+               end
+               """)
 
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [10]} = Firebird.call(inst, "double", [5])
@@ -183,20 +193,21 @@ defmodule Firebird.Target.CompilationEdgeCasesTest do
     end
 
     test "many exported functions" do
-      assert {:ok, result} = Firebird.Compiler.compile_source("""
-      defmodule ManyExports do
-        @wasm true
-        def f1(n), do: n + 1
-        @wasm true
-        def f2(n), do: n + 2
-        @wasm true
-        def f3(n), do: n + 3
-        @wasm true
-        def f4(n), do: n + 4
-        @wasm true
-        def f5(n), do: n + 5
-      end
-      """)
+      assert {:ok, result} =
+               Firebird.Compiler.compile_source("""
+               defmodule ManyExports do
+                 @wasm true
+                 def f1(n), do: n + 1
+                 @wasm true
+                 def f2(n), do: n + 2
+                 @wasm true
+                 def f3(n), do: n + 3
+                 @wasm true
+                 def f4(n), do: n + 4
+                 @wasm true
+                 def f5(n), do: n + 5
+               end
+               """)
 
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [6]} = Firebird.call(inst, "f1", [5])
@@ -255,12 +266,13 @@ defmodule Firebird.Target.CompilationEdgeCasesTest do
 
   describe "WAT output" do
     test "WAT contains module and export" do
-      {:ok, result} = Firebird.Compiler.compile_source("""
-      defmodule WatCheck do
-        @wasm true
-        def inc(n), do: n + 1
-      end
-      """)
+      {:ok, result} =
+        Firebird.Compiler.compile_source("""
+        defmodule WatCheck do
+          @wasm true
+          def inc(n), do: n + 1
+        end
+        """)
 
       assert String.contains?(result.wat, "(module")
       assert String.contains?(result.wat, "(export")
@@ -268,12 +280,16 @@ defmodule Firebird.Target.CompilationEdgeCasesTest do
     end
 
     test "WAT-only mode produces no binary" do
-      {:ok, result} = Firebird.Compiler.compile_source("""
-      defmodule WatOnly do
-        @wasm true
-        def dec(n), do: n - 1
-      end
-      """, wat_only: true)
+      {:ok, result} =
+        Firebird.Compiler.compile_source(
+          """
+          defmodule WatOnly do
+            @wasm true
+            def dec(n), do: n - 1
+          end
+          """,
+          wat_only: true
+        )
 
       assert result.wat != nil
       assert result.wasm == nil
diff --git a/test/target/compile_integration_test.exs b/test/target/compile_integration_test.exs
index 9f24a6f..d031105 100644
--- a/test/target/compile_integration_test.exs
+++ b/test/target/compile_integration_test.exs
@@ -8,7 +8,10 @@ defmodule Firebird.Target.CompileIntegrationTest do
 
   alias Firebird.Target.{Config, ContentHash, Parallel}
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_compile_integ_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_compile_integ_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -23,20 +26,23 @@ defmodule Firebird.Target.CompileIntegrationTest do
 
   defp write_module(dir, name, body) do
     path = Path.join(dir, "#{String.downcase(to_string(name))}.ex")
+
     File.write!(path, """
     defmodule #{name} do
       #{body}
     end
     """)
+
     path
   end
 
   describe "content hash + compilation integration" do
     test "hash changes when content changes", %{src_dir: src} do
-      path = write_module(src, "IntHashMod", """
-        @wasm true
-        def add(a, b), do: a + b
-      """)
+      path =
+        write_module(src, "IntHashMod", """
+          @wasm true
+          def add(a, b), do: a + b
+        """)
 
       h1 = ContentHash.hash_file(path)
 
@@ -67,15 +73,17 @@ defmodule Firebird.Target.CompileIntegrationTest do
     end
 
     test "content hash filter detects modified files", %{src_dir: src} do
-      f1 = write_module(src, "IntFilterA", """
-        @wasm true
-        def a(x), do: x
-      """)
-
-      f2 = write_module(src, "IntFilterB", """
-        @wasm true
-        def b(x), do: x
-      """)
+      f1 =
+        write_module(src, "IntFilterA", """
+          @wasm true
+          def a(x), do: x
+        """)
+
+      f2 =
+        write_module(src, "IntFilterB", """
+          @wasm true
+          def b(x), do: x
+        """)
 
       # Build initial manifest
       manifest = ContentHash.build_manifest([f1, f2])
@@ -94,20 +102,23 @@ defmodule Firebird.Target.CompileIntegrationTest do
 
   describe "parallel compilation integration" do
     test "parallel compile produces correct results", %{src_dir: src, out_dir: out} do
-      f1 = write_module(src, "IntParA", """
-        @wasm true
-        def add(a, b), do: a + b
-      """)
-
-      f2 = write_module(src, "IntParB", """
-        @wasm true
-        def mul(a, b), do: a * b
-      """)
-
-      f3 = write_module(src, "IntParC", """
-        @wasm true
-        def sub(a, b), do: a - b
-      """)
+      f1 =
+        write_module(src, "IntParA", """
+          @wasm true
+          def add(a, b), do: a + b
+        """)
+
+      f2 =
+        write_module(src, "IntParB", """
+          @wasm true
+          def mul(a, b), do: a * b
+        """)
+
+      f3 =
+        write_module(src, "IntParC", """
+          @wasm true
+          def sub(a, b), do: a - b
+        """)
 
       config = Config.new(output_dir: out)
       assert {:ok, results} = Parallel.compile([f1, f2, f3], config)
@@ -129,15 +140,17 @@ defmodule Firebird.Target.CompileIntegrationTest do
     end
 
     test "parallel compile with max_concurrency=1 (sequential)", %{src_dir: src, out_dir: out} do
-      f1 = write_module(src, "IntSeqA", """
-        @wasm true
-        def inc(n), do: n + 1
-      """)
-
-      f2 = write_module(src, "IntSeqB", """
-        @wasm true
-        def dec(n), do: n - 1
-      """)
+      f1 =
+        write_module(src, "IntSeqA", """
+          @wasm true
+          def inc(n), do: n + 1
+        """)
+
+      f2 =
+        write_module(src, "IntSeqB", """
+          @wasm true
+          def dec(n), do: n - 1
+        """)
 
       config = Config.new(output_dir: out)
       assert {:ok, results} = Parallel.compile([f1, f2], config, max_concurrency: 1)
@@ -175,13 +188,14 @@ defmodule Firebird.Target.CompileIntegrationTest do
         def sum(n), do: n + sum(n - 1)
       """)
 
-      config = Config.new(
-        sources: [src],
-        output_dir: out,
-        optimize: true,
-        tco: true,
-        inline: true
-      )
+      config =
+        Config.new(
+          sources: [src],
+          output_dir: out,
+          optimize: true,
+          tco: true,
+          inline: true
+        )
 
       assert {:ok, [result]} = Firebird.Target.compile(config)
       assert result.wat != nil
diff --git a/test/target/compiler_integration_test.exs b/test/target/compiler_integration_test.exs
index 1b797ce..7c5ca8c 100644
--- a/test/target/compiler_integration_test.exs
+++ b/test/target/compiler_integration_test.exs
@@ -7,7 +7,10 @@ defmodule Firebird.Target.CompilerIntegrationTest do
 
   alias Mix.Compilers.FirebirdWasm
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_compiler_int_test_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_compiler_int_test_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -126,22 +129,24 @@ defmodule Firebird.Target.CompilerIntegrationTest do
 
   describe "has_wasm_annotation?/1" do
     test "returns true for annotated file", %{tmp_dir: dir} do
-      path = write_file(dir, "annotated.ex", """
-      defmodule Annotated do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      path =
+        write_file(dir, "annotated.ex", """
+        defmodule Annotated do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
       assert FirebirdWasm.has_wasm_annotation?(path)
     end
 
     test "returns false for non-annotated file", %{tmp_dir: dir} do
-      path = write_file(dir, "plain.ex", """
-      defmodule Plain do
-        def add(a, b), do: a + b
-      end
-      """)
+      path =
+        write_file(dir, "plain.ex", """
+        defmodule Plain do
+          def add(a, b), do: a + b
+        end
+        """)
 
       refute FirebirdWasm.has_wasm_annotation?(path)
     end
diff --git a/test/target/config_comprehensive_test.exs b/test/target/config_comprehensive_test.exs
index ebc0d9e..e3f4a65 100644
--- a/test/target/config_comprehensive_test.exs
+++ b/test/target/config_comprehensive_test.exs
@@ -20,18 +20,19 @@ defmodule Firebird.Target.ConfigComprehensiveTest do
     end
 
     test "creates config with custom values" do
-      config = Config.new(
-        output_dir: "priv/wasm",
-        sources: ["lib/wasm_modules"],
-        optimize: true,
-        tco: true,
-        inline: true,
-        wat_only: true,
-        verify: true,
-        source_map: true,
-        verbose: true,
-        force: true
-      )
+      config =
+        Config.new(
+          output_dir: "priv/wasm",
+          sources: ["lib/wasm_modules"],
+          optimize: true,
+          tco: true,
+          inline: true,
+          wat_only: true,
+          verify: true,
+          source_map: true,
+          verbose: true,
+          force: true
+        )
 
       assert config.output_dir == "priv/wasm"
       assert config.sources == ["lib/wasm_modules"]
diff --git a/test/target/config_extended_test.exs b/test/target/config_extended_test.exs
index 2da6b49..e54ed29 100644
--- a/test/target/config_extended_test.exs
+++ b/test/target/config_extended_test.exs
@@ -20,19 +20,20 @@ defmodule Firebird.Target.ConfigExtendedTest do
     end
 
     test "accepts all known options" do
-      config = Config.new(
-        output_dir: "custom/out",
-        sources: ["src1", "src2"],
-        files: ["a.ex", "b.ex"],
-        optimize: true,
-        tco: true,
-        inline: true,
-        wat_only: true,
-        verify: true,
-        source_map: true,
-        verbose: true,
-        force: true
-      )
+      config =
+        Config.new(
+          output_dir: "custom/out",
+          sources: ["src1", "src2"],
+          files: ["a.ex", "b.ex"],
+          optimize: true,
+          tco: true,
+          inline: true,
+          wat_only: true,
+          verify: true,
+          source_map: true,
+          verbose: true,
+          force: true
+        )
 
       assert config.output_dir == "custom/out"
       assert config.sources == ["src1", "src2"]
@@ -64,13 +65,15 @@ defmodule Firebird.Target.ConfigExtendedTest do
 
     test "can override all fields" do
       base = Config.new()
-      merged = Config.merge(base,
-        output_dir: "new",
-        optimize: true,
-        tco: true,
-        inline: true,
-        verbose: true
-      )
+
+      merged =
+        Config.merge(base,
+          output_dir: "new",
+          optimize: true,
+          tco: true,
+          inline: true,
+          verbose: true
+        )
 
       assert merged.output_dir == "new"
       assert merged.optimize == true
diff --git a/test/target/config_test.exs b/test/target/config_test.exs
index fd1ec84..af143b0 100644
--- a/test/target/config_test.exs
+++ b/test/target/config_test.exs
@@ -21,14 +21,15 @@ defmodule Firebird.Target.ConfigTest do
     end
 
     test "creates config with custom options" do
-      config = Config.new(
-        output_dir: "priv/wasm",
-        sources: ["lib/wasm"],
-        optimize: true,
-        tco: true,
-        inline: true,
-        verbose: true
-      )
+      config =
+        Config.new(
+          output_dir: "priv/wasm",
+          sources: ["lib/wasm"],
+          optimize: true,
+          tco: true,
+          inline: true,
+          verbose: true
+        )
 
       assert config.output_dir == "priv/wasm"
       assert config.sources == ["lib/wasm"]
@@ -44,19 +45,20 @@ defmodule Firebird.Target.ConfigTest do
     end
 
     test "creates config with all options" do
-      config = Config.new(
-        output_dir: "out",
-        sources: ["src"],
-        files: ["a.ex"],
-        optimize: true,
-        tco: true,
-        inline: true,
-        wat_only: true,
-        verify: true,
-        source_map: true,
-        verbose: true,
-        force: true
-      )
+      config =
+        Config.new(
+          output_dir: "out",
+          sources: ["src"],
+          files: ["a.ex"],
+          optimize: true,
+          tco: true,
+          inline: true,
+          wat_only: true,
+          verify: true,
+          source_map: true,
+          verbose: true,
+          force: true
+        )
 
       assert config.output_dir == "out"
       assert config.sources == ["src"]
@@ -123,7 +125,9 @@ defmodule Firebird.Target.ConfigTest do
     end
 
     test "warns about nonexistent source directory" do
-      config = Config.new(sources: ["/nonexistent/source/dir_#{:erlang.unique_integer([:positive])}"])
+      config =
+        Config.new(sources: ["/nonexistent/source/dir_#{:erlang.unique_integer([:positive])}"])
+
       assert {:ok, warnings} = Config.validate(config)
       assert Enum.any?(warnings, &String.contains?(&1, "Source directory not found"))
     end
@@ -141,7 +145,9 @@ defmodule Firebird.Target.ConfigTest do
     end
 
     test "warns about absolute output dir with nonexistent parent" do
-      config = Config.new(output_dir: "/nonexistent_parent_#{:erlang.unique_integer([:positive])}/wasm")
+      config =
+        Config.new(output_dir: "/nonexistent_parent_#{:erlang.unique_integer([:positive])}/wasm")
+
       assert {:ok, warnings} = Config.validate(config)
       assert Enum.any?(warnings, &String.contains?(&1, "Output directory parent"))
     end
diff --git a/test/target/content_hash_comprehensive_test.exs b/test/target/content_hash_comprehensive_test.exs
index 70c15dd..ea00987 100644
--- a/test/target/content_hash_comprehensive_test.exs
+++ b/test/target/content_hash_comprehensive_test.exs
@@ -53,9 +53,15 @@ defmodule Firebird.Target.ContentHashComprehensiveTest do
 
     test "hash length is consistent" do
       h1 = ContentHash.hash_content("short")
-      h2 = ContentHash.hash_content("a much longer piece of code that spans multiple lines\nand has more content")
+
+      h2 =
+        ContentHash.hash_content(
+          "a much longer piece of code that spans multiple lines\nand has more content"
+        )
+
       assert String.length(h1) == String.length(h2)
-      assert String.length(h1) == 64  # SHA-256 hex = 64 chars
+      # SHA-256 hex = 64 chars
+      assert String.length(h1) == 64
     end
   end
 
diff --git a/test/target/content_hash_test.exs b/test/target/content_hash_test.exs
index 461adb3..d5d50b5 100644
--- a/test/target/content_hash_test.exs
+++ b/test/target/content_hash_test.exs
@@ -3,7 +3,10 @@ defmodule Firebird.Target.ContentHashTest do
 
   alias Firebird.Target.ContentHash
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_content_hash_test_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_content_hash_test_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -46,7 +49,8 @@ defmodule Firebird.Target.ContentHashTest do
       hash = ContentHash.hash_content("test")
       assert is_binary(hash)
       assert Regex.match?(~r/^[0-9a-f]+$/, hash)
-      assert byte_size(hash) == 64  # SHA-256 = 32 bytes = 64 hex chars
+      # SHA-256 = 32 bytes = 64 hex chars
+      assert byte_size(hash) == 64
     end
   end
 
diff --git a/test/target/dependency_tracker_test.exs b/test/target/dependency_tracker_test.exs
index 8eb0492..ec2d696 100644
--- a/test/target/dependency_tracker_test.exs
+++ b/test/target/dependency_tracker_test.exs
@@ -3,7 +3,10 @@ defmodule Firebird.Compiler.DependencyTrackerTest do
 
   alias Firebird.Compiler.DependencyTracker
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_dep_tracker_test_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_dep_tracker_test_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -19,19 +22,21 @@ defmodule Firebird.Compiler.DependencyTrackerTest do
 
   describe "analyze/1" do
     test "analyzes independent modules", %{tmp_dir: dir} do
-      f1 = write_module(dir, "a", """
-      defmodule DepA do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
-
-      f2 = write_module(dir, "b", """
-      defmodule DepB do
-        @wasm true
-        def mul(a, b), do: a * b
-      end
-      """)
+      f1 =
+        write_module(dir, "a", """
+        defmodule DepA do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
+
+      f2 =
+        write_module(dir, "b", """
+        defmodule DepB do
+          @wasm true
+          def mul(a, b), do: a * b
+        end
+        """)
 
       assert {:ok, graph} = DependencyTracker.analyze([f1, f2])
       assert is_map(graph)
diff --git a/test/target/diagnostics_comprehensive_test.exs b/test/target/diagnostics_comprehensive_test.exs
index b0d1f4f..80e4f19 100644
--- a/test/target/diagnostics_comprehensive_test.exs
+++ b/test/target/diagnostics_comprehensive_test.exs
@@ -67,7 +67,7 @@ defmodule Firebird.Target.DiagnosticsComprehensiveTest do
     test "reports compilable code as compilable" do
       report = Diagnostics.analyze_code(@compilable_code)
       assert report.compilable == true
-      assert report.module == :"DiagTestMath"
+      assert report.module == :DiagTestMath
       assert report.function_count == 1
     end
 
@@ -131,6 +131,7 @@ defmodule Firebird.Target.DiagnosticsComprehensiveTest do
 
     test "diagnostics include severity" do
       report = Diagnostics.analyze_code(@process_code)
+
       Enum.each(report.diagnostics, fn d ->
         assert d.severity in [:error, :warning, :info, :hint]
       end)
@@ -138,7 +139,9 @@ defmodule Firebird.Target.DiagnosticsComprehensiveTest do
 
     test "info diagnostics report function count" do
       report = Diagnostics.analyze_code(@compilable_code)
-      info_messages = report.diagnostics
+
+      info_messages =
+        report.diagnostics
         |> Enum.filter(&(&1.severity == :info))
         |> Enum.map(& &1.message)
 
@@ -159,14 +162,19 @@ defmodule Firebird.Target.DiagnosticsComprehensiveTest do
     end
 
     test "returns error for nonexistent file" do
-      assert {:error, {:file_read_error, :enoent, _}} = Diagnostics.analyze_file("/nonexistent.ex")
+      assert {:error, {:file_read_error, :enoent, _}} =
+               Diagnostics.analyze_file("/nonexistent.ex")
     end
   end
 
   describe "analyze_files/1" do
     test "analyzes multiple files" do
-      tmp1 = Path.join(System.tmp_dir!(), "diag_multi_1_#{:erlang.unique_integer([:positive])}.ex")
-      tmp2 = Path.join(System.tmp_dir!(), "diag_multi_2_#{:erlang.unique_integer([:positive])}.ex")
+      tmp1 =
+        Path.join(System.tmp_dir!(), "diag_multi_1_#{:erlang.unique_integer([:positive])}.ex")
+
+      tmp2 =
+        Path.join(System.tmp_dir!(), "diag_multi_2_#{:erlang.unique_integer([:positive])}.ex")
+
       File.write!(tmp1, @compilable_code)
       File.write!(tmp2, @io_code)
 
diff --git a/test/target/diagnostics_edge_cases_test.exs b/test/target/diagnostics_edge_cases_test.exs
index cd885ef..f302311 100644
--- a/test/target/diagnostics_edge_cases_test.exs
+++ b/test/target/diagnostics_edge_cases_test.exs
@@ -3,7 +3,10 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   alias Firebird.Target.Diagnostics
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_diag_edge_test_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_diag_edge_test_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -21,16 +24,17 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   describe "unsupported pattern: receive blocks" do
     test "detects receive do blocks" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadReceive do
-        @wasm true
-        def wait do
-          receive do
-            :ok -> 1
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadReceive do
+          @wasm true
+          def wait do
+            receive do
+              :ok -> 1
+            end
           end
         end
-      end
-      """)
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "Receive blocks"))
@@ -39,14 +43,15 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   describe "unsupported pattern: send" do
     test "detects send() calls" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadSend do
-        @wasm true
-        def notify(pid) do
-          send(pid, :hello)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadSend do
+          @wasm true
+          def notify(pid) do
+            send(pid, :hello)
+          end
         end
-      end
-      """)
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "Message passing"))
@@ -55,14 +60,15 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   describe "unsupported pattern: Agent" do
     test "detects Agent module usage" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadAgent do
-        @wasm true
-        def start do
-          Agent.start_link(fn -> 0 end)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadAgent do
+          @wasm true
+          def start do
+            Agent.start_link(fn -> 0 end)
+          end
         end
-      end
-      """)
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "Agent"))
@@ -71,14 +77,15 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   describe "unsupported pattern: Task" do
     test "detects Task module usage" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadTask do
-        @wasm true
-        def run do
-          Task.async(fn -> 42 end)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadTask do
+          @wasm true
+          def run do
+            Task.async(fn -> 42 end)
+          end
         end
-      end
-      """)
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "Task"))
@@ -87,14 +94,15 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   describe "unsupported pattern: Stream module" do
     test "detects Stream module usage" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadStream do
-        @wasm true
-        def lazy do
-          Stream.map(1..10, &(&1 * 2))
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadStream do
+          @wasm true
+          def lazy do
+            Stream.map(1..10, &(&1 * 2))
+          end
         end
-      end
-      """)
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "Stream"))
@@ -103,14 +111,15 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   describe "unsupported pattern: Keyword" do
     test "detects Keyword module usage" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadKeyword do
-        @wasm true
-        def get_opt(opts) do
-          Keyword.get(opts, :key)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadKeyword do
+          @wasm true
+          def get_opt(opts) do
+            Keyword.get(opts, :key)
+          end
         end
-      end
-      """)
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "Keyword"))
@@ -119,14 +128,15 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   describe "unsupported pattern: erlang calls" do
     test "detects :erlang. calls" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadErlang do
-        @wasm true
-        def now do
-          :erlang.monotonic_time()
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadErlang do
+          @wasm true
+          def now do
+            :erlang.monotonic_time()
+          end
         end
-      end
-      """)
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "Erlang"))
@@ -135,16 +145,17 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   describe "unsupported pattern: with expressions" do
     test "detects with <- expressions" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadWith do
-        @wasm true
-        def process(x) do
-          with {:ok, val} <- validate(x) do
-            val
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadWith do
+          @wasm true
+          def process(x) do
+            with {:ok, val} <- validate(x) do
+              val
+            end
           end
         end
-      end
-      """)
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "With expressions"))
@@ -153,14 +164,15 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   describe "unsupported pattern: comprehensions" do
     test "detects for <- comprehensions" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadFor do
-        @wasm true
-        def squares do
-          for x <- 1..10, do: x * x
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadFor do
+          @wasm true
+          def squares do
+            for x <- 1..10, do: x * x
+          end
         end
-      end
-      """)
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "Comprehensions"))
@@ -169,13 +181,14 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   describe "unsupported pattern: import" do
     test "detects import statements" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadImport do
-        import SomeModule
-        @wasm true
-        def calc, do: 1
-      end
-      """)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadImport do
+          import SomeModule
+          @wasm true
+          def calc, do: 1
+        end
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "imports"))
@@ -184,13 +197,14 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   describe "unsupported pattern: use macros" do
     test "detects use statements" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadUse do
-        use SomeLib
-        @wasm true
-        def calc, do: 1
-      end
-      """)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadUse do
+          use SomeLib
+          @wasm true
+          def calc, do: 1
+        end
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "Use macros"))
@@ -199,13 +213,14 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   describe "unsupported pattern: alias" do
     test "detects alias statements" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadAlias do
-        alias Some.Module
-        @wasm true
-        def calc, do: 1
-      end
-      """)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadAlias do
+          alias Some.Module
+          @wasm true
+          def calc, do: 1
+        end
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "aliases"))
@@ -214,14 +229,15 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   describe "unsupported pattern: maps" do
     test "detects map literals" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadMap2 do
-        @wasm true
-        def make_map do
-          %{a: 1, b: 2}
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadMap2 do
+          @wasm true
+          def make_map do
+            %{a: 1, b: 2}
+          end
         end
-      end
-      """)
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "Maps"))
@@ -230,14 +246,15 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   describe "unsupported pattern: tuples" do
     test "detects tuple literals" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadTuple do
-        @wasm true
-        def make_tuple do
-          {1, 2, 3}
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadTuple do
+          @wasm true
+          def make_tuple do
+            {1, 2, 3}
+          end
         end
-      end
-      """)
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "Tuples"))
@@ -246,12 +263,13 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   describe "unsupported pattern: lists" do
     test "detects cons-style list patterns" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadList do
-        @wasm true
-        def head([h|_t]), do: h
-      end
-      """)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadList do
+          @wasm true
+          def head([h|_t]), do: h
+        end
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "Lists"))
@@ -262,32 +280,35 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   describe "optimization hints" do
     test "suggests TCO for recursive functions" do
-      report = Diagnostics.analyze_code("""
-      defmodule RecursiveMod do
-        @wasm true
-        def sum(0), do: 0
-        def sum(n) do
-          sum(n - 1)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule RecursiveMod do
+          @wasm true
+          def sum(0), do: 0
+          def sum(n) do
+            sum(n - 1)
+          end
         end
-      end
-      """)
+        """)
 
       hints = Enum.filter(report.diagnostics, &(&1.severity == :hint))
       assert Enum.any?(hints, &String.contains?(&1.message, "tco"))
     end
 
     test "hints have nil line numbers" do
-      report = Diagnostics.analyze_code("""
-      defmodule HintLines do
-        @wasm true
-        def f(0), do: 0
-        def f(n) do
-          f(n - 1)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule HintLines do
+          @wasm true
+          def f(0), do: 0
+          def f(n) do
+            f(n - 1)
+          end
         end
-      end
-      """)
+        """)
 
       hints = Enum.filter(report.diagnostics, &(&1.severity == :hint))
+
       for hint <- hints do
         assert hint.line == nil
       end
@@ -298,14 +319,15 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   describe "compilable? edge cases" do
     test "returns true for module with only warnings (no errors)", %{tmp_dir: dir} do
-      path = write_file(dir, "warn_only.ex", """
-      defmodule WarnOnly do
-        @wasm true
-        def bad do
-          IO.puts("hi")
+      path =
+        write_file(dir, "warn_only.ex", """
+        defmodule WarnOnly do
+          @wasm true
+          def bad do
+            IO.puts("hi")
+          end
         end
-      end
-      """)
+        """)
 
       # Warnings don't make it uncompilable - only errors do
       assert {:ok, report} = Diagnostics.analyze_file(path)
@@ -334,38 +356,41 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
     end
 
     test "handles code with only comments" do
-      report = Diagnostics.analyze_code("""
-      # Just a comment
-      # Another comment
-      """)
+      report =
+        Diagnostics.analyze_code("""
+        # Just a comment
+        # Another comment
+        """)
 
       assert report.compilable == true
       assert report.function_count == 0
     end
 
     test "handles module with no functions" do
-      report = Diagnostics.analyze_code("""
-      defmodule Empty do
-      end
-      """)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule Empty do
+        end
+        """)
 
-      assert report.module == :"Empty"
+      assert report.module == :Empty
       assert report.function_count == 0
       assert report.compilable == true
     end
 
     test "handles multiple modules (picks first)" do
-      report = Diagnostics.analyze_code("""
-      defmodule First do
-        @wasm true
-        def one, do: 1
-      end
+      report =
+        Diagnostics.analyze_code("""
+        defmodule First do
+          @wasm true
+          def one, do: 1
+        end
 
-      defmodule Second do
-        @wasm true
-        def two, do: 2
-      end
-      """)
+        defmodule Second do
+          @wasm true
+          def two, do: 2
+        end
+        """)
 
       # Should pick up at least one module
       assert report.module != nil
@@ -377,48 +402,56 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
     end
 
     test "file parameter is passed to diagnostics source" do
-      report = Diagnostics.analyze_code("""
-      defmodule WithIO do
-        @wasm true
-        def bad do
-          IO.puts("hi")
-        end
-      end
-      """, "test_source.ex")
+      report =
+        Diagnostics.analyze_code(
+          """
+          defmodule WithIO do
+            @wasm true
+            def bad do
+              IO.puts("hi")
+            end
+          end
+          """,
+          "test_source.ex"
+        )
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
+
       for w <- warnings do
         assert w.source == "test_source.ex"
       end
     end
 
     test "estimated size is nil when function_count is 0" do
-      report = Diagnostics.analyze_code("""
-      defmodule NoFuncs do
-      end
-      """)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule NoFuncs do
+        end
+        """)
 
       assert report.estimated_wasm_size == nil
     end
 
     test "estimated size grows with more functions" do
-      report1 = Diagnostics.analyze_code("""
-      defmodule One do
-        @wasm true
-        def a, do: 1
-      end
-      """)
-
-      report3 = Diagnostics.analyze_code("""
-      defmodule Three do
-        @wasm true
-        def a, do: 1
-        @wasm true
-        def b, do: 2
-        @wasm true
-        def c, do: 3
-      end
-      """)
+      report1 =
+        Diagnostics.analyze_code("""
+        defmodule One do
+          @wasm true
+          def a, do: 1
+        end
+        """)
+
+      report3 =
+        Diagnostics.analyze_code("""
+        defmodule Three do
+          @wasm true
+          def a, do: 1
+          @wasm true
+          def b, do: 2
+          @wasm true
+          def c, do: 3
+        end
+        """)
 
       assert report1.estimated_wasm_size != nil
       assert report3.estimated_wasm_size != nil
@@ -430,12 +463,13 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   describe "analyze_files edge cases" do
     test "handles mix of valid and invalid files", %{tmp_dir: dir} do
-      good = write_file(dir, "good.ex", """
-      defmodule Good do
-        @wasm true
-        def ok, do: 1
-      end
-      """)
+      good =
+        write_file(dir, "good.ex", """
+        defmodule Good do
+          @wasm true
+          def ok, do: 1
+        end
+        """)
 
       bad = write_file(dir, "bad.ex", "def foo(, do: 1")
 
@@ -460,7 +494,7 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
     test "formats report with hint diagnostics" do
       report = %{
         file: "test.ex",
-        module: :"Test",
+        module: :Test,
         compilable: true,
         diagnostics: [
           %{severity: :hint, message: "May benefit from --tco", line: nil, source: nil}
@@ -477,7 +511,7 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
     test "formats report with info icon" do
       report = %{
         file: "test.ex",
-        module: :"Test",
+        module: :Test,
         compilable: true,
         diagnostics: [
           %{severity: :info, message: "1 function(s) found", line: nil, source: nil}
@@ -507,7 +541,7 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
     test "formats report with no diagnostics" do
       report = %{
         file: "clean.ex",
-        module: :"Clean",
+        module: :Clean,
         compilable: true,
         diagnostics: [],
         function_count: 0,
@@ -578,8 +612,22 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
   describe "format_reports edge cases" do
     test "separates reports with double newlines" do
       reports = [
-        %{file: "a.ex", module: :A, compilable: true, diagnostics: [], function_count: 0, estimated_wasm_size: nil},
-        %{file: "b.ex", module: :B, compilable: true, diagnostics: [], function_count: 0, estimated_wasm_size: nil}
+        %{
+          file: "a.ex",
+          module: :A,
+          compilable: true,
+          diagnostics: [],
+          function_count: 0,
+          estimated_wasm_size: nil
+        },
+        %{
+          file: "b.ex",
+          module: :B,
+          compilable: true,
+          diagnostics: [],
+          function_count: 0,
+          estimated_wasm_size: nil
+        }
       ]
 
       output = Diagnostics.format_reports(reports)
@@ -592,7 +640,14 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
     test "single report formatting" do
       reports = [
-        %{file: "only.ex", module: :Only, compilable: true, diagnostics: [], function_count: 1, estimated_wasm_size: 120}
+        %{
+          file: "only.ex",
+          module: :Only,
+          compilable: true,
+          diagnostics: [],
+          function_count: 1,
+          estimated_wasm_size: 120
+        }
       ]
 
       output = Diagnostics.format_reports(reports)
@@ -605,20 +660,21 @@ defmodule Firebird.Target.DiagnosticsEdgeCasesTest do
 
   describe "line number accuracy for warnings" do
     test "line number is correct for pattern later in file" do
-      report = Diagnostics.analyze_code("""
-      defmodule LineTest do
-        @wasm true
-        def good_func(a, b), do: a + b
-
-        @wasm true
-        def another(x), do: x * 2
-
-        @wasm true
-        def bad_func do
-          IO.puts("on line 10")
+      report =
+        Diagnostics.analyze_code("""
+        defmodule LineTest do
+          @wasm true
+          def good_func(a, b), do: a + b
+
+          @wasm true
+          def another(x), do: x * 2
+
+          @wasm true
+          def bad_func do
+            IO.puts("on line 10")
+          end
         end
-      end
-      """)
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       io_warning = Enum.find(warnings, &String.contains?(&1.message, "IO"))
diff --git a/test/target/diagnostics_test.exs b/test/target/diagnostics_test.exs
index 28170c8..f198d0a 100644
--- a/test/target/diagnostics_test.exs
+++ b/test/target/diagnostics_test.exs
@@ -3,7 +3,10 @@ defmodule Firebird.Target.DiagnosticsTest do
 
   alias Firebird.Target.Diagnostics
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_diag_test_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_diag_test_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -19,137 +22,147 @@ defmodule Firebird.Target.DiagnosticsTest do
 
   describe "analyze_code/2" do
     test "clean module has no warnings" do
-      report = Diagnostics.analyze_code("""
-      defmodule Clean do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule Clean do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
       assert report.compilable == true
       assert report.function_count == 1
-      assert report.module == :"Clean"
+      assert report.module == :Clean
       refute Enum.any?(report.diagnostics, &(&1.severity == :error))
       refute Enum.any?(report.diagnostics, &(&1.severity == :warning))
     end
 
     test "detects spawn usage" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadSpawn do
-        @wasm true
-        def start do
-          spawn(fn -> :ok end)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadSpawn do
+          @wasm true
+          def start do
+            spawn(fn -> :ok end)
+          end
         end
-      end
-      """)
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "Process spawning"))
     end
 
     test "detects IO usage" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadIO do
-        @wasm true
-        def greet do
-          IO.puts("hello")
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadIO do
+          @wasm true
+          def greet do
+            IO.puts("hello")
+          end
         end
-      end
-      """)
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "IO operations"))
     end
 
     test "detects GenServer usage" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadGenServer do
-        use GenServer
-        @wasm true
-        def start, do: GenServer.start(__MODULE__, [])
-      end
-      """)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadGenServer do
+          use GenServer
+          @wasm true
+          def start, do: GenServer.start(__MODULE__, [])
+        end
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "GenServer"))
     end
 
     test "detects Enum usage" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadEnum do
-        @wasm true
-        def sum(list), do: Enum.sum(list)
-      end
-      """)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadEnum do
+          @wasm true
+          def sum(list), do: Enum.sum(list)
+        end
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "Enum"))
     end
 
     test "detects Map usage" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadMap do
-        @wasm true
-        def get(map, key), do: Map.get(map, key)
-      end
-      """)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadMap do
+          @wasm true
+          def get(map, key), do: Map.get(map, key)
+        end
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "Map"))
     end
 
     test "detects String usage" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadString do
-        @wasm true
-        def upper(s), do: String.upcase(s)
-      end
-      """)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadString do
+          @wasm true
+          def upper(s), do: String.upcase(s)
+        end
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "String"))
     end
 
     test "detects File operations" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadFile do
-        @wasm true
-        def read, do: File.read!("test.txt")
-      end
-      """)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadFile do
+          @wasm true
+          def read, do: File.read!("test.txt")
+        end
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "File operations"))
     end
 
     test "detects try/rescue" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadTry do
-        @wasm true
-        def safe_div(a, b) do
-          try do
-            div(a, b)
-          rescue
-            _ -> 0
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadTry do
+          @wasm true
+          def safe_div(a, b) do
+            try do
+              div(a, b)
+            rescue
+              _ -> 0
+            end
           end
         end
-      end
-      """)
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "Try/rescue"))
     end
 
     test "detects raise" do
-      report = Diagnostics.analyze_code("""
-      defmodule BadRaise do
-        @wasm true
-        def check(n) do
-          if n < 0, do: raise "negative"
-          n
+      report =
+        Diagnostics.analyze_code("""
+        defmodule BadRaise do
+          @wasm true
+          def check(n) do
+            if n < 0, do: raise "negative"
+            n
+          end
         end
-      end
-      """)
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert Enum.any?(warnings, &String.contains?(&1.message, "Exceptions"))
@@ -164,18 +177,19 @@ defmodule Firebird.Target.DiagnosticsTest do
     end
 
     test "counts @wasm annotated functions" do
-      report = Diagnostics.analyze_code("""
-      defmodule Multi do
-        @wasm true
-        def add(a, b), do: a + b
+      report =
+        Diagnostics.analyze_code("""
+        defmodule Multi do
+          @wasm true
+          def add(a, b), do: a + b
 
-        @wasm true
-        def sub(a, b), do: a - b
+          @wasm true
+          def sub(a, b), do: a - b
 
-        @wasm true
-        def mul(a, b), do: a * b
-      end
-      """)
+          @wasm true
+          def mul(a, b), do: a * b
+        end
+        """)
 
       assert report.function_count == 3
       info = Enum.filter(report.diagnostics, &(&1.severity == :info))
@@ -183,11 +197,12 @@ defmodule Firebird.Target.DiagnosticsTest do
     end
 
     test "reports when no @wasm annotations present" do
-      report = Diagnostics.analyze_code("""
-      defmodule NoAnnot do
-        def add(a, b), do: a + b
-      end
-      """)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule NoAnnot do
+          def add(a, b), do: a + b
+        end
+        """)
 
       assert report.function_count == 0
       info = Enum.filter(report.diagnostics, &(&1.severity == :info))
@@ -195,15 +210,16 @@ defmodule Firebird.Target.DiagnosticsTest do
     end
 
     test "estimates WASM size" do
-      report = Diagnostics.analyze_code("""
-      defmodule SizeEst do
-        @wasm true
-        def add(a, b), do: a + b
-
-        @wasm true
-        def sub(a, b), do: a - b
-      end
-      """)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule SizeEst do
+          @wasm true
+          def add(a, b), do: a + b
+
+          @wasm true
+          def sub(a, b), do: a - b
+        end
+        """)
 
       assert report.estimated_wasm_size != nil
       assert report.estimated_wasm_size > 0
@@ -215,12 +231,13 @@ defmodule Firebird.Target.DiagnosticsTest do
     end
 
     test "extracts module name" do
-      report = Diagnostics.analyze_code("""
-      defmodule MyApp.Math.Utils do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      report =
+        Diagnostics.analyze_code("""
+        defmodule MyApp.Math.Utils do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
       assert report.module == :"MyApp.Math.Utils"
     end
@@ -232,14 +249,15 @@ defmodule Firebird.Target.DiagnosticsTest do
     end
 
     test "includes line numbers for warnings" do
-      report = Diagnostics.analyze_code("""
-      defmodule WithIO do
-        @wasm true
-        def greet do
-          IO.puts("hi")
+      report =
+        Diagnostics.analyze_code("""
+        defmodule WithIO do
+          @wasm true
+          def greet do
+            IO.puts("hi")
+          end
         end
-      end
-      """)
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       io_warning = Enum.find(warnings, &String.contains?(&1.message, "IO"))
@@ -249,16 +267,17 @@ defmodule Firebird.Target.DiagnosticsTest do
     end
 
     test "detects multiple unsupported features" do
-      report = Diagnostics.analyze_code("""
-      defmodule MultiIssue do
-        @wasm true
-        def bad do
-          IO.puts("hi")
-          Enum.map([1, 2, 3], &(&1 * 2))
-          String.upcase("hello")
+      report =
+        Diagnostics.analyze_code("""
+        defmodule MultiIssue do
+          @wasm true
+          def bad do
+            IO.puts("hi")
+            Enum.map([1, 2, 3], &(&1 * 2))
+            String.upcase("hello")
+          end
         end
-      end
-      """)
+        """)
 
       warnings = Enum.filter(report.diagnostics, &(&1.severity == :warning))
       assert length(warnings) >= 3
@@ -267,17 +286,18 @@ defmodule Firebird.Target.DiagnosticsTest do
 
   describe "analyze_file/1" do
     test "analyzes a valid file", %{tmp_dir: dir} do
-      path = write_file(dir, "math.ex", """
-      defmodule FileMath do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      path =
+        write_file(dir, "math.ex", """
+        defmodule FileMath do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
       assert {:ok, report} = Diagnostics.analyze_file(path)
       assert report.file == path
       assert report.compilable == true
-      assert report.module == :"FileMath"
+      assert report.module == :FileMath
     end
 
     test "returns error for nonexistent file" do
@@ -287,19 +307,21 @@ defmodule Firebird.Target.DiagnosticsTest do
 
   describe "analyze_files/1" do
     test "analyzes multiple files", %{tmp_dir: dir} do
-      path1 = write_file(dir, "a.ex", """
-      defmodule A do
-        @wasm true
-        def one, do: 1
-      end
-      """)
-
-      path2 = write_file(dir, "b.ex", """
-      defmodule B do
-        @wasm true
-        def two, do: 2
-      end
-      """)
+      path1 =
+        write_file(dir, "a.ex", """
+        defmodule A do
+          @wasm true
+          def one, do: 1
+        end
+        """)
+
+      path2 =
+        write_file(dir, "b.ex", """
+        defmodule B do
+          @wasm true
+          def two, do: 2
+        end
+        """)
 
       assert {:ok, reports} = Diagnostics.analyze_files([path1, path2])
       assert length(reports) == 2
@@ -310,12 +332,13 @@ defmodule Firebird.Target.DiagnosticsTest do
     end
 
     test "skips unreadable files", %{tmp_dir: dir} do
-      path = write_file(dir, "good.ex", """
-      defmodule Good do
-        @wasm true
-        def id(n), do: n
-      end
-      """)
+      path =
+        write_file(dir, "good.ex", """
+        defmodule Good do
+          @wasm true
+          def id(n), do: n
+        end
+        """)
 
       assert {:ok, reports} = Diagnostics.analyze_files([path, "/nonexistent/bad.ex"])
       assert length(reports) == 1
@@ -324,12 +347,13 @@ defmodule Firebird.Target.DiagnosticsTest do
 
   describe "compilable?/1" do
     test "returns true for compilable file", %{tmp_dir: dir} do
-      path = write_file(dir, "good.ex", """
-      defmodule Compilable do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      path =
+        write_file(dir, "good.ex", """
+        defmodule Compilable do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
       assert Diagnostics.compilable?(path) == true
     end
@@ -343,7 +367,7 @@ defmodule Firebird.Target.DiagnosticsTest do
     test "formats a clean report" do
       report = %{
         file: "lib/math.ex",
-        module: :"Math",
+        module: :Math,
         compilable: true,
         diagnostics: [
           %{severity: :info, message: "1 WASM function(s) found", line: nil, source: nil}
@@ -362,7 +386,7 @@ defmodule Firebird.Target.DiagnosticsTest do
     test "formats a report with warnings" do
       report = %{
         file: "lib/bad.ex",
-        module: :"Bad",
+        module: :Bad,
         compilable: true,
         diagnostics: [
           %{severity: :warning, message: "IO operations not available", line: 5, source: nil},
@@ -413,8 +437,22 @@ defmodule Firebird.Target.DiagnosticsTest do
   describe "format_reports/1" do
     test "formats multiple reports" do
       reports = [
-        %{file: "a.ex", module: :A, compilable: true, diagnostics: [], function_count: 1, estimated_wasm_size: 100},
-        %{file: "b.ex", module: :B, compilable: true, diagnostics: [], function_count: 2, estimated_wasm_size: 200}
+        %{
+          file: "a.ex",
+          module: :A,
+          compilable: true,
+          diagnostics: [],
+          function_count: 1,
+          estimated_wasm_size: 100
+        },
+        %{
+          file: "b.ex",
+          module: :B,
+          compilable: true,
+          diagnostics: [],
+          function_count: 2,
+          estimated_wasm_size: 200
+        }
       ]
 
       output = Diagnostics.format_reports(reports)
diff --git a/test/target/e2e_compilation_test.exs b/test/target/e2e_compilation_test.exs
index 0bd5191..9988c12 100644
--- a/test/target/e2e_compilation_test.exs
+++ b/test/target/e2e_compilation_test.exs
@@ -9,7 +9,10 @@ defmodule Firebird.Target.E2ECompilationTest do
 
   alias Firebird.Target
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_e2e_test_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_e2e_test_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -19,12 +22,13 @@ defmodule Firebird.Target.E2ECompilationTest do
 
   describe "arithmetic operations" do
     test "add produces correct results for various inputs" do
-      {:ok, result} = compile_source("""
-      defmodule E2EAdd do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      {:ok, result} =
+        compile_source("""
+        defmodule E2EAdd do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
 
@@ -46,12 +50,13 @@ defmodule Firebird.Target.E2ECompilationTest do
     end
 
     test "multiply produces correct results" do
-      {:ok, result} = compile_source("""
-      defmodule E2EMul do
-        @wasm true
-        def multiply(a, b), do: a * b
-      end
-      """)
+      {:ok, result} =
+        compile_source("""
+        defmodule E2EMul do
+          @wasm true
+          def multiply(a, b), do: a * b
+        end
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
 
@@ -64,15 +69,16 @@ defmodule Firebird.Target.E2ECompilationTest do
     end
 
     test "division and remainder" do
-      {:ok, result} = compile_source("""
-      defmodule E2EDiv do
-        @wasm true
-        def divide(a, b), do: div(a, b)
-
-        @wasm true
-        def modulo(a, b), do: rem(a, b)
-      end
-      """)
+      {:ok, result} =
+        compile_source("""
+        defmodule E2EDiv do
+          @wasm true
+          def divide(a, b), do: div(a, b)
+
+          @wasm true
+          def modulo(a, b), do: rem(a, b)
+        end
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
 
@@ -85,12 +91,13 @@ defmodule Firebird.Target.E2ECompilationTest do
     end
 
     test "subtraction" do
-      {:ok, result} = compile_source("""
-      defmodule E2ESub do
-        @wasm true
-        def subtract(a, b), do: a - b
-      end
-      """)
+      {:ok, result} =
+        compile_source("""
+        defmodule E2ESub do
+          @wasm true
+          def subtract(a, b), do: a - b
+        end
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
 
@@ -104,37 +111,38 @@ defmodule Firebird.Target.E2ECompilationTest do
 
   describe "control flow" do
     test "if/else branching" do
-      {:ok, result} = compile_source("""
-      defmodule E2EBranch do
-        @wasm true
-        def abs_val(n) do
-          if n >= 0, do: n, else: 0 - n
-        end
+      {:ok, result} =
+        compile_source("""
+        defmodule E2EBranch do
+          @wasm true
+          def abs_val(n) do
+            if n >= 0, do: n, else: 0 - n
+          end
 
-        @wasm true
-        def max_val(a, b) do
-          if a >= b, do: a, else: b
-        end
+          @wasm true
+          def max_val(a, b) do
+            if a >= b, do: a, else: b
+          end
 
-        @wasm true
-        def min_val(a, b) do
-          if a <= b, do: a, else: b
-        end
+          @wasm true
+          def min_val(a, b) do
+            if a <= b, do: a, else: b
+          end
 
-        @wasm true
-        def sign(n) do
-          if n > 0 do
-            1
-          else
-            if n < 0 do
-              0 - 1
+          @wasm true
+          def sign(n) do
+            if n > 0 do
+              1
             else
-              0
+              if n < 0 do
+                0 - 1
+              else
+                0
+              end
             end
           end
         end
-      end
-      """)
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
 
@@ -161,22 +169,23 @@ defmodule Firebird.Target.E2ECompilationTest do
     end
 
     test "clamp function with nested if" do
-      {:ok, result} = compile_source("""
-      defmodule E2EClamp do
-        @wasm true
-        def clamp(val, lo, hi) do
-          if val < lo do
-            lo
-          else
-            if val > hi do
-              hi
+      {:ok, result} =
+        compile_source("""
+        defmodule E2EClamp do
+          @wasm true
+          def clamp(val, lo, hi) do
+            if val < lo do
+              lo
             else
-              val
+              if val > hi do
+                hi
+              else
+                val
+              end
             end
           end
         end
-      end
-      """)
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
 
@@ -192,14 +201,15 @@ defmodule Firebird.Target.E2ECompilationTest do
 
   describe "pattern matching and recursion" do
     test "fibonacci sequence" do
-      {:ok, result} = compile_source("""
-      defmodule E2EFib do
-        @wasm true
-        def fibonacci(0), do: 0
-        def fibonacci(1), do: 1
-        def fibonacci(n), do: fibonacci(n - 1) + fibonacci(n - 2)
-      end
-      """)
+      {:ok, result} =
+        compile_source("""
+        defmodule E2EFib do
+          @wasm true
+          def fibonacci(0), do: 0
+          def fibonacci(1), do: 1
+          def fibonacci(n), do: fibonacci(n - 1) + fibonacci(n - 2)
+        end
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
 
@@ -214,18 +224,27 @@ defmodule Firebird.Target.E2ECompilationTest do
     end
 
     test "factorial" do
-      {:ok, result} = compile_source("""
-      defmodule E2EFact do
-        @wasm true
-        def factorial(0), do: 1
-        def factorial(n), do: n * factorial(n - 1)
-      end
-      """)
+      {:ok, result} =
+        compile_source("""
+        defmodule E2EFact do
+          @wasm true
+          def factorial(0), do: 1
+          def factorial(n), do: n * factorial(n - 1)
+        end
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
 
-      expected = %{0 => 1, 1 => 1, 2 => 2, 3 => 6, 4 => 24, 5 => 120,
-                   10 => 3_628_800, 12 => 479_001_600}
+      expected = %{
+        0 => 1,
+        1 => 1,
+        2 => 2,
+        3 => 6,
+        4 => 24,
+        5 => 120,
+        10 => 3_628_800,
+        12 => 479_001_600
+      }
 
       for {n, expected_val} <- expected do
         assert {:ok, [^expected_val]} = Firebird.call(inst, "factorial", [n]),
@@ -236,13 +255,14 @@ defmodule Firebird.Target.E2ECompilationTest do
     end
 
     test "GCD (Euclidean algorithm)" do
-      {:ok, result} = compile_source("""
-      defmodule E2EGCD do
-        @wasm true
-        def gcd(a, 0), do: a
-        def gcd(a, b), do: gcd(b, rem(a, b))
-      end
-      """)
+      {:ok, result} =
+        compile_source("""
+        defmodule E2EGCD do
+          @wasm true
+          def gcd(a, 0), do: a
+          def gcd(a, b), do: gcd(b, rem(a, b))
+        end
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
 
@@ -264,13 +284,14 @@ defmodule Firebird.Target.E2ECompilationTest do
     end
 
     test "power function" do
-      {:ok, result} = compile_source("""
-      defmodule E2EPow do
-        @wasm true
-        def power(_, 0), do: 1
-        def power(base, exp), do: base * power(base, exp - 1)
-      end
-      """)
+      {:ok, result} =
+        compile_source("""
+        defmodule E2EPow do
+          @wasm true
+          def power(_, 0), do: 1
+          def power(base, exp), do: base * power(base, exp - 1)
+        end
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
 
@@ -284,18 +305,20 @@ defmodule Firebird.Target.E2ECompilationTest do
     end
 
     test "sum_to (recursive summation)" do
-      {:ok, result} = compile_source("""
-      defmodule E2ESum do
-        @wasm true
-        def sum_to(0), do: 0
-        def sum_to(n), do: n + sum_to(n - 1)
-      end
-      """)
+      {:ok, result} =
+        compile_source("""
+        defmodule E2ESum do
+          @wasm true
+          def sum_to(0), do: 0
+          def sum_to(n), do: n + sum_to(n - 1)
+        end
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
 
       for n <- [0, 1, 5, 10, 50, 100] do
         expected = div(n * (n + 1), 2)
+
         assert {:ok, [^expected]} = Firebird.call(inst, "sum_to", [n]),
                "sum_to(#{n}) should be #{expected}"
       end
@@ -304,19 +327,20 @@ defmodule Firebird.Target.E2ECompilationTest do
     end
 
     test "collatz steps" do
-      {:ok, result} = compile_source("""
-      defmodule E2ECollatz do
-        @wasm true
-        def collatz_steps(1), do: 0
-        def collatz_steps(n) do
-          if rem(n, 2) == 0 do
-            1 + collatz_steps(div(n, 2))
-          else
-            1 + collatz_steps(3 * n + 1)
+      {:ok, result} =
+        compile_source("""
+        defmodule E2ECollatz do
+          @wasm true
+          def collatz_steps(1), do: 0
+          def collatz_steps(n) do
+            if rem(n, 2) == 0 do
+              1 + collatz_steps(div(n, 2))
+            else
+              1 + collatz_steps(3 * n + 1)
+            end
           end
         end
-      end
-      """)
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
 
@@ -331,30 +355,31 @@ defmodule Firebird.Target.E2ECompilationTest do
 
   describe "multi-function modules" do
     test "module with many exported functions" do
-      {:ok, result} = compile_source("""
-      defmodule E2EMulti do
-        @wasm true
-        def add(a, b), do: a + b
+      {:ok, result} =
+        compile_source("""
+        defmodule E2EMulti do
+          @wasm true
+          def add(a, b), do: a + b
 
-        @wasm true
-        def sub(a, b), do: a - b
+          @wasm true
+          def sub(a, b), do: a - b
 
-        @wasm true
-        def mul(a, b), do: a * b
+          @wasm true
+          def mul(a, b), do: a * b
 
-        @wasm true
-        def square(n), do: n * n
+          @wasm true
+          def square(n), do: n * n
 
-        @wasm true
-        def cube(n), do: n * n * n
+          @wasm true
+          def cube(n), do: n * n * n
 
-        @wasm true
-        def double(n), do: n * 2
+          @wasm true
+          def double(n), do: n * 2
 
-        @wasm true
-        def triple(n), do: n * 3
-      end
-      """)
+          @wasm true
+          def triple(n), do: n * 3
+        end
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
 
@@ -370,15 +395,16 @@ defmodule Firebird.Target.E2ECompilationTest do
     end
 
     test "module with helper functions calling each other" do
-      {:ok, result} = compile_source("""
-      defmodule E2EHelpers do
-        @wasm true
-        def double(n), do: n + n
-
-        @wasm true
-        def quadruple(n), do: double(double(n))
-      end
-      """)
+      {:ok, result} =
+        compile_source("""
+        defmodule E2EHelpers do
+          @wasm true
+          def double(n), do: n + n
+
+          @wasm true
+          def quadruple(n), do: double(double(n))
+        end
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
 
@@ -391,17 +417,21 @@ defmodule Firebird.Target.E2ECompilationTest do
 
   describe "compilation with optimizations" do
     test "optimize flag produces working WASM" do
-      {:ok, result} = Target.compile_source("""
-      defmodule E2EOptimized do
-        @wasm true
-        def add(a, b), do: a + b
-
-        @wasm true
-        def fibonacci(0), do: 0
-        def fibonacci(1), do: 1
-        def fibonacci(n), do: fibonacci(n - 1) + fibonacci(n - 2)
-      end
-      """, optimize: true)
+      {:ok, result} =
+        Target.compile_source(
+          """
+          defmodule E2EOptimized do
+            @wasm true
+            def add(a, b), do: a + b
+
+            @wasm true
+            def fibonacci(0), do: 0
+            def fibonacci(1), do: 1
+            def fibonacci(n), do: fibonacci(n - 1) + fibonacci(n - 2)
+          end
+          """,
+          optimize: true
+        )
 
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [30]} = Firebird.call(inst, "add", [10, 20])
@@ -410,12 +440,16 @@ defmodule Firebird.Target.E2ECompilationTest do
     end
 
     test "tco flag produces working WASM" do
-      {:ok, result} = Target.compile_source("""
-      defmodule E2ETCO do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """, tco: true)
+      {:ok, result} =
+        Target.compile_source(
+          """
+          defmodule E2ETCO do
+            @wasm true
+            def add(a, b), do: a + b
+          end
+          """,
+          tco: true
+        )
 
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [7]} = Firebird.call(inst, "add", [3, 4])
@@ -423,12 +457,16 @@ defmodule Firebird.Target.E2ECompilationTest do
     end
 
     test "inline flag produces working WASM" do
-      {:ok, result} = Target.compile_source("""
-      defmodule E2EInline do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """, inline: true)
+      {:ok, result} =
+        Target.compile_source(
+          """
+          defmodule E2EInline do
+            @wasm true
+            def add(a, b), do: a + b
+          end
+          """,
+          inline: true
+        )
 
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [9]} = Firebird.call(inst, "add", [4, 5])
@@ -438,12 +476,13 @@ defmodule Firebird.Target.E2ECompilationTest do
 
   describe "WAT output correctness" do
     test "generated WAT contains module structure" do
-      {:ok, result} = compile_source("""
-      defmodule E2EWat do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      {:ok, result} =
+        compile_source("""
+        defmodule E2EWat do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
       assert String.contains?(result.wat, "(module")
       assert String.contains?(result.wat, "(func")
@@ -454,15 +493,16 @@ defmodule Firebird.Target.E2ECompilationTest do
     end
 
     test "multi-function WAT has all exports" do
-      {:ok, result} = compile_source("""
-      defmodule E2EWatMulti do
-        @wasm true
-        def foo(a), do: a
-
-        @wasm true
-        def bar(a, b), do: a + b
-      end
-      """)
+      {:ok, result} =
+        compile_source("""
+        defmodule E2EWatMulti do
+          @wasm true
+          def foo(a), do: a
+
+          @wasm true
+          def bar(a, b), do: a + b
+        end
+        """)
 
       assert String.contains?(result.wat, "(export \"foo\")")
       assert String.contains?(result.wat, "(export \"bar\")")
diff --git a/test/target/full_pipeline_bench_test.exs b/test/target/full_pipeline_bench_test.exs
index b8214cc..c940860 100644
--- a/test/target/full_pipeline_bench_test.exs
+++ b/test/target/full_pipeline_bench_test.exs
@@ -241,8 +241,9 @@ defmodule Firebird.Target.FullPipelineBenchTest do
 
       Enum.each(test_cases, fn {func, args, expected} ->
         actual = call(inst, func, args)
+
         assert actual == expected,
-          "#{func}(#{Enum.join(args, ", ")}) expected #{expected}, got #{actual}"
+               "#{func}(#{Enum.join(args, ", ")}) expected #{expected}, got #{actual}"
       end)
     end
   end
diff --git a/test/target/guard_test.exs b/test/target/guard_test.exs
index a91a718..b1a9580 100644
--- a/test/target/guard_test.exs
+++ b/test/target/guard_test.exs
@@ -6,53 +6,53 @@ defmodule Firebird.Target.GuardTest do
   describe "compilable_source?/1" do
     test "accepts basic arithmetic module" do
       assert Guard.compilable_source?("""
-      defmodule Math do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+             defmodule Math do
+               @wasm true
+               def add(a, b), do: a + b
+             end
+             """)
     end
 
     test "accepts pattern matching" do
       assert Guard.compilable_source?("""
-      defmodule Fib do
-        @wasm true
-        def fib(0), do: 0
-        def fib(1), do: 1
-        def fib(n), do: fib(n - 1) + fib(n - 2)
-      end
-      """)
+             defmodule Fib do
+               @wasm true
+               def fib(0), do: 0
+               def fib(1), do: 1
+               def fib(n), do: fib(n - 1) + fib(n - 2)
+             end
+             """)
     end
 
     test "accepts if/else" do
       assert Guard.compilable_source?("""
-      defmodule Cond do
-        @wasm true
-        def abs(n), do: if(n >= 0, do: n, else: 0 - n)
-      end
-      """)
+             defmodule Cond do
+               @wasm true
+               def abs(n), do: if(n >= 0, do: n, else: 0 - n)
+             end
+             """)
     end
 
     test "rejects spawn" do
       refute Guard.compilable_source?("""
-      defmodule Bad do
-        def run, do: spawn(fn -> :ok end)
-      end
-      """)
+             defmodule Bad do
+               def run, do: spawn(fn -> :ok end)
+             end
+             """)
     end
 
     test "rejects try/rescue" do
       refute Guard.compilable_source?("""
-      defmodule Bad do
-        def run do
-          try do
-            1 / 0
-          rescue
-            _ -> 0
-          end
-        end
-      end
-      """)
+             defmodule Bad do
+               def run do
+                 try do
+                   1 / 0
+                 rescue
+                   _ -> 0
+                 end
+               end
+             end
+             """)
     end
 
     test "rejects invalid syntax" do
@@ -61,44 +61,47 @@ defmodule Firebird.Target.GuardTest do
 
     test "rejects remote calls" do
       refute Guard.compilable_source?("""
-      defmodule Bad do
-        def run(n), do: Enum.map([1, 2], &(&1))
-      end
-      """)
+             defmodule Bad do
+               def run(n), do: Enum.map([1, 2], &(&1))
+             end
+             """)
     end
   end
 
   describe "check_issues/1" do
     test "returns empty list for compilable code" do
-      issues = Guard.check_issues("""
-      defmodule Math do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      issues =
+        Guard.check_issues("""
+        defmodule Math do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
       assert issues == []
     end
 
     test "lists spawn as an issue" do
-      issues = Guard.check_issues("""
-      defmodule Bad do
-        def run, do: spawn(fn -> :ok end)
-      end
-      """)
+      issues =
+        Guard.check_issues("""
+        defmodule Bad do
+          def run, do: spawn(fn -> :ok end)
+        end
+        """)
 
       assert Enum.any?(issues, &String.contains?(&1, "spawn"))
     end
 
     test "lists multiple issues" do
-      issues = Guard.check_issues("""
-      defmodule Bad do
-        def run do
-          spawn(fn -> :ok end)
-          raise "error"
+      issues =
+        Guard.check_issues("""
+        defmodule Bad do
+          def run do
+            spawn(fn -> :ok end)
+            raise "error"
+          end
         end
-      end
-      """)
+        """)
 
       assert length(issues) >= 2
     end
@@ -110,63 +113,69 @@ defmodule Firebird.Target.GuardTest do
     end
 
     test "detects remote module calls" do
-      issues = Guard.check_issues("""
-      defmodule Bad do
-        def run, do: Enum.map([1], &(&1))
-      end
-      """)
+      issues =
+        Guard.check_issues("""
+        defmodule Bad do
+          def run, do: Enum.map([1], &(&1))
+        end
+        """)
 
       assert Enum.any?(issues, &String.contains?(&1, "Remote calls"))
     end
 
     test "detects map usage" do
-      issues = Guard.check_issues("""
-      defmodule Bad do
-        def run, do: %{a: 1}
-      end
-      """)
+      issues =
+        Guard.check_issues("""
+        defmodule Bad do
+          def run, do: %{a: 1}
+        end
+        """)
 
       assert Enum.any?(issues, &String.contains?(&1, "Maps"))
     end
 
     test "detects with expression" do
-      issues = Guard.check_issues("""
-      defmodule Bad do
-        def run(n) do
-          with {:ok, x} <- {:ok, n}, do: x
+      issues =
+        Guard.check_issues("""
+        defmodule Bad do
+          def run(n) do
+            with {:ok, x} <- {:ok, n}, do: x
+          end
         end
-      end
-      """)
+        """)
 
       assert Enum.any?(issues, &String.contains?(&1, "With"))
     end
 
     test "detects for comprehension" do
-      issues = Guard.check_issues("""
-      defmodule Bad do
-        def run, do: for x <- [1, 2, 3], do: x
-      end
-      """)
+      issues =
+        Guard.check_issues("""
+        defmodule Bad do
+          def run, do: for x <- [1, 2, 3], do: x
+        end
+        """)
 
       assert Enum.any?(issues, &String.contains?(&1, "Comprehensions"))
     end
 
     test "detects use macro" do
-      issues = Guard.check_issues("""
-      defmodule Bad do
-        use GenServer
-      end
-      """)
+      issues =
+        Guard.check_issues("""
+        defmodule Bad do
+          use GenServer
+        end
+        """)
 
       assert Enum.any?(issues, &String.contains?(&1, "Use macros"))
     end
 
     test "detects import" do
-      issues = Guard.check_issues("""
-      defmodule Bad do
-        import Enum
-      end
-      """)
+      issues =
+        Guard.check_issues("""
+        defmodule Bad do
+          import Enum
+        end
+        """)
 
       assert Enum.any?(issues, &String.contains?(&1, "Imports"))
     end
diff --git a/test/target/loader_test.exs b/test/target/loader_test.exs
index 4e6ba54..2c05e2b 100644
--- a/test/target/loader_test.exs
+++ b/test/target/loader_test.exs
@@ -66,12 +66,14 @@ defmodule Firebird.Target.LoaderTest do
   describe "load_all/1" do
     test "loads all WASM modules in directory", %{dir: dir} do
       # Add another module
-      {:ok, result2} = Firebird.Compiler.compile_source("""
-      defmodule LoaderTestUtils do
-        @wasm true
-        def double(n), do: n * 2
-      end
-      """)
+      {:ok, result2} =
+        Firebird.Compiler.compile_source("""
+        defmodule LoaderTestUtils do
+          @wasm true
+          def double(n), do: n * 2
+        end
+        """)
+
       File.write!(Path.join(dir, "LoaderTestUtils.wasm"), result2.wasm)
 
       assert {:ok, instances} = Loader.load_all(dir: dir)
diff --git a/test/target/manifest_comprehensive_test.exs b/test/target/manifest_comprehensive_test.exs
index 4e43d47..62cd8a9 100644
--- a/test/target/manifest_comprehensive_test.exs
+++ b/test/target/manifest_comprehensive_test.exs
@@ -84,10 +84,12 @@ defmodule Firebird.Target.ManifestComprehensiveTest do
 
   describe "module_names/1" do
     test "returns module name strings" do
-      manifest = %{"modules" => [
-        %{"module" => "Math"},
-        %{"module" => "Utils"}
-      ]}
+      manifest = %{
+        "modules" => [
+          %{"module" => "Math"},
+          %{"module" => "Utils"}
+        ]
+      }
 
       names = Manifest.module_names(manifest)
       assert "Math" in names
@@ -97,10 +99,12 @@ defmodule Firebird.Target.ManifestComprehensiveTest do
 
   describe "find_module/2" do
     test "finds a module by name" do
-      manifest = %{"modules" => [
-        %{"module" => "Math", "wat_size" => 100},
-        %{"module" => "Utils", "wat_size" => 200}
-      ]}
+      manifest = %{
+        "modules" => [
+          %{"module" => "Math", "wat_size" => 100},
+          %{"module" => "Utils", "wat_size" => 200}
+        ]
+      }
 
       found = Manifest.find_module(manifest, "Math")
       assert found != nil
diff --git a/test/target/manifest_extended_test.exs b/test/target/manifest_extended_test.exs
index 51c4663..ea475cf 100644
--- a/test/target/manifest_extended_test.exs
+++ b/test/target/manifest_extended_test.exs
@@ -3,7 +3,10 @@ defmodule Firebird.Target.ManifestExtendedTest do
 
   alias Firebird.Target.Manifest
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_manifest_ext_test_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_manifest_ext_test_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -14,6 +17,7 @@ defmodule Firebird.Target.ManifestExtendedTest do
   describe "read/1 and write/2" do
     test "round-trips manifest", %{tmp_dir: dir} do
       path = Path.join(dir, "manifest.json")
+
       manifest = %{
         "version" => 1,
         "timestamp" => "2026-02-28T11:00:00Z",
@@ -87,10 +91,12 @@ defmodule Firebird.Target.ManifestExtendedTest do
 
   describe "find_module/2" do
     test "finds module by name" do
-      manifest = %{"modules" => [
-        %{"module" => "Math", "wasm_file" => "Math.wasm"},
-        %{"module" => "Utils", "wasm_file" => "Utils.wasm"}
-      ]}
+      manifest = %{
+        "modules" => [
+          %{"module" => "Math", "wasm_file" => "Math.wasm"},
+          %{"module" => "Utils", "wasm_file" => "Utils.wasm"}
+        ]
+      }
 
       assert %{"module" => "Math"} = Manifest.find_module(manifest, "Math")
     end
diff --git a/test/target/manifest_test.exs b/test/target/manifest_test.exs
index 1435175..e8150eb 100644
--- a/test/target/manifest_test.exs
+++ b/test/target/manifest_test.exs
@@ -3,7 +3,10 @@ defmodule Firebird.Target.ManifestTest do
 
   alias Firebird.Target.Manifest
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_manifest_test_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_manifest_test_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -148,12 +151,16 @@ defmodule Firebird.Target.ManifestTest do
   describe "load_module/2" do
     test "loads a compiled WASM module", %{tmp_dir: dir} do
       # Compile a real module first
-      {:ok, result} = Firebird.Target.compile_source("""
-      defmodule ManifestLoadTest do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """, output_dir: dir)
+      {:ok, result} =
+        Firebird.Target.compile_source(
+          """
+          defmodule ManifestLoadTest do
+            @wasm true
+            def add(a, b), do: a + b
+          end
+          """,
+          output_dir: dir
+        )
 
       manifest = %{
         "version" => 1,
@@ -201,19 +208,27 @@ defmodule Firebird.Target.ManifestTest do
   describe "load_all/1" do
     test "loads all modules from manifest", %{tmp_dir: dir} do
       # Compile modules
-      {:ok, _} = Firebird.Target.compile_source("""
-      defmodule ManifestAll1 do
-        @wasm true
-        def one, do: 1
-      end
-      """, output_dir: dir)
-
-      {:ok, _} = Firebird.Target.compile_source("""
-      defmodule ManifestAll2 do
-        @wasm true
-        def two, do: 2
-      end
-      """, output_dir: dir)
+      {:ok, _} =
+        Firebird.Target.compile_source(
+          """
+          defmodule ManifestAll1 do
+            @wasm true
+            def one, do: 1
+          end
+          """,
+          output_dir: dir
+        )
+
+      {:ok, _} =
+        Firebird.Target.compile_source(
+          """
+          defmodule ManifestAll2 do
+            @wasm true
+            def two, do: 2
+          end
+          """,
+          output_dir: dir
+        )
 
       manifest = %{
         "version" => 1,
diff --git a/test/target/mix_compiler_test.exs b/test/target/mix_compiler_test.exs
index 85d215a..de9f953 100644
--- a/test/target/mix_compiler_test.exs
+++ b/test/target/mix_compiler_test.exs
@@ -1,7 +1,10 @@
 defmodule Mix.Compilers.FirebirdWasmTest do
   use ExUnit.Case, async: true
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_mix_compiler_test_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_mix_compiler_test_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -12,6 +15,7 @@ defmodule Mix.Compilers.FirebirdWasmTest do
   describe "find_wasm_sources/1" do
     test "finds files with @wasm annotations", %{tmp_dir: dir} do
       wasm_file = Path.join(dir, "math.ex")
+
       File.write!(wasm_file, """
       defmodule CompMath do
         @wasm true
@@ -20,6 +24,7 @@ defmodule Mix.Compilers.FirebirdWasmTest do
       """)
 
       plain_file = Path.join(dir, "plain.ex")
+
       File.write!(plain_file, """
       defmodule Plain do
         def func, do: :ok
@@ -48,6 +53,7 @@ defmodule Mix.Compilers.FirebirdWasmTest do
       File.mkdir_p!(nested)
 
       file = Path.join(nested, "math.ex")
+
       File.write!(file, """
       defmodule NestedMath do
         @wasm true
diff --git a/test/target/mix_target_comprehensive_test.exs b/test/target/mix_target_comprehensive_test.exs
index 1a5ebcd..b6aeeec 100644
--- a/test/target/mix_target_comprehensive_test.exs
+++ b/test/target/mix_target_comprehensive_test.exs
@@ -49,7 +49,9 @@ defmodule Firebird.Target.MixTargetComprehensiveTest do
       config = MixTarget.config_from_env()
       assert config.wat_only == true
 
-      if old, do: System.put_env("FIREBIRD_WAT_ONLY", old), else: System.delete_env("FIREBIRD_WAT_ONLY")
+      if old,
+        do: System.put_env("FIREBIRD_WAT_ONLY", old),
+        else: System.delete_env("FIREBIRD_WAT_ONLY")
     end
 
     test "respects FIREBIRD_OPTIMIZE env var" do
@@ -59,7 +61,9 @@ defmodule Firebird.Target.MixTargetComprehensiveTest do
       config = MixTarget.config_from_env()
       assert config.optimize == true
 
-      if old, do: System.put_env("FIREBIRD_OPTIMIZE", old), else: System.delete_env("FIREBIRD_OPTIMIZE")
+      if old,
+        do: System.put_env("FIREBIRD_OPTIMIZE", old),
+        else: System.delete_env("FIREBIRD_OPTIMIZE")
     end
 
     test "FIREBIRD_WAT_ONLY=0 is false" do
@@ -69,7 +73,9 @@ defmodule Firebird.Target.MixTargetComprehensiveTest do
       config = MixTarget.config_from_env()
       assert config.wat_only == false
 
-      if old, do: System.put_env("FIREBIRD_WAT_ONLY", old), else: System.delete_env("FIREBIRD_WAT_ONLY")
+      if old,
+        do: System.put_env("FIREBIRD_WAT_ONLY", old),
+        else: System.delete_env("FIREBIRD_WAT_ONLY")
     end
 
     test "FIREBIRD_WAT_ONLY=false is false" do
@@ -79,7 +85,9 @@ defmodule Firebird.Target.MixTargetComprehensiveTest do
       config = MixTarget.config_from_env()
       assert config.wat_only == false
 
-      if old, do: System.put_env("FIREBIRD_WAT_ONLY", old), else: System.delete_env("FIREBIRD_WAT_ONLY")
+      if old,
+        do: System.put_env("FIREBIRD_WAT_ONLY", old),
+        else: System.delete_env("FIREBIRD_WAT_ONLY")
     end
 
     test "respects FIREBIRD_OUTPUT env var" do
@@ -89,7 +97,9 @@ defmodule Firebird.Target.MixTargetComprehensiveTest do
       config = MixTarget.config_from_env()
       assert config.output_dir == "/tmp/custom_wasm_output"
 
-      if old, do: System.put_env("FIREBIRD_OUTPUT", old), else: System.delete_env("FIREBIRD_OUTPUT")
+      if old,
+        do: System.put_env("FIREBIRD_OUTPUT", old),
+        else: System.delete_env("FIREBIRD_OUTPUT")
     end
 
     test "respects FIREBIRD_TCO env var" do
@@ -109,7 +119,9 @@ defmodule Firebird.Target.MixTargetComprehensiveTest do
       config = MixTarget.config_from_env()
       assert config.inline == true
 
-      if old, do: System.put_env("FIREBIRD_INLINE", old), else: System.delete_env("FIREBIRD_INLINE")
+      if old,
+        do: System.put_env("FIREBIRD_INLINE", old),
+        else: System.delete_env("FIREBIRD_INLINE")
     end
 
     test "respects FIREBIRD_VERBOSE env var" do
@@ -119,7 +131,9 @@ defmodule Firebird.Target.MixTargetComprehensiveTest do
       config = MixTarget.config_from_env()
       assert config.verbose == true
 
-      if old, do: System.put_env("FIREBIRD_VERBOSE", old), else: System.delete_env("FIREBIRD_VERBOSE")
+      if old,
+        do: System.put_env("FIREBIRD_VERBOSE", old),
+        else: System.delete_env("FIREBIRD_VERBOSE")
     end
 
     test "respects FIREBIRD_VERIFY env var" do
@@ -129,7 +143,9 @@ defmodule Firebird.Target.MixTargetComprehensiveTest do
       config = MixTarget.config_from_env()
       assert config.verify == true
 
-      if old, do: System.put_env("FIREBIRD_VERIFY", old), else: System.delete_env("FIREBIRD_VERIFY")
+      if old,
+        do: System.put_env("FIREBIRD_VERIFY", old),
+        else: System.delete_env("FIREBIRD_VERIFY")
     end
 
     test "empty env var is false" do
@@ -139,7 +155,9 @@ defmodule Firebird.Target.MixTargetComprehensiveTest do
       config = MixTarget.config_from_env()
       assert config.optimize == false
 
-      if old, do: System.put_env("FIREBIRD_OPTIMIZE", old), else: System.delete_env("FIREBIRD_OPTIMIZE")
+      if old,
+        do: System.put_env("FIREBIRD_OPTIMIZE", old),
+        else: System.delete_env("FIREBIRD_OPTIMIZE")
     end
   end
 end
diff --git a/test/target/mix_target_test.exs b/test/target/mix_target_test.exs
index afaa1df..8e654bd 100644
--- a/test/target/mix_target_test.exs
+++ b/test/target/mix_target_test.exs
@@ -141,7 +141,14 @@ defmodule Firebird.Target.MixTargetTest do
     end
 
     test "truthy env values" do
-      envs = ["FIREBIRD_OPTIMIZE", "FIREBIRD_TCO", "FIREBIRD_INLINE", "FIREBIRD_VERBOSE", "FIREBIRD_VERIFY"]
+      envs = [
+        "FIREBIRD_OPTIMIZE",
+        "FIREBIRD_TCO",
+        "FIREBIRD_INLINE",
+        "FIREBIRD_VERBOSE",
+        "FIREBIRD_VERIFY"
+      ]
+
       originals = Enum.map(envs, &System.get_env/1)
 
       Enum.each(envs, &System.put_env(&1, "1"))
diff --git a/test/target/mix_tasks_test.exs b/test/target/mix_tasks_test.exs
index 32faa89..ca873e2 100644
--- a/test/target/mix_tasks_test.exs
+++ b/test/target/mix_tasks_test.exs
@@ -1,7 +1,10 @@
 defmodule Firebird.Target.MixTasksTest do
   use ExUnit.Case
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_target_mix_test_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_target_mix_test_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -98,15 +101,36 @@ defmodule Firebird.Target.MixTasksTest do
     end
 
     test "runs with --json output" do
-      assert :ok = Mix.Tasks.Firebird.Target.Bench.run(["--iterations", "5", "--filter", "add", "--json"])
+      assert :ok =
+               Mix.Tasks.Firebird.Target.Bench.run([
+                 "--iterations",
+                 "5",
+                 "--filter",
+                 "add",
+                 "--json"
+               ])
     end
 
     test "runs with --markdown output" do
-      assert :ok = Mix.Tasks.Firebird.Target.Bench.run(["--iterations", "5", "--filter", "add", "--markdown"])
+      assert :ok =
+               Mix.Tasks.Firebird.Target.Bench.run([
+                 "--iterations",
+                 "5",
+                 "--filter",
+                 "add",
+                 "--markdown"
+               ])
     end
 
     test "runs with --csv output" do
-      assert :ok = Mix.Tasks.Firebird.Target.Bench.run(["--iterations", "5", "--filter", "add", "--csv"])
+      assert :ok =
+               Mix.Tasks.Firebird.Target.Bench.run([
+                 "--iterations",
+                 "5",
+                 "--filter",
+                 "add",
+                 "--csv"
+               ])
     end
   end
 end
diff --git a/test/target/parallel_compile_task_test.exs b/test/target/parallel_compile_task_test.exs
index 92b178b..0016242 100644
--- a/test/target/parallel_compile_task_test.exs
+++ b/test/target/parallel_compile_task_test.exs
@@ -3,7 +3,10 @@ defmodule Firebird.Target.ParallelCompileTaskTest do
 
   alias Firebird.Target.Config
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_par_compile_task_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_par_compile_task_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -18,11 +21,13 @@ defmodule Firebird.Target.ParallelCompileTaskTest do
 
   defp write_module(dir, name, body) do
     path = Path.join(dir, "#{String.downcase(to_string(name))}.ex")
+
     File.write!(path, """
     defmodule #{name} do
       #{body}
     end
     """)
+
     path
   end
 
@@ -46,6 +51,7 @@ defmodule Firebird.Target.ParallelCompileTaskTest do
 
       # Verify all modules compiled
       modules = Enum.map(results, & &1.module) |> MapSet.new()
+
       for i <- 1..4 do
         assert String.to_atom("ParTask#{i}") in modules
       end
@@ -81,10 +87,11 @@ defmodule Firebird.Target.ParallelCompileTaskTest do
     end
 
     test "parallel with single file works", %{src_dir: src, out_dir: out} do
-      f1 = write_module(src, "ParSingle", """
-        @wasm true
-        def id(x), do: x
-      """)
+      f1 =
+        write_module(src, "ParSingle", """
+          @wasm true
+          def id(x), do: x
+        """)
 
       config = Config.new(output_dir: out)
       {:ok, results} = Firebird.Target.Parallel.compile([f1], config)
diff --git a/test/target/parallel_comprehensive_test.exs b/test/target/parallel_comprehensive_test.exs
index 63288b5..7382bf6 100644
--- a/test/target/parallel_comprehensive_test.exs
+++ b/test/target/parallel_comprehensive_test.exs
@@ -25,65 +25,71 @@ defmodule Firebird.Target.ParallelComprehensiveTest do
 
   describe "compile/3" do
     test "compiles a single file", %{src_dir: src, out_dir: out} do
-      path = write_module(src, "adder", """
-      defmodule ParallelAdder do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      path =
+        write_module(src, "adder", """
+        defmodule ParallelAdder do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
       config = Config.new(output_dir: out)
       assert {:ok, [result]} = Parallel.compile([path], config)
-      assert result.module == :"ParallelAdder"
+      assert result.module == :ParallelAdder
       assert result.wasm != nil
     end
 
     test "compiles multiple files in parallel", %{src_dir: src, out_dir: out} do
-      p1 = write_module(src, "p_add", """
-      defmodule ParallelAdd do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
-
-      p2 = write_module(src, "p_mul", """
-      defmodule ParallelMul do
-        @wasm true
-        def multiply(a, b), do: a * b
-      end
-      """)
-
-      p3 = write_module(src, "p_sub", """
-      defmodule ParallelSub do
-        @wasm true
-        def subtract(a, b), do: a - b
-      end
-      """)
+      p1 =
+        write_module(src, "p_add", """
+        defmodule ParallelAdd do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
+
+      p2 =
+        write_module(src, "p_mul", """
+        defmodule ParallelMul do
+          @wasm true
+          def multiply(a, b), do: a * b
+        end
+        """)
+
+      p3 =
+        write_module(src, "p_sub", """
+        defmodule ParallelSub do
+          @wasm true
+          def subtract(a, b), do: a - b
+        end
+        """)
 
       config = Config.new(output_dir: out)
       assert {:ok, results} = Parallel.compile([p1, p2, p3], config)
       assert length(results) == 3
 
       modules = Enum.map(results, & &1.module) |> Enum.sort()
-      assert :"ParallelAdd" in modules
-      assert :"ParallelMul" in modules
-      assert :"ParallelSub" in modules
+      assert :ParallelAdd in modules
+      assert :ParallelMul in modules
+      assert :ParallelSub in modules
     end
 
     test "respects max_concurrency option", %{src_dir: src, out_dir: out} do
-      p1 = write_module(src, "conc1", """
-      defmodule Conc1 do
-        @wasm true
-        def f(n), do: n + 1
-      end
-      """)
-
-      p2 = write_module(src, "conc2", """
-      defmodule Conc2 do
-        @wasm true
-        def g(n), do: n + 2
-      end
-      """)
+      p1 =
+        write_module(src, "conc1", """
+        defmodule Conc1 do
+          @wasm true
+          def f(n), do: n + 1
+        end
+        """)
+
+      p2 =
+        write_module(src, "conc2", """
+        defmodule Conc2 do
+          @wasm true
+          def g(n), do: n + 2
+        end
+        """)
 
       config = Config.new(output_dir: out)
       assert {:ok, results} = Parallel.compile([p1, p2], config, max_concurrency: 1)
@@ -91,12 +97,13 @@ defmodule Firebird.Target.ParallelComprehensiveTest do
     end
 
     test "compiled results are correct", %{src_dir: src, out_dir: out} do
-      path = write_module(src, "correct", """
-      defmodule ParallelCorrect do
-        @wasm true
-        def square(n), do: n * n
-      end
-      """)
+      path =
+        write_module(src, "correct", """
+        defmodule ParallelCorrect do
+          @wasm true
+          def square(n), do: n * n
+        end
+        """)
 
       config = Config.new(output_dir: out)
       {:ok, [result]} = Parallel.compile([path], config)
@@ -107,19 +114,21 @@ defmodule Firebird.Target.ParallelComprehensiveTest do
     end
 
     test "handles partial failures gracefully", %{src_dir: src, out_dir: out} do
-      good = write_module(src, "good", """
-      defmodule ParallelGood do
-        @wasm true
-        def id(n), do: n
-      end
-      """)
-
-      bad = write_module(src, "bad", """
-      defmodule ParallelBad do
-        @wasm true
-        def bad(n), do: Enum.map([1], &(&1))
-      end
-      """)
+      good =
+        write_module(src, "good", """
+        defmodule ParallelGood do
+          @wasm true
+          def id(n), do: n
+        end
+        """)
+
+      bad =
+        write_module(src, "bad", """
+        defmodule ParallelBad do
+          @wasm true
+          def bad(n), do: Enum.map([1], &(&1))
+        end
+        """)
 
       config = Config.new(output_dir: out)
       result = Parallel.compile([good, bad], config)
@@ -134,12 +143,13 @@ defmodule Firebird.Target.ParallelComprehensiveTest do
     end
 
     test "with wat_only config", %{src_dir: src, out_dir: out} do
-      path = write_module(src, "watonly", """
-      defmodule ParallelWatOnly do
-        @wasm true
-        def inc(n), do: n + 1
-      end
-      """)
+      path =
+        write_module(src, "watonly", """
+        defmodule ParallelWatOnly do
+          @wasm true
+          def inc(n), do: n + 1
+        end
+        """)
 
       config = Config.new(output_dir: out, wat_only: true)
       assert {:ok, [result]} = Parallel.compile([path], config)
@@ -148,12 +158,13 @@ defmodule Firebird.Target.ParallelComprehensiveTest do
     end
 
     test "with optimize config", %{src_dir: src, out_dir: out} do
-      path = write_module(src, "opt", """
-      defmodule ParallelOpt do
-        @wasm true
-        def double(n), do: n * 2
-      end
-      """)
+      path =
+        write_module(src, "opt", """
+        defmodule ParallelOpt do
+          @wasm true
+          def double(n), do: n * 2
+        end
+        """)
 
       config = Config.new(output_dir: out, optimize: true)
       assert {:ok, [result]} = Parallel.compile([path], config)
@@ -161,12 +172,13 @@ defmodule Firebird.Target.ParallelComprehensiveTest do
     end
 
     test "includes source_file in results", %{src_dir: src, out_dir: out} do
-      path = write_module(src, "srcfile", """
-      defmodule ParallelSrcFile do
-        @wasm true
-        def f(n), do: n
-      end
-      """)
+      path =
+        write_module(src, "srcfile", """
+        defmodule ParallelSrcFile do
+          @wasm true
+          def f(n), do: n
+        end
+        """)
 
       config = Config.new(output_dir: out)
       {:ok, [result]} = Parallel.compile([path], config)
diff --git a/test/target/parallel_test.exs b/test/target/parallel_test.exs
index 61521ce..7f4ee08 100644
--- a/test/target/parallel_test.exs
+++ b/test/target/parallel_test.exs
@@ -4,7 +4,10 @@ defmodule Firebird.Target.ParallelTest do
   alias Firebird.Target.Parallel
   alias Firebird.Target.Config
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_parallel_test_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_parallel_test_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -25,19 +28,21 @@ defmodule Firebird.Target.ParallelTest do
 
   describe "compile/3" do
     test "compiles multiple files in parallel", %{src_dir: src, out_dir: out} do
-      f1 = write_module(src, "math1", """
-      defmodule ParMath1 do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      f1 =
+        write_module(src, "math1", """
+        defmodule ParMath1 do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
-      f2 = write_module(src, "math2", """
-      defmodule ParMath2 do
-        @wasm true
-        def multiply(a, b), do: a * b
-      end
-      """)
+      f2 =
+        write_module(src, "math2", """
+        defmodule ParMath2 do
+          @wasm true
+          def multiply(a, b), do: a * b
+        end
+        """)
 
       config = Config.new(output_dir: out)
       assert {:ok, results} = Parallel.compile([f1, f2], config)
@@ -49,12 +54,13 @@ defmodule Firebird.Target.ParallelTest do
     end
 
     test "compiles single file", %{src_dir: src, out_dir: out} do
-      f1 = write_module(src, "single", """
-      defmodule ParSingle do
-        @wasm true
-        def inc(n), do: n + 1
-      end
-      """)
+      f1 =
+        write_module(src, "single", """
+        defmodule ParSingle do
+          @wasm true
+          def inc(n), do: n + 1
+        end
+        """)
 
       config = Config.new(output_dir: out)
       assert {:ok, results} = Parallel.compile([f1], config)
@@ -68,14 +74,15 @@ defmodule Firebird.Target.ParallelTest do
     end
 
     test "respects max_concurrency option", %{src_dir: src, out_dir: out} do
-      files = for i <- 1..4 do
-        write_module(src, "conc#{i}", """
-        defmodule ParConc#{i} do
-          @wasm true
-          def func(a), do: a + #{i}
+      files =
+        for i <- 1..4 do
+          write_module(src, "conc#{i}", """
+          defmodule ParConc#{i} do
+            @wasm true
+            def func(a), do: a + #{i}
+          end
+          """)
         end
-        """)
-      end
 
       config = Config.new(output_dir: out)
       assert {:ok, results} = Parallel.compile(files, config, max_concurrency: 2)
@@ -83,21 +90,23 @@ defmodule Firebird.Target.ParallelTest do
     end
 
     test "reports partial failures", %{src_dir: src, out_dir: out} do
-      f1 = write_module(src, "good", """
-      defmodule ParGood do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      f1 =
+        write_module(src, "good", """
+        defmodule ParGood do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
-      f2 = write_module(src, "bad", """
-      defmodule ParBad do
-        @wasm true
-        def broken(a) do
-          Enum.map(a, fn x -> x end)
+      f2 =
+        write_module(src, "bad", """
+        defmodule ParBad do
+          @wasm true
+          def broken(a) do
+            Enum.map(a, fn x -> x end)
+          end
         end
-      end
-      """)
+        """)
 
       config = Config.new(output_dir: out)
       result = Parallel.compile([f1, f2], config)
@@ -106,6 +115,7 @@ defmodule Firebird.Target.ParallelTest do
         {:error, {:partial_failure, details}} ->
           assert length(details[:successes]) >= 1
           assert length(details[:failures]) >= 1
+
         {:ok, _results} ->
           # Both succeeded - that's also valid depending on validator behavior
           :ok
@@ -113,12 +123,13 @@ defmodule Firebird.Target.ParallelTest do
     end
 
     test "includes source_file in results", %{src_dir: src, out_dir: out} do
-      f1 = write_module(src, "traced", """
-      defmodule ParTraced do
-        @wasm true
-        def id(x), do: x
-      end
-      """)
+      f1 =
+        write_module(src, "traced", """
+        defmodule ParTraced do
+          @wasm true
+          def id(x), do: x
+        end
+        """)
 
       config = Config.new(output_dir: out)
       assert {:ok, [result]} = Parallel.compile([f1], config)
@@ -126,35 +137,39 @@ defmodule Firebird.Target.ParallelTest do
     end
 
     test "passes compiler options through", %{src_dir: src, out_dir: out} do
-      f1 = write_module(src, "opts", """
-      defmodule ParOpts do
-        @wasm true
-        def double(n), do: n * 2
-      end
-      """)
+      f1 =
+        write_module(src, "opts", """
+        defmodule ParOpts do
+          @wasm true
+          def double(n), do: n * 2
+        end
+        """)
 
       config = Config.new(output_dir: out, optimize: true, wat_only: true)
       assert {:ok, [result]} = Parallel.compile([f1], config)
-      assert result.wasm == nil  # wat_only mode
+      # wat_only mode
+      assert result.wasm == nil
       assert result.wat != nil
     end
   end
 
   describe "compile_ordered/3" do
     test "compiles independent modules in order", %{src_dir: src, out_dir: out} do
-      f1 = write_module(src, "base", """
-      defmodule ParBase do
-        @wasm true
-        def zero(), do: 0
-      end
-      """)
+      f1 =
+        write_module(src, "base", """
+        defmodule ParBase do
+          @wasm true
+          def zero(), do: 0
+        end
+        """)
 
-      f2 = write_module(src, "derived", """
-      defmodule ParDerived do
-        @wasm true
-        def one(), do: 1
-      end
-      """)
+      f2 =
+        write_module(src, "derived", """
+        defmodule ParDerived do
+          @wasm true
+          def one(), do: 1
+        end
+        """)
 
       config = Config.new(output_dir: out)
       assert {:ok, results} = Parallel.compile_ordered([f1, f2], config)
@@ -162,12 +177,13 @@ defmodule Firebird.Target.ParallelTest do
     end
 
     test "handles single file", %{src_dir: src, out_dir: out} do
-      f1 = write_module(src, "solo", """
-      defmodule ParSolo do
-        @wasm true
-        def val(), do: 42
-      end
-      """)
+      f1 =
+        write_module(src, "solo", """
+        defmodule ParSolo do
+          @wasm true
+          def val(), do: 42
+        end
+        """)
 
       config = Config.new(output_dir: out)
       assert {:ok, [result]} = Parallel.compile_ordered([f1], config)
diff --git a/test/target/pipeline_comprehensive_test.exs b/test/target/pipeline_comprehensive_test.exs
index 55919b0..38e6a64 100644
--- a/test/target/pipeline_comprehensive_test.exs
+++ b/test/target/pipeline_comprehensive_test.exs
@@ -54,7 +54,7 @@ defmodule Firebird.Target.PipelineComprehensiveTest do
     test "generates IR from AST" do
       {:ok, ast} = Pipeline.parse(@simple_source)
       assert {:ok, ir} = Pipeline.to_ir(ast)
-      assert ir.name == :"PipelineTestSimple"
+      assert ir.name == :PipelineTestSimple
       assert length(ir.functions) >= 1
     end
   end
@@ -131,7 +131,7 @@ defmodule Firebird.Target.PipelineComprehensiveTest do
 
     test "runs to ir stage" do
       assert {:ok, ir} = Pipeline.run_to(:ir, @simple_source)
-      assert ir.name == :"PipelineTestSimple"
+      assert ir.name == :PipelineTestSimple
     end
 
     test "runs to validate stage" do
@@ -140,7 +140,7 @@ defmodule Firebird.Target.PipelineComprehensiveTest do
 
     test "runs to type_infer stage" do
       assert {:ok, typed_ir} = Pipeline.run_to(:type_infer, @simple_source)
-      assert typed_ir.name == :"PipelineTestSimple"
+      assert typed_ir.name == :PipelineTestSimple
     end
 
     test "runs to wat stage" do
diff --git a/test/target/pipeline_stages_test.exs b/test/target/pipeline_stages_test.exs
index 6f515e1..8565566 100644
--- a/test/target/pipeline_stages_test.exs
+++ b/test/target/pipeline_stages_test.exs
@@ -65,7 +65,7 @@ defmodule Firebird.Target.PipelineStagesTest do
     test "generates IR from AST" do
       {:ok, ast} = Pipeline.parse(@simple_source)
       assert {:ok, ir} = Pipeline.to_ir(ast)
-      assert ir.name == :"PipeStage"
+      assert ir.name == :PipeStage
       assert length(ir.functions) == 2
     end
 
@@ -141,7 +141,7 @@ defmodule Firebird.Target.PipelineStagesTest do
 
     test "runs to :ir stage" do
       assert {:ok, ir} = Pipeline.run_to(:ir, @simple_source)
-      assert ir.name == :"PipeStage"
+      assert ir.name == :PipeStage
     end
 
     test "runs to :validate stage" do
@@ -150,7 +150,7 @@ defmodule Firebird.Target.PipelineStagesTest do
 
     test "runs to :type_infer stage" do
       assert {:ok, typed} = Pipeline.run_to(:type_infer, @simple_source)
-      assert typed.name == :"PipeStage"
+      assert typed.name == :PipeStage
     end
 
     test "runs to :wat stage" do
@@ -192,9 +192,9 @@ defmodule Firebird.Target.PipelineStagesTest do
       {:ok, results} = Pipeline.run_all(@simple_source)
 
       assert is_tuple(results.ast)
-      assert results.ir.name == :"PipeStage"
+      assert results.ir.name == :PipeStage
       assert results.validated == true
-      assert results.typed_ir.name == :"PipeStage"
+      assert results.typed_ir.name == :PipeStage
       assert String.contains?(results.wat, "(module")
       assert is_binary(results.wasm)
     end
diff --git a/test/target/pipeline_test.exs b/test/target/pipeline_test.exs
index 662b2e1..9923edb 100644
--- a/test/target/pipeline_test.exs
+++ b/test/target/pipeline_test.exs
@@ -38,10 +38,18 @@ defmodule Firebird.Target.PipelineTest do
       # Order matters — matches Firebird.Compiler.compile_source/2
       assert Enum.find_index(stages, &(&1 == :parse)) < Enum.find_index(stages, &(&1 == :ir))
       assert Enum.find_index(stages, &(&1 == :ir)) < Enum.find_index(stages, &(&1 == :inline))
-      assert Enum.find_index(stages, &(&1 == :inline)) < Enum.find_index(stages, &(&1 == :optimize))
+
+      assert Enum.find_index(stages, &(&1 == :inline)) <
+               Enum.find_index(stages, &(&1 == :optimize))
+
       assert Enum.find_index(stages, &(&1 == :optimize)) < Enum.find_index(stages, &(&1 == :tco))
-      assert Enum.find_index(stages, &(&1 == :tco)) < Enum.find_index(stages, &(&1 == :post_optimize))
-      assert Enum.find_index(stages, &(&1 == :post_optimize)) < Enum.find_index(stages, &(&1 == :wat))
+
+      assert Enum.find_index(stages, &(&1 == :tco)) <
+               Enum.find_index(stages, &(&1 == :post_optimize))
+
+      assert Enum.find_index(stages, &(&1 == :post_optimize)) <
+               Enum.find_index(stages, &(&1 == :wat))
+
       assert Enum.find_index(stages, &(&1 == :wat)) < Enum.find_index(stages, &(&1 == :wasm))
     end
   end
@@ -61,7 +69,7 @@ defmodule Firebird.Target.PipelineTest do
     test "generates IR from AST" do
       {:ok, ast} = Pipeline.parse(@simple_source)
       assert {:ok, %IR.Module{} = ir} = Pipeline.to_ir(ast)
-      assert ir.name == :"PipelineMath"
+      assert ir.name == :PipelineMath
       assert length(ir.functions) == 2
     end
   end
@@ -81,6 +89,7 @@ defmodule Firebird.Target.PipelineTest do
       {:ok, typed_ir} = Pipeline.type_infer(ir)
 
       assert %IR.Module{} = typed_ir
+
       Enum.each(typed_ir.functions, fn f ->
         assert f.type != nil
         assert is_list(f.type.params)
@@ -181,12 +190,15 @@ defmodule Firebird.Target.PipelineTest do
       end
       """
 
-      assert {:ok, %IR.Module{}} = Pipeline.run_to(:post_optimize, tco_source, optimize: true, tco: true)
+      assert {:ok, %IR.Module{}} =
+               Pipeline.run_to(:post_optimize, tco_source, optimize: true, tco: true)
     end
 
     test "post_optimize is a no-op when tco is disabled" do
       # With optimize: true but tco: false, post_optimize should pass through unchanged
-      assert {:ok, ir_no_post} = Pipeline.run_to(:post_optimize, @simple_source, optimize: true, tco: false)
+      assert {:ok, ir_no_post} =
+               Pipeline.run_to(:post_optimize, @simple_source, optimize: true, tco: false)
+
       assert %IR.Module{} = ir_no_post
     end
 
@@ -277,7 +289,9 @@ defmodule Firebird.Target.PipelineTest do
       end
       """
 
-      assert {:ok, results} = Pipeline.run_all(tco_source, optimize: true, tco: true, inline: true)
+      assert {:ok, results} =
+               Pipeline.run_all(tco_source, optimize: true, tco: true, inline: true)
+
       assert %IR.Module{} = results.post_optimized_ir
       assert is_binary(results.wasm)
 
diff --git a/test/target/profiler_test.exs b/test/target/profiler_test.exs
index 8c111e4..c2c1cf3 100644
--- a/test/target/profiler_test.exs
+++ b/test/target/profiler_test.exs
@@ -20,7 +20,7 @@ defmodule Firebird.Target.ProfilerTest do
       assert {:ok, profile} = Profiler.profile_source(@math_source)
 
       assert profile.result == :ok
-      assert profile.module == :"ProfilerTestMath"
+      assert profile.module == :ProfilerTestMath
       assert profile.error == nil
       assert profile.total_us > 0
       assert is_list(profile.timings)
@@ -97,7 +97,9 @@ defmodule Firebird.Target.ProfilerTest do
 
   describe "profile_file/2" do
     test "profiles a file" do
-      tmp = Path.join(System.tmp_dir!(), "profiler_test_#{:erlang.unique_integer([:positive])}.ex")
+      tmp =
+        Path.join(System.tmp_dir!(), "profiler_test_#{:erlang.unique_integer([:positive])}.ex")
+
       File.write!(tmp, @math_source)
 
       assert {:ok, profile} = Profiler.profile_file(tmp)
diff --git a/test/target/report_test.exs b/test/target/report_test.exs
index 0f288cf..9db0a2b 100644
--- a/test/target/report_test.exs
+++ b/test/target/report_test.exs
@@ -7,7 +7,8 @@ defmodule Firebird.Target.ReportTest do
   @sample_results [
     %{
       module: :TestMath,
-      wat: "(module (func $add (export \"add\") (param i64) (param i64) (result i64) local.get 0 local.get 1 i64.add))",
+      wat:
+        "(module (func $add (export \"add\") (param i64) (param i64) (result i64) local.get 0 local.get 1 i64.add))",
       wasm: <<0, 97, 115, 109, 1, 0, 0, 0>>,
       source_file: "lib/math.ex"
     },
diff --git a/test/target/stats_test.exs b/test/target/stats_test.exs
index faffac6..d8cec26 100644
--- a/test/target/stats_test.exs
+++ b/test/target/stats_test.exs
@@ -145,12 +145,19 @@ defmodule Firebird.Target.StatsTest do
 
     test "percentage change is calculated" do
       old = %{
-        module_count: 1, total_wat_bytes: 100, total_wasm_bytes: 50,
-        elapsed_ms: 10, modules: [%{module: "A", wat_bytes: 100, wasm_bytes: 50}]
+        module_count: 1,
+        total_wat_bytes: 100,
+        total_wasm_bytes: 50,
+        elapsed_ms: 10,
+        modules: [%{module: "A", wat_bytes: 100, wasm_bytes: 50}]
       }
+
       new = %{
-        module_count: 1, total_wat_bytes: 150, total_wasm_bytes: 75,
-        elapsed_ms: 15, modules: [%{module: "A", wat_bytes: 150, wasm_bytes: 75}]
+        module_count: 1,
+        total_wat_bytes: 150,
+        total_wasm_bytes: 75,
+        elapsed_ms: 15,
+        modules: [%{module: "A", wat_bytes: 150, wasm_bytes: 75}]
       }
 
       comp = Stats.compare(old, new)
diff --git a/test/target/target_api_test.exs b/test/target/target_api_test.exs
index 302bded..4e13482 100644
--- a/test/target/target_api_test.exs
+++ b/test/target/target_api_test.exs
@@ -4,7 +4,10 @@ defmodule Firebird.Target.ApiTest do
   alias Firebird.Target
   alias Firebird.Target.Config
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_target_api_v2_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_target_api_v2_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -19,11 +22,13 @@ defmodule Firebird.Target.ApiTest do
 
   defp write_wasm_module(dir, name, body) do
     path = Path.join(dir, "#{String.downcase(to_string(name))}.ex")
+
     File.write!(path, """
     defmodule #{name} do
       #{body}
     end
     """)
+
     path
   end
 
@@ -72,6 +77,7 @@ defmodule Firebird.Target.ApiTest do
 
       # Write a module that will fail validation
       path = Path.join(src, "bad.ex")
+
       File.write!(path, """
       defmodule ApiPfBad do
         @wasm true
@@ -86,17 +92,19 @@ defmodule Firebird.Target.ApiTest do
 
       case result do
         {:error, {:partial_failure, _details}} -> :ok
-        {:ok, _results} -> :ok  # May succeed if validator allows
+        # May succeed if validator allows
+        {:ok, _results} -> :ok
       end
     end
   end
 
   describe "compile_files/2" do
     test "compiles specific files", %{src_dir: src, out_dir: out} do
-      f1 = write_wasm_module(src, "ApiFile1", """
-        @wasm true
-        def add(a, b), do: a + b
-      """)
+      f1 =
+        write_wasm_module(src, "ApiFile1", """
+          @wasm true
+          def add(a, b), do: a + b
+        """)
 
       assert {:ok, results} = Target.compile_files([f1], output_dir: out)
       assert length(results) >= 1
@@ -154,16 +162,17 @@ defmodule Firebird.Target.ApiTest do
 
       # Only the @wasm annotated file
       assert Enum.all?(sources, fn s ->
-        content = File.read!(s)
-        String.contains?(content, "@wasm true") or String.contains?(s, "wasm_modules")
-      end)
+               content = File.read!(s)
+               String.contains?(content, "@wasm true") or String.contains?(s, "wasm_modules")
+             end)
     end
 
     test "handles explicit files config", %{src_dir: src, out_dir: out} do
-      f1 = write_wasm_module(src, "ApiDiscExplicit", """
-        @wasm true
-        def func(a), do: a
-      """)
+      f1 =
+        write_wasm_module(src, "ApiDiscExplicit", """
+          @wasm true
+          def func(a), do: a
+        """)
 
       config = Config.new(files: [f1], sources: [], output_dir: out)
       sources = Target.discover_sources(config)
diff --git a/test/target/target_check_test.exs b/test/target/target_check_test.exs
index e6b5601..71f351f 100644
--- a/test/target/target_check_test.exs
+++ b/test/target/target_check_test.exs
@@ -3,7 +3,10 @@ defmodule Firebird.Target.CheckTaskTest do
 
   alias Mix.Tasks.Firebird.Target.Check, as: CheckTask
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_check_test_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_check_test_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -19,30 +22,33 @@ defmodule Firebird.Target.CheckTaskTest do
 
   describe "checking compilable files" do
     test "passes for clean @wasm module", %{tmp_dir: dir} do
-      path = write_file(dir, "math.ex", """
-      defmodule CheckMath do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      path =
+        write_file(dir, "math.ex", """
+        defmodule CheckMath do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
       assert :ok = CheckTask.run([path])
     end
 
     test "passes for multiple clean files", %{tmp_dir: dir} do
-      path1 = write_file(dir, "a.ex", """
-      defmodule CheckA do
-        @wasm true
-        def one, do: 1
-      end
-      """)
-
-      path2 = write_file(dir, "b.ex", """
-      defmodule CheckB do
-        @wasm true
-        def two, do: 2
-      end
-      """)
+      path1 =
+        write_file(dir, "a.ex", """
+        defmodule CheckA do
+          @wasm true
+          def one, do: 1
+        end
+        """)
+
+      path2 =
+        write_file(dir, "b.ex", """
+        defmodule CheckB do
+          @wasm true
+          def two, do: 2
+        end
+        """)
 
       assert :ok = CheckTask.run([path1, path2])
     end
@@ -63,12 +69,13 @@ defmodule Firebird.Target.CheckTaskTest do
 
   describe "checking with --json" do
     test "outputs JSON format", %{tmp_dir: dir} do
-      path = write_file(dir, "math.ex", """
-      defmodule CheckJsonMath do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      path =
+        write_file(dir, "math.ex", """
+        defmodule CheckJsonMath do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
       assert :ok = CheckTask.run([path, "--json"])
     end
@@ -76,12 +83,13 @@ defmodule Firebird.Target.CheckTaskTest do
 
   describe "checking with --verbose" do
     test "shows detailed output", %{tmp_dir: dir} do
-      path = write_file(dir, "math.ex", """
-      defmodule CheckVerboseMath do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      path =
+        write_file(dir, "math.ex", """
+        defmodule CheckVerboseMath do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
       assert :ok = CheckTask.run([path, "--verbose"])
     end
diff --git a/test/target/target_compile_test.exs b/test/target/target_compile_test.exs
index 0a253e7..b5a56f7 100644
--- a/test/target/target_compile_test.exs
+++ b/test/target/target_compile_test.exs
@@ -6,7 +6,10 @@ defmodule Firebird.Target.CompileTaskTest do
 
   alias Mix.Tasks.Firebird.Target.Compile, as: CompileTask
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_compile_task_test_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_compile_task_test_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -101,13 +104,14 @@ defmodule Firebird.Target.CompileTaskTest do
     end
 
     test "multiple options combined" do
-      config = CompileTask.build_config(
-        output: "/tmp/out",
-        optimize: true,
-        tco: true,
-        verbose: true,
-        force: true
-      )
+      config =
+        CompileTask.build_config(
+          output: "/tmp/out",
+          optimize: true,
+          tco: true,
+          verbose: true,
+          force: true
+        )
 
       assert config.output_dir == "/tmp/out"
       assert config.optimize == true
diff --git a/test/target/target_comprehensive_test.exs b/test/target/target_comprehensive_test.exs
index 1a383d7..2944acd 100644
--- a/test/target/target_comprehensive_test.exs
+++ b/test/target/target_comprehensive_test.exs
@@ -38,7 +38,7 @@ defmodule Firebird.Target.ComprehensiveTest do
 
       config = Config.new(sources: [src], output_dir: out, optimize: true)
       assert {:ok, [result]} = Target.compile(config)
-      assert result.module == :"OptTestMath"
+      assert result.module == :OptTestMath
 
       # Verify the compiled module works
       {:ok, instance} = Firebird.load(result.wasm)
@@ -72,10 +72,15 @@ defmodule Firebird.Target.ComprehensiveTest do
       end
       """)
 
-      config = Config.new(
-        sources: [src], output_dir: out,
-        optimize: true, tco: true, inline: true
-      )
+      config =
+        Config.new(
+          sources: [src],
+          output_dir: out,
+          optimize: true,
+          tco: true,
+          inline: true
+        )
+
       assert {:ok, [result]} = Target.compile(config)
       assert result.wasm != nil
     end
@@ -109,9 +114,9 @@ defmodule Firebird.Target.ComprehensiveTest do
       assert length(results) == 3
 
       modules = Enum.map(results, & &1.module) |> Enum.sort()
-      assert :"MultiAdder" in modules
-      assert :"MultiMultiplier" in modules
-      assert :"MultiNegator" in modules
+      assert :MultiAdder in modules
+      assert :MultiMultiplier in modules
+      assert :MultiNegator in modules
 
       # Verify each module works
       Enum.each(results, fn result ->
@@ -204,7 +209,7 @@ defmodule Firebird.Target.ComprehensiveTest do
       """
 
       assert {:ok, result} = Target.compile_source(source)
-      assert result.module == :"InlineTest1"
+      assert result.module == :InlineTest1
       assert result.wat != nil
       assert result.wasm != nil
     end
diff --git a/test/target/target_edge_cases_test.exs b/test/target/target_edge_cases_test.exs
index 482253e..36f8b54 100644
--- a/test/target/target_edge_cases_test.exs
+++ b/test/target/target_edge_cases_test.exs
@@ -4,7 +4,10 @@ defmodule Firebird.Target.EdgeCasesTest do
   alias Firebird.Target
   alias Firebird.Target.Config
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_edge_test_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_edge_test_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -14,14 +17,15 @@ defmodule Firebird.Target.EdgeCasesTest do
 
   describe "compile with edge cases" do
     test "compiles module with single function" do
-      {:ok, result} = Target.compile_source("""
-      defmodule SingleFunc do
-        @wasm true
-        def id(n), do: n
-      end
-      """)
+      {:ok, result} =
+        Target.compile_source("""
+        defmodule SingleFunc do
+          @wasm true
+          def id(n), do: n
+        end
+        """)
 
-      assert result.module == :"SingleFunc"
+      assert result.module == :SingleFunc
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [42]} = Firebird.call(inst, "id", [42])
       assert {:ok, [0]} = Firebird.call(inst, "id", [0])
@@ -30,26 +34,27 @@ defmodule Firebird.Target.EdgeCasesTest do
     end
 
     test "compiles module with deeply nested if" do
-      {:ok, result} = Target.compile_source("""
-      defmodule DeepIf do
-        @wasm true
-        def classify(n) do
-          if n > 100 do
-            3
-          else
-            if n > 50 do
-              2
+      {:ok, result} =
+        Target.compile_source("""
+        defmodule DeepIf do
+          @wasm true
+          def classify(n) do
+            if n > 100 do
+              3
             else
-              if n > 0 do
-                1
+              if n > 50 do
+                2
               else
-                0
+                if n > 0 do
+                  1
+                else
+                  0
+                end
               end
             end
           end
         end
-      end
-      """)
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [3]} = Firebird.call(inst, "classify", [150])
@@ -61,12 +66,13 @@ defmodule Firebird.Target.EdgeCasesTest do
     end
 
     test "compiles module with 3-arity function" do
-      {:ok, result} = Target.compile_source("""
-      defmodule ThreeArgs do
-        @wasm true
-        def add3(a, b, c), do: a + b + c
-      end
-      """)
+      {:ok, result} =
+        Target.compile_source("""
+        defmodule ThreeArgs do
+          @wasm true
+          def add3(a, b, c), do: a + b + c
+        end
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [6]} = Firebird.call(inst, "add3", [1, 2, 3])
@@ -74,18 +80,19 @@ defmodule Firebird.Target.EdgeCasesTest do
     end
 
     test "compiles module with mutual helper calls" do
-      {:ok, result} = Target.compile_source("""
-      defmodule Helpers do
-        @wasm true
-        def double(n), do: n + n
+      {:ok, result} =
+        Target.compile_source("""
+        defmodule Helpers do
+          @wasm true
+          def double(n), do: n + n
 
-        @wasm true
-        def quadruple(n), do: double(double(n))
+          @wasm true
+          def quadruple(n), do: double(double(n))
 
-        @wasm true
-        def octuple(n), do: double(quadruple(n))
-      end
-      """)
+          @wasm true
+          def octuple(n), do: double(quadruple(n))
+        end
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [10]} = Firebird.call(inst, "double", [5])
@@ -95,15 +102,16 @@ defmodule Firebird.Target.EdgeCasesTest do
     end
 
     test "compiles module with negative literals" do
-      {:ok, result} = Target.compile_source("""
-      defmodule NegLit do
-        @wasm true
-        def negate(n), do: 0 - n
-
-        @wasm true
-        def offset(n), do: n + 100
-      end
-      """)
+      {:ok, result} =
+        Target.compile_source("""
+        defmodule NegLit do
+          @wasm true
+          def negate(n), do: 0 - n
+
+          @wasm true
+          def offset(n), do: n + 100
+        end
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [-5]} = Firebird.call(inst, "negate", [5])
@@ -113,16 +121,17 @@ defmodule Firebird.Target.EdgeCasesTest do
     end
 
     test "compiles module with multiple pattern match clauses" do
-      {:ok, result} = Target.compile_source("""
-      defmodule MultiClause do
-        @wasm true
-        def describe(0), do: 0
-        def describe(1), do: 10
-        def describe(2), do: 20
-        def describe(3), do: 30
-        def describe(_n), do: 99
-      end
-      """)
+      {:ok, result} =
+        Target.compile_source("""
+        defmodule MultiClause do
+          @wasm true
+          def describe(0), do: 0
+          def describe(1), do: 10
+          def describe(2), do: 20
+          def describe(3), do: 30
+          def describe(_n), do: 99
+        end
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [0]} = Firebird.call(inst, "describe", [0])
@@ -135,24 +144,25 @@ defmodule Firebird.Target.EdgeCasesTest do
     end
 
     test "compiles module with comparison operators" do
-      {:ok, result} = Target.compile_source("""
-      defmodule Compare do
-        @wasm true
-        def is_positive(n) do
-          if n > 0, do: 1, else: 0
-        end
+      {:ok, result} =
+        Target.compile_source("""
+        defmodule Compare do
+          @wasm true
+          def is_positive(n) do
+            if n > 0, do: 1, else: 0
+          end
 
-        @wasm true
-        def is_zero(n) do
-          if n == 0, do: 1, else: 0
-        end
+          @wasm true
+          def is_zero(n) do
+            if n == 0, do: 1, else: 0
+          end
 
-        @wasm true
-        def is_nonzero(n) do
-          if n != 0, do: 1, else: 0
+          @wasm true
+          def is_nonzero(n) do
+            if n != 0, do: 1, else: 0
+          end
         end
-      end
-      """)
+        """)
 
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [1]} = Firebird.call(inst, "is_positive", [5])
@@ -171,12 +181,14 @@ defmodule Firebird.Target.EdgeCasesTest do
 
     test "compile_source returns error for module without @wasm" do
       # Modules without @wasm compile all public functions
-      {:ok, result} = Target.compile_source("""
-      defmodule NoAnnotation do
-        def add(a, b), do: a + b
-      end
-      """)
-      assert result.module == :"NoAnnotation"
+      {:ok, result} =
+        Target.compile_source("""
+        defmodule NoAnnotation do
+          def add(a, b), do: a + b
+        end
+        """)
+
+      assert result.module == :NoAnnotation
     end
   end
 
@@ -194,11 +206,12 @@ defmodule Firebird.Target.EdgeCasesTest do
     end
 
     test "config validation with multiple issues" do
-      config = Config.new(
-        sources: ["/nonexistent_source_#{:erlang.unique_integer([:positive])}"],
-        files: ["/nonexistent_file_#{:erlang.unique_integer([:positive])}.ex"],
-        output_dir: "/nonexistent_parent_#{:erlang.unique_integer([:positive])}/wasm"
-      )
+      config =
+        Config.new(
+          sources: ["/nonexistent_source_#{:erlang.unique_integer([:positive])}"],
+          files: ["/nonexistent_file_#{:erlang.unique_integer([:positive])}.ex"],
+          output_dir: "/nonexistent_parent_#{:erlang.unique_integer([:positive])}/wasm"
+        )
 
       {:ok, warnings} = Config.validate(config)
       assert length(warnings) >= 2
@@ -220,7 +233,7 @@ defmodule Firebird.Target.EdgeCasesTest do
 
       config = Config.new(sources: [src], output_dir: out)
       assert {:ok, [result]} = Target.compile(config)
-      assert result.module == :"DiskTest"
+      assert result.module == :DiskTest
 
       {:ok, inst} = Firebird.load(result.wasm)
       assert {:ok, [25]} = Firebird.call(inst, "square", [5])
diff --git a/test/target/target_full_flow_test.exs b/test/target/target_full_flow_test.exs
index ec8b2b3..ae20816 100644
--- a/test/target/target_full_flow_test.exs
+++ b/test/target/target_full_flow_test.exs
@@ -7,7 +7,10 @@ defmodule Firebird.Target.FullFlowTest do
   alias Firebird.Target
   alias Firebird.Target.{Config, Manifest, Diagnostics}
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_full_flow_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_full_flow_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -46,16 +49,18 @@ defmodule Firebird.Target.FullFlowTest do
         "version" => 1,
         "timestamp" => DateTime.utc_now() |> DateTime.to_iso8601(),
         "output_dir" => out,
-        "modules" => Enum.map(results, fn r ->
-          base = Atom.to_string(r.module) |> String.replace(".", "_")
-          %{
-            "module" => to_string(r.module),
-            "wat_file" => "#{base}.wat",
-            "wasm_file" => "#{base}.wasm",
-            "wat_size" => byte_size(r.wat),
-            "wasm_size" => if(r.wasm, do: byte_size(r.wasm), else: 0)
-          }
-        end)
+        "modules" =>
+          Enum.map(results, fn r ->
+            base = Atom.to_string(r.module) |> String.replace(".", "_")
+
+            %{
+              "module" => to_string(r.module),
+              "wat_file" => "#{base}.wat",
+              "wasm_file" => "#{base}.wasm",
+              "wat_size" => byte_size(r.wat),
+              "wasm_size" => if(r.wasm, do: byte_size(r.wasm), else: 0)
+            }
+          end)
       }
 
       manifest_path = Path.join(out, Manifest.filename())
@@ -98,8 +103,8 @@ defmodule Firebird.Target.FullFlowTest do
       assert length(results) == 2
 
       # Verify each module works
-      arith_result = Enum.find(results, &(&1.module == :"FlowArith"))
-      fib_result = Enum.find(results, &(&1.module == :"FlowFib"))
+      arith_result = Enum.find(results, &(&1.module == :FlowArith))
+      fib_result = Enum.find(results, &(&1.module == :FlowFib))
 
       {:ok, arith_inst} = Firebird.load(arith_result.wasm)
       {:ok, fib_inst} = Firebird.load(fib_result.wasm)
@@ -113,8 +118,12 @@ defmodule Firebird.Target.FullFlowTest do
   end
 
   describe "diagnostics → compile flow" do
-    test "diagnostics pass for compilable module, then compile succeeds", %{src_dir: src, out_dir: out} do
+    test "diagnostics pass for compilable module, then compile succeeds", %{
+      src_dir: src,
+      out_dir: out
+    } do
       path = Path.join(src, "clean.ex")
+
       File.write!(path, """
       defmodule FlowClean do
         @wasm true
@@ -130,7 +139,7 @@ defmodule Firebird.Target.FullFlowTest do
       # Compile
       config = Config.new(sources: [src], output_dir: out)
       assert {:ok, [result]} = Target.compile(config)
-      assert result.module == :"FlowClean"
+      assert result.module == :FlowClean
 
       # Verify
       {:ok, inst} = Firebird.load(result.wasm)
@@ -140,6 +149,7 @@ defmodule Firebird.Target.FullFlowTest do
 
     test "diagnostics warn about issues but compilation may still work", %{src_dir: src} do
       path = Path.join(src, "partial.ex")
+
       File.write!(path, """
       defmodule FlowPartial do
         @wasm true
@@ -252,7 +262,9 @@ defmodule Firebird.Target.FullFlowTest do
       end
       """)
 
-      config = Config.new(sources: [src], output_dir: out, optimize: true, tco: true, inline: true)
+      config =
+        Config.new(sources: [src], output_dir: out, optimize: true, tco: true, inline: true)
+
       assert {:ok, [result]} = Target.compile(config)
 
       {:ok, inst} = Firebird.load(result.wasm)
@@ -290,10 +302,11 @@ defmodule Firebird.Target.FullFlowTest do
 
     test "reports error for unsupported constructs" do
       # A module with only list operations won't produce valid WASM IR
-      result = Target.compile_source("""
-      defmodule BadModule do
-      end
-      """)
+      result =
+        Target.compile_source("""
+        defmodule BadModule do
+        end
+        """)
 
       # Empty module should either compile with no functions or error
       case result do
diff --git a/test/target/target_new_test.exs b/test/target/target_new_test.exs
index 58db128..7b9f16d 100644
--- a/test/target/target_new_test.exs
+++ b/test/target/target_new_test.exs
@@ -1,7 +1,10 @@
 defmodule Mix.Tasks.Firebird.Target.NewTest do
   use ExUnit.Case
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_target_new_test_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_target_new_test_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -31,8 +34,10 @@ defmodule Mix.Tasks.Firebird.Target.NewTest do
 
       Mix.Tasks.Firebird.Target.New.run([
         "MyApp.Custom",
-        "--dir", output_dir,
-        "--functions", "foo,bar,baz"
+        "--dir",
+        output_dir,
+        "--functions",
+        "foo,bar,baz"
       ])
 
       path = Path.join(output_dir, "custom.ex")
diff --git a/test/target/target_test.exs b/test/target/target_test.exs
index 205aa39..57eb0ad 100644
--- a/test/target/target_test.exs
+++ b/test/target/target_test.exs
@@ -4,7 +4,10 @@ defmodule Firebird.TargetTest do
   alias Firebird.Target
   alias Firebird.Target.Config
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_target_api_test_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_target_api_test_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -19,6 +22,7 @@ defmodule Firebird.TargetTest do
 
   defp write_math_module(dir) do
     path = Path.join(dir, "math.ex")
+
     File.write!(path, """
     defmodule TargetApiMath do
       @wasm true
@@ -28,11 +32,13 @@ defmodule Firebird.TargetTest do
       def multiply(a, b), do: a * b
     end
     """)
+
     path
   end
 
   defp write_fib_module(dir) do
     path = Path.join(dir, "fib.ex")
+
     File.write!(path, """
     defmodule TargetApiFib do
       @wasm true
@@ -41,6 +47,7 @@ defmodule Firebird.TargetTest do
       def fibonacci(n), do: fibonacci(n - 1) + fibonacci(n - 2)
     end
     """)
+
     path
   end
 
@@ -51,7 +58,7 @@ defmodule Firebird.TargetTest do
       config = Config.new(sources: [src], output_dir: out)
       assert {:ok, results} = Target.compile(config)
       assert length(results) == 1
-      assert hd(results).module == :"TargetApiMath"
+      assert hd(results).module == :TargetApiMath
       assert hd(results).wat != nil
       assert hd(results).wasm != nil
     end
@@ -73,8 +80,8 @@ defmodule Firebird.TargetTest do
       assert length(results) == 2
 
       modules = Enum.map(results, & &1.module) |> Enum.sort()
-      assert :"TargetApiFib" in modules
-      assert :"TargetApiMath" in modules
+      assert :TargetApiFib in modules
+      assert :TargetApiMath in modules
     end
 
     test "writes output files", %{src_dir: src, out_dir: out} do
@@ -139,7 +146,7 @@ defmodule Firebird.TargetTest do
       path = write_math_module(src)
 
       assert {:ok, [result]} = Target.compile_files([path], output_dir: out)
-      assert result.module == :"TargetApiMath"
+      assert result.module == :TargetApiMath
     end
 
     test "compiles subset of files", %{src_dir: src, out_dir: out} do
@@ -148,7 +155,7 @@ defmodule Firebird.TargetTest do
 
       assert {:ok, results} = Target.compile_files([math_path], output_dir: out)
       assert length(results) == 1
-      assert hd(results).module == :"TargetApiMath"
+      assert hd(results).module == :TargetApiMath
     end
   end
 
@@ -162,7 +169,7 @@ defmodule Firebird.TargetTest do
       """
 
       assert {:ok, result} = Target.compile_source(source)
-      assert result.module == :"InlineTest"
+      assert result.module == :InlineTest
       assert result.wat != nil
       assert result.wasm != nil
     end
@@ -252,7 +259,7 @@ defmodule Firebird.TargetTest do
       assert length(analyses) == 1
 
       analysis = hd(analyses)
-      assert analysis.module == :"TargetApiMath"
+      assert analysis.module == :TargetApiMath
       assert analysis.compilable == true
       assert is_list(analysis.functions)
     end
diff --git a/test/target/verify_comprehensive_test.exs b/test/target/verify_comprehensive_test.exs
index 1ef74b6..45995e2 100644
--- a/test/target/verify_comprehensive_test.exs
+++ b/test/target/verify_comprehensive_test.exs
@@ -45,7 +45,8 @@ defmodule Firebird.Target.VerifyComprehensiveTest do
 
     test "reports failing smoke tests", %{wasm: wasm} do
       smoke_tests = [
-        {:add, [1, 2], 999}  # Wrong expected value
+        # Wrong expected value
+        {:add, [1, 2], 999}
       ]
 
       assert {:ok, report} = Verify.verify_binary(wasm, smoke_tests: smoke_tests)
diff --git a/test/target/verify_test.exs b/test/target/verify_test.exs
index 390f24b..3c4f9c4 100644
--- a/test/target/verify_test.exs
+++ b/test/target/verify_test.exs
@@ -13,7 +13,10 @@ defmodule Firebird.Target.VerifyTest do
   end
   """
 
-  @tmp_dir Path.join(System.tmp_dir!(), "firebird_verify_test_#{:erlang.unique_integer([:positive])}")
+  @tmp_dir Path.join(
+             System.tmp_dir!(),
+             "firebird_verify_test_#{:erlang.unique_integer([:positive])}"
+           )
 
   setup do
     File.mkdir_p!(@tmp_dir)
@@ -45,12 +48,13 @@ defmodule Firebird.Target.VerifyTest do
     test "runs smoke tests" do
       result = compile_to_wasm(@math_source)
 
-      assert {:ok, report} = Verify.verify_binary(result.wasm,
-        smoke_tests: [
-          {:add, [3, 4], 7},
-          {:multiply, [5, 6], 30}
-        ]
-      )
+      assert {:ok, report} =
+               Verify.verify_binary(result.wasm,
+                 smoke_tests: [
+                   {:add, [3, 4], 7},
+                   {:multiply, [5, 6], 30}
+                 ]
+               )
 
       assert report.valid == true
       assert length(report.smoke_tests) == 2
@@ -60,13 +64,16 @@ defmodule Firebird.Target.VerifyTest do
     test "detects failing smoke tests" do
       result = compile_to_wasm(@math_source)
 
-      assert {:ok, report} = Verify.verify_binary(result.wasm,
-        smoke_tests: [
-          {:add, [3, 4], 999}  # Wrong expected value
-        ]
-      )
+      assert {:ok, report} =
+               Verify.verify_binary(result.wasm,
+                 smoke_tests: [
+                   # Wrong expected value
+                   {:add, [3, 4], 999}
+                 ]
+               )
 
-      assert report.valid == true  # Module is valid
+      # Module is valid
+      assert report.valid == true
       assert length(report.smoke_tests) == 1
       refute hd(report.smoke_tests).passed
       assert hd(report.smoke_tests).actual == 7
@@ -125,9 +132,12 @@ defmodule Firebird.Target.VerifyTest do
 
     test "formats report with smoke tests" do
       result = compile_to_wasm(@math_source)
-      {:ok, report} = Verify.verify_binary(result.wasm,
-        smoke_tests: [{:add, [1, 2], 3}]
-      )
+
+      {:ok, report} =
+        Verify.verify_binary(result.wasm,
+          smoke_tests: [{:add, [1, 2], 3}]
+        )
+
       output = Verify.format_report(report)
       assert String.contains?(output, "Smoke Tests")
       assert String.contains?(output, "add")
diff --git a/test/target/wasm_constructs_test.exs b/test/target/wasm_constructs_test.exs
index cdfd65a..d5f677a 100644
--- a/test/target/wasm_constructs_test.exs
+++ b/test/target/wasm_constructs_test.exs
@@ -27,27 +27,28 @@ defmodule Firebird.Target.WasmConstructsTest do
 
   describe "arithmetic operations" do
     setup do
-      instance = compile_and_load("""
-      defmodule ArithOps do
-        @wasm true
-        def add(a, b), do: a + b
+      instance =
+        compile_and_load("""
+        defmodule ArithOps do
+          @wasm true
+          def add(a, b), do: a + b
 
-        @wasm true
-        def sub(a, b), do: a - b
+          @wasm true
+          def sub(a, b), do: a - b
 
-        @wasm true
-        def mul(a, b), do: a * b
+          @wasm true
+          def mul(a, b), do: a * b
 
-        @wasm true
-        def div_op(a, b), do: div(a, b)
+          @wasm true
+          def div_op(a, b), do: div(a, b)
 
-        @wasm true
-        def rem_op(a, b), do: rem(a, b)
+          @wasm true
+          def rem_op(a, b), do: rem(a, b)
 
-        @wasm true
-        def complex(a, b, c), do: a * b + c
-      end
-      """)
+          @wasm true
+          def complex(a, b, c), do: a * b + c
+        end
+        """)
 
       on_exit(fn -> safe_stop(instance) end)
       {:ok, inst: instance}
@@ -88,19 +89,20 @@ defmodule Firebird.Target.WasmConstructsTest do
 
   describe "pattern matching" do
     setup do
-      instance = compile_and_load("""
-      defmodule PatMatch do
-        @wasm true
-        def fib(0), do: 0
-        def fib(1), do: 1
-        def fib(n), do: fib(n - 1) + fib(n - 2)
-
-        @wasm true
-        def classify(0), do: 0
-        def classify(1), do: 1
-        def classify(n), do: n * n
-      end
-      """)
+      instance =
+        compile_and_load("""
+        defmodule PatMatch do
+          @wasm true
+          def fib(0), do: 0
+          def fib(1), do: 1
+          def fib(n), do: fib(n - 1) + fib(n - 2)
+
+          @wasm true
+          def classify(0), do: 0
+          def classify(1), do: 1
+          def classify(n), do: n * n
+        end
+        """)
 
       on_exit(fn -> safe_stop(instance) end)
       {:ok, inst: instance}
@@ -122,50 +124,51 @@ defmodule Firebird.Target.WasmConstructsTest do
 
   describe "if/else expressions" do
     setup do
-      instance = compile_and_load("""
-      defmodule IfElse do
-        @wasm true
-        def abs_val(n) do
-          if n >= 0, do: n, else: 0 - n
-        end
+      instance =
+        compile_and_load("""
+        defmodule IfElse do
+          @wasm true
+          def abs_val(n) do
+            if n >= 0, do: n, else: 0 - n
+          end
 
-        @wasm true
-        def max_val(a, b) do
-          if a >= b, do: a, else: b
-        end
+          @wasm true
+          def max_val(a, b) do
+            if a >= b, do: a, else: b
+          end
 
-        @wasm true
-        def min_val(a, b) do
-          if a <= b, do: a, else: b
-        end
+          @wasm true
+          def min_val(a, b) do
+            if a <= b, do: a, else: b
+          end
 
-        @wasm true
-        def sign(n) do
-          if n > 0 do
-            1
-          else
-            if n < 0 do
-              -1
+          @wasm true
+          def sign(n) do
+            if n > 0 do
+              1
             else
-              0
+              if n < 0 do
+                -1
+              else
+                0
+              end
             end
           end
-        end
 
-        @wasm true
-        def clamp(n, lo, hi) do
-          if n < lo do
-            lo
-          else
-            if n > hi do
-              hi
+          @wasm true
+          def clamp(n, lo, hi) do
+            if n < lo do
+              lo
             else
-              n
+              if n > hi do
+                hi
+              else
+                n
+              end
             end
           end
         end
-      end
-      """)
+        """)
 
       on_exit(fn -> safe_stop(instance) end)
       {:ok, inst: instance}
@@ -203,25 +206,26 @@ defmodule Firebird.Target.WasmConstructsTest do
 
   describe "recursion patterns" do
     setup do
-      instance = compile_and_load("""
-      defmodule Recursion do
-        @wasm true
-        def factorial(0), do: 1
-        def factorial(n), do: n * factorial(n - 1)
-
-        @wasm true
-        def sum_to(0), do: 0
-        def sum_to(n), do: n + sum_to(n - 1)
-
-        @wasm true
-        def power(_, 0), do: 1
-        def power(base, exp), do: base * power(base, exp - 1)
-
-        @wasm true
-        def gcd(a, 0), do: a
-        def gcd(a, b), do: gcd(b, rem(a, b))
-      end
-      """)
+      instance =
+        compile_and_load("""
+        defmodule Recursion do
+          @wasm true
+          def factorial(0), do: 1
+          def factorial(n), do: n * factorial(n - 1)
+
+          @wasm true
+          def sum_to(0), do: 0
+          def sum_to(n), do: n + sum_to(n - 1)
+
+          @wasm true
+          def power(_, 0), do: 1
+          def power(base, exp), do: base * power(base, exp - 1)
+
+          @wasm true
+          def gcd(a, 0), do: a
+          def gcd(a, b), do: gcd(b, rem(a, b))
+        end
+        """)
 
       on_exit(fn -> safe_stop(instance) end)
       {:ok, inst: instance}
@@ -256,37 +260,38 @@ defmodule Firebird.Target.WasmConstructsTest do
 
   describe "comparison operators" do
     setup do
-      instance = compile_and_load("""
-      defmodule Comparisons do
-        @wasm true
-        def is_positive(n) do
-          if n > 0, do: 1, else: 0
-        end
+      instance =
+        compile_and_load("""
+        defmodule Comparisons do
+          @wasm true
+          def is_positive(n) do
+            if n > 0, do: 1, else: 0
+          end
 
-        @wasm true
-        def is_zero(n) do
-          if n == 0, do: 1, else: 0
-        end
+          @wasm true
+          def is_zero(n) do
+            if n == 0, do: 1, else: 0
+          end
 
-        @wasm true
-        def is_even(n) do
-          if rem(n, 2) == 0, do: 1, else: 0
-        end
+          @wasm true
+          def is_even(n) do
+            if rem(n, 2) == 0, do: 1, else: 0
+          end
 
-        @wasm true
-        def compare(a, b) do
-          if a > b do
-            1
-          else
-            if a < b do
-              -1
+          @wasm true
+          def compare(a, b) do
+            if a > b do
+              1
             else
-              0
+              if a < b do
+                -1
+              else
+                0
+              end
             end
           end
         end
-      end
-      """)
+        """)
 
       on_exit(fn -> safe_stop(instance) end)
       {:ok, inst: instance}
@@ -318,19 +323,20 @@ defmodule Firebird.Target.WasmConstructsTest do
 
   describe "collatz conjecture" do
     setup do
-      instance = compile_and_load("""
-      defmodule Collatz do
-        @wasm true
-        def steps(1), do: 0
-        def steps(n) do
-          if rem(n, 2) == 0 do
-            1 + steps(div(n, 2))
-          else
-            1 + steps(3 * n + 1)
+      instance =
+        compile_and_load("""
+        defmodule Collatz do
+          @wasm true
+          def steps(1), do: 0
+          def steps(n) do
+            if rem(n, 2) == 0 do
+              1 + steps(div(n, 2))
+            else
+              1 + steps(3 * n + 1)
+            end
           end
         end
-      end
-      """)
+        """)
 
       on_exit(fn -> safe_stop(instance) end)
       {:ok, inst: instance}
diff --git a/test/target/wasm_correctness_test.exs b/test/target/wasm_correctness_test.exs
index f00dc1d..57f4a65 100644
--- a/test/target/wasm_correctness_test.exs
+++ b/test/target/wasm_correctness_test.exs
@@ -23,24 +23,25 @@ defmodule Firebird.Target.WasmCorrectnessTest do
 
   describe "arithmetic correctness" do
     setup do
-      instance = compile_and_load("""
-      defmodule CorrectnessArith do
-        @wasm true
-        def add(a, b), do: a + b
+      instance =
+        compile_and_load("""
+        defmodule CorrectnessArith do
+          @wasm true
+          def add(a, b), do: a + b
 
-        @wasm true
-        def sub(a, b), do: a - b
+          @wasm true
+          def sub(a, b), do: a - b
 
-        @wasm true
-        def mul(a, b), do: a * b
+          @wasm true
+          def mul(a, b), do: a * b
 
-        @wasm true
-        def divide(a, b), do: div(a, b)
+          @wasm true
+          def divide(a, b), do: div(a, b)
 
-        @wasm true
-        def modulo(a, b), do: rem(a, b)
-      end
-      """)
+          @wasm true
+          def modulo(a, b), do: rem(a, b)
+        end
+        """)
 
       on_exit(fn -> safe_stop(instance) end)
       {:ok, inst: instance}
@@ -85,42 +86,43 @@ defmodule Firebird.Target.WasmCorrectnessTest do
 
   describe "comparison and control flow" do
     setup do
-      instance = compile_and_load("""
-      defmodule CorrectnessControl do
-        @wasm true
-        def abs_val(n) do
-          if n >= 0, do: n, else: 0 - n
-        end
+      instance =
+        compile_and_load("""
+        defmodule CorrectnessControl do
+          @wasm true
+          def abs_val(n) do
+            if n >= 0, do: n, else: 0 - n
+          end
 
-        @wasm true
-        def max_val(a, b) do
-          if a >= b, do: a, else: b
-        end
+          @wasm true
+          def max_val(a, b) do
+            if a >= b, do: a, else: b
+          end
 
-        @wasm true
-        def min_val(a, b) do
-          if a <= b, do: a, else: b
-        end
+          @wasm true
+          def min_val(a, b) do
+            if a <= b, do: a, else: b
+          end
 
-        @wasm true
-        def clamp(n, lo, hi) do
-          if n < lo do
-            lo
-          else
-            if n > hi, do: hi, else: n
+          @wasm true
+          def clamp(n, lo, hi) do
+            if n < lo do
+              lo
+            else
+              if n > hi, do: hi, else: n
+            end
           end
-        end
 
-        @wasm true
-        def sign(n) do
-          if n > 0 do
-            1
-          else
-            if n < 0, do: -1, else: 0
+          @wasm true
+          def sign(n) do
+            if n > 0 do
+              1
+            else
+              if n < 0, do: -1, else: 0
+            end
           end
         end
-      end
-      """)
+        """)
 
       on_exit(fn -> safe_stop(instance) end)
       {:ok, inst: instance}
@@ -162,40 +164,41 @@ defmodule Firebird.Target.WasmCorrectnessTest do
 
   describe "pattern matching and recursion" do
     setup do
-      instance = compile_and_load("""
-      defmodule CorrectnessRecursion do
-        @wasm true
-        def fibonacci(0), do: 0
-        def fibonacci(1), do: 1
-        def fibonacci(n), do: fibonacci(n - 1) + fibonacci(n - 2)
-
-        @wasm true
-        def factorial(0), do: 1
-        def factorial(n), do: n * factorial(n - 1)
-
-        @wasm true
-        def gcd(a, 0), do: a
-        def gcd(a, b), do: gcd(b, rem(a, b))
-
-        @wasm true
-        def power(_, 0), do: 1
-        def power(base, exp), do: base * power(base, exp - 1)
-
-        @wasm true
-        def sum_to(0), do: 0
-        def sum_to(n), do: n + sum_to(n - 1)
-
-        @wasm true
-        def collatz_steps(1), do: 0
-        def collatz_steps(n) do
-          if rem(n, 2) == 0 do
-            1 + collatz_steps(div(n, 2))
-          else
-            1 + collatz_steps(3 * n + 1)
+      instance =
+        compile_and_load("""
+        defmodule CorrectnessRecursion do
+          @wasm true
+          def fibonacci(0), do: 0
+          def fibonacci(1), do: 1
+          def fibonacci(n), do: fibonacci(n - 1) + fibonacci(n - 2)
+
+          @wasm true
+          def factorial(0), do: 1
+          def factorial(n), do: n * factorial(n - 1)
+
+          @wasm true
+          def gcd(a, 0), do: a
+          def gcd(a, b), do: gcd(b, rem(a, b))
+
+          @wasm true
+          def power(_, 0), do: 1
+          def power(base, exp), do: base * power(base, exp - 1)
+
+          @wasm true
+          def sum_to(0), do: 0
+          def sum_to(n), do: n + sum_to(n - 1)
+
+          @wasm true
+          def collatz_steps(1), do: 0
+          def collatz_steps(n) do
+            if rem(n, 2) == 0 do
+              1 + collatz_steps(div(n, 2))
+            else
+              1 + collatz_steps(3 * n + 1)
+            end
           end
         end
-      end
-      """)
+        """)
 
       on_exit(fn -> safe_stop(instance) end)
       {:ok, inst: instance}
@@ -211,8 +214,19 @@ defmodule Firebird.Target.WasmCorrectnessTest do
     end
 
     test "factorial", %{inst: inst} do
-      facts = [{0, 1}, {1, 1}, {2, 2}, {3, 6}, {4, 24}, {5, 120}, {6, 720},
-               {7, 5040}, {8, 40320}, {9, 362880}, {10, 3_628_800}]
+      facts = [
+        {0, 1},
+        {1, 1},
+        {2, 2},
+        {3, 6},
+        {4, 24},
+        {5, 120},
+        {6, 720},
+        {7, 5040},
+        {8, 40320},
+        {9, 362_880},
+        {10, 3_628_800}
+      ]
 
       for {n, expected} <- facts do
         assert {:ok, [^expected]} = Firebird.call(inst, "factorial", [n]),
@@ -259,50 +273,51 @@ defmodule Firebird.Target.WasmCorrectnessTest do
 
   describe "complex control flow" do
     setup do
-      instance = compile_and_load("""
-      defmodule CorrectnessComplex do
-        @wasm true
-        def classify(n) do
-          if n > 100 do
-            4
-          else
-            if n > 50 do
-              3
+      instance =
+        compile_and_load("""
+        defmodule CorrectnessComplex do
+          @wasm true
+          def classify(n) do
+            if n > 100 do
+              4
             else
-              if n > 10 do
-                2
+              if n > 50 do
+                3
               else
-                if n > 0 do
-                  1
+                if n > 10 do
+                  2
                 else
-                  0
+                  if n > 0 do
+                    1
+                  else
+                    0
+                  end
                 end
               end
             end
           end
-        end
 
-        @wasm true
-        def is_even(0), do: 1
-        def is_even(1), do: 0
-        def is_even(n) do
-          if n > 0 do
-            is_even(n - 2)
-          else
-            is_even(n + 2)
+          @wasm true
+          def is_even(0), do: 1
+          def is_even(1), do: 0
+          def is_even(n) do
+            if n > 0 do
+              is_even(n - 2)
+            else
+              is_even(n + 2)
+            end
           end
-        end
 
-        @wasm true
-        def triangular(0), do: 0
-        def triangular(n), do: n + triangular(n - 1)
+          @wasm true
+          def triangular(0), do: 0
+          def triangular(n), do: n + triangular(n - 1)
 
-        @wasm true
-        def double_factorial(0), do: 1
-        def double_factorial(1), do: 1
-        def double_factorial(n), do: n * double_factorial(n - 2)
-      end
-      """)
+          @wasm true
+          def double_factorial(0), do: 1
+          def double_factorial(1), do: 1
+          def double_factorial(n), do: n * double_factorial(n - 2)
+        end
+        """)
 
       on_exit(fn -> safe_stop(instance) end)
       {:ok, inst: instance}
@@ -345,12 +360,13 @@ defmodule Firebird.Target.WasmCorrectnessTest do
 
   describe "WASM output from target API" do
     test "compile_source returns all expected fields" do
-      {:ok, result} = Target.compile_source("""
-      defmodule FieldTest do
-        @wasm true
-        def id(n), do: n
-      end
-      """)
+      {:ok, result} =
+        Target.compile_source("""
+        defmodule FieldTest do
+          @wasm true
+          def id(n), do: n
+        end
+        """)
 
       assert is_atom(result.module)
       assert is_binary(result.wat)
@@ -360,12 +376,13 @@ defmodule Firebird.Target.WasmCorrectnessTest do
     end
 
     test "WAT output is valid WebAssembly text" do
-      {:ok, result} = Target.compile_source("""
-      defmodule WatCheck do
-        @wasm true
-        def add(a, b), do: a + b
-      end
-      """)
+      {:ok, result} =
+        Target.compile_source("""
+        defmodule WatCheck do
+          @wasm true
+          def add(a, b), do: a + b
+        end
+        """)
 
       assert String.starts_with?(result.wat, "(module")
       assert String.contains?(result.wat, "(func")
@@ -375,12 +392,13 @@ defmodule Firebird.Target.WasmCorrectnessTest do
     end
 
     test "WASM binary starts with magic bytes" do
-      {:ok, result} = Target.compile_source("""
-      defmodule MagicCheck do
-        @wasm true
-        def one, do: 1
-      end
-      """)
+      {:ok, result} =
+        Target.compile_source("""
+        defmodule MagicCheck do
+          @wasm true
+          def one, do: 1
+        end
+        """)
 
       # WASM magic number: \0asm
       <<magic::binary-size(4), _rest::binary>> = result.wasm
diff --git a/test/target/wasm_e2e_bench_test.exs b/test/target/wasm_e2e_bench_test.exs
index 991c067..b55298a 100644
--- a/test/target/wasm_e2e_bench_test.exs
+++ b/test/target/wasm_e2e_bench_test.exs
@@ -18,12 +18,15 @@ defmodule Firebird.Target.WasmE2EBenchTest do
       end
       """
 
-      result = Benchmark.compare_function(
-        source, :add, [42, 58],
-        beam_fn: fn a, b -> a + b end,
-        iterations: 10,
-        warmup: 2
-      )
+      result =
+        Benchmark.compare_function(
+          source,
+          :add,
+          [42, 58],
+          beam_fn: fn a, b -> a + b end,
+          iterations: 10,
+          warmup: 2
+        )
 
       assert result.correct == true
       assert result.wasm_result == 100
@@ -43,12 +46,15 @@ defmodule Firebird.Target.WasmE2EBenchTest do
       end
       """
 
-      result = Benchmark.compare_function(
-        source, :fibonacci, [10],
-        beam_fn: &beam_fibonacci/1,
-        iterations: 10,
-        warmup: 2
-      )
+      result =
+        Benchmark.compare_function(
+          source,
+          :fibonacci,
+          [10],
+          beam_fn: &beam_fibonacci/1,
+          iterations: 10,
+          warmup: 2
+        )
 
       assert result.correct == true
       assert result.wasm_result == 55
@@ -64,12 +70,15 @@ defmodule Firebird.Target.WasmE2EBenchTest do
       end
       """
 
-      result = Benchmark.compare_function(
-        source, :factorial, [10],
-        beam_fn: &beam_factorial/1,
-        iterations: 10,
-        warmup: 2
-      )
+      result =
+        Benchmark.compare_function(
+          source,
+          :factorial,
+          [10],
+          beam_fn: &beam_factorial/1,
+          iterations: 10,
+          warmup: 2
+        )
 
       assert result.correct == true
       assert result.wasm_result == 3_628_800
@@ -85,12 +94,15 @@ defmodule Firebird.Target.WasmE2EBenchTest do
       end
       """
 
-      result = Benchmark.compare_function(
-        source, :gcd, [48, 18],
-        beam_fn: fn a, b -> Integer.gcd(a, b) end,
-        iterations: 10,
-        warmup: 2
-      )
+      result =
+        Benchmark.compare_function(
+          source,
+          :gcd,
+          [48, 18],
+          beam_fn: fn a, b -> Integer.gcd(a, b) end,
+          iterations: 10,
+          warmup: 2
+        )
 
       assert result.correct == true
       assert result.wasm_result == 6
@@ -107,12 +119,15 @@ defmodule Firebird.Target.WasmE2EBenchTest do
       end
       """
 
-      result = Benchmark.compare_function(
-        source, :max_val, [10, 20],
-        beam_fn: fn a, b -> max(a, b) end,
-        iterations: 10,
-        warmup: 2
-      )
+      result =
+        Benchmark.compare_function(
+          source,
+          :max_val,
+          [10, 20],
+          beam_fn: fn a, b -> max(a, b) end,
+          iterations: 10,
+          warmup: 2
+        )
 
       assert result.correct == true
       assert result.wasm_result == 20
@@ -128,12 +143,15 @@ defmodule Firebird.Target.WasmE2EBenchTest do
       end
       """
 
-      result = Benchmark.compare_function(
-        source, :double, [21],
-        beam_fn: fn n -> n * 2 end,
-        iterations: 20,
-        warmup: 5
-      )
+      result =
+        Benchmark.compare_function(
+          source,
+          :double,
+          [21],
+          beam_fn: fn n -> n * 2 end,
+          iterations: 20,
+          warmup: 5
+        )
 
       # Check WASM stats
       assert is_number(result.wasm.avg)
@@ -188,15 +206,16 @@ defmodule Firebird.Target.WasmE2EBenchTest do
 
   describe "run_suite/1" do
     test "runs default suite with filter" do
-      results = Benchmark.run_suite(
-        iterations: 5,
-        warmup: 2,
-        filter: "add"
-      )
+      results =
+        Benchmark.run_suite(
+          iterations: 5,
+          warmup: 2,
+          filter: "add"
+        )
 
       assert is_list(results)
       assert length(results) >= 1
-      assert Enum.all?(results, &(&1.correct))
+      assert Enum.all?(results, & &1.correct)
     end
   end
 
@@ -209,8 +228,26 @@ defmodule Firebird.Target.WasmE2EBenchTest do
       correct: correct,
       wasm_result: 1,
       beam_result: 1,
-      wasm: %{avg: wasm_avg, min: 1, max: 20, median: wasm_avg, p95: wasm_avg * 1.5, p99: wasm_avg * 2, stddev: 1.0, total: wasm_avg * 10},
-      beam: %{avg: beam_avg, min: 1, max: 10, median: beam_avg, p95: beam_avg * 1.5, p99: beam_avg * 2, stddev: 0.5, total: beam_avg * 10},
+      wasm: %{
+        avg: wasm_avg,
+        min: 1,
+        max: 20,
+        median: wasm_avg,
+        p95: wasm_avg * 1.5,
+        p99: wasm_avg * 2,
+        stddev: 1.0,
+        total: wasm_avg * 10
+      },
+      beam: %{
+        avg: beam_avg,
+        min: 1,
+        max: 10,
+        median: beam_avg,
+        p95: beam_avg * 1.5,
+        p99: beam_avg * 2,
+        stddev: 0.5,
+        total: beam_avg * 10
+      },
       speedup: beam_avg / wasm_avg,
       iterations: 10
     }
diff --git a/test/test_helpers_macros_test.exs b/test/test_helpers_macros_test.exs
index 6fa2e9c..8d0ad9b 100644
--- a/test/test_helpers_macros_test.exs
+++ b/test/test_helpers_macros_test.exs
@@ -264,25 +264,34 @@ defmodule Firebird.TestHelpersMacrosTest do
     end
 
     test "raw mode passes for list results", %{wasm: wasm} do
-      assert_wasm_table wasm, :add, [
-        {[1, 2], [3]},
-        {[5, 3], [8]}
-      ], raw: true
+      assert_wasm_table wasm,
+                        :add,
+                        [
+                          {[1, 2], [3]},
+                          {[5, 3], [8]}
+                        ],
+                        raw: true
     end
 
     test "raw mode fails on incorrect result", %{wasm: wasm} do
       assert_raise ExUnit.AssertionError, ~r/assert_wasm_table.*failed/, fn ->
-        assert_wasm_table wasm, :add, [
-          {[1, 2], [999]}
-        ], raw: true
+        assert_wasm_table wasm,
+                          :add,
+                          [
+                            {[1, 2], [999]}
+                          ],
+                          raw: true
       end
     end
 
     test "raw mode fails on error", %{wasm: wasm} do
       assert_raise ExUnit.AssertionError, ~r/assert_wasm_table.*errored/, fn ->
-        assert_wasm_table wasm, :nonexistent, [
-          {[1], [1]}
-        ], raw: true
+        assert_wasm_table wasm,
+                          :nonexistent,
+                          [
+                            {[1], [1]}
+                          ],
+                          raw: true
       end
     end
   end
diff --git a/test/test_helpers_pool_pipeline_test.exs b/test/test_helpers_pool_pipeline_test.exs
index 080dafb..c0cdeed 100644
--- a/test/test_helpers_pool_pipeline_test.exs
+++ b/test/test_helpers_pool_pipeline_test.exs
@@ -12,7 +12,7 @@ defmodule Firebird.TestHelpers.PoolPipelineTest do
   # ── setup_pool tests ──────────────────────────────────────────────────────
 
   describe "setup_pool/2" do
-    setup_pool @math_wasm, size: 2
+    setup_pool(@math_wasm, size: 2)
 
     test "creates a pool in the test context", %{pool: pool} do
       assert is_pid(pool)
@@ -46,55 +46,83 @@ defmodule Firebird.TestHelpers.PoolPipelineTest do
     end
 
     test "single-step pipeline", %{wasm: wasm} do
-      assert_wasm_pipeline wasm, [
-        {:add, [5, 3]}
-      ], [8]
+      assert_wasm_pipeline(
+        wasm,
+        [
+          {:add, [5, 3]}
+        ],
+        [8]
+      )
     end
 
     test "two-step pipeline with placeholder", %{wasm: wasm} do
-      assert_wasm_pipeline wasm, [
-        {:add, [5, 3]},
-        {:multiply, [:_, 2]}
-      ], [16]
+      assert_wasm_pipeline(
+        wasm,
+        [
+          {:add, [5, 3]},
+          {:multiply, [:_, 2]}
+        ],
+        [16]
+      )
     end
 
     test "three-step pipeline", %{wasm: wasm} do
-      assert_wasm_pipeline wasm, [
-        {:add, [10, 20]},
-        {:multiply, [:_, 2]},
-        {:subtract, [:_, 10]}
-      ], [50]
+      assert_wasm_pipeline(
+        wasm,
+        [
+          {:add, [10, 20]},
+          {:multiply, [:_, 2]},
+          {:subtract, [:_, 10]}
+        ],
+        [50]
+      )
     end
 
     test "pipeline with fibonacci", %{wasm: wasm} do
-      assert_wasm_pipeline wasm, [
-        {:add, [5, 5]},
-        {:fibonacci, [:_]}
-      ], [55]
+      assert_wasm_pipeline(
+        wasm,
+        [
+          {:add, [5, 5]},
+          {:fibonacci, [:_]}
+        ],
+        [55]
+      )
     end
 
     test "pipeline with factorial", %{wasm: wasm} do
-      assert_wasm_pipeline wasm, [
-        {:add, [3, 2]},
-        {:factorial, [:_]}
-      ], [120]
+      assert_wasm_pipeline(
+        wasm,
+        [
+          {:add, [3, 2]},
+          {:factorial, [:_]}
+        ],
+        [120]
+      )
     end
 
     test "pipeline failure raises with helpful message", %{wasm: wasm} do
       assert_raise ExUnit.AssertionError, ~r/assert_wasm_pipeline/, fn ->
         # add(5,3) = 8, multiply(8,2) = 16, but we expect [999]
-        assert_wasm_pipeline wasm, [
-          {:add, [5, 3]},
-          {:multiply, [:_, 2]}
-        ], [999]
+        assert_wasm_pipeline(
+          wasm,
+          [
+            {:add, [5, 3]},
+            {:multiply, [:_, 2]}
+          ],
+          [999]
+        )
       end
     end
 
     test "pipeline with nonexistent function reports error", %{wasm: wasm} do
       assert_raise ExUnit.AssertionError, ~r/assert_wasm_pipeline errored/, fn ->
-        assert_wasm_pipeline wasm, [
-          {:nonexistent_function, [1, 2]}
-        ], [3]
+        assert_wasm_pipeline(
+          wasm,
+          [
+            {:nonexistent_function, [1, 2]}
+          ],
+          [3]
+        )
       end
     end
   end
@@ -110,51 +138,51 @@ defmodule Firebird.TestHelpers.PoolPipelineTest do
 
     test "value within range passes", %{wasm: wasm} do
       # fibonacci(10) = 55, which is between 50 and 60
-      assert_wasm_between wasm, :fibonacci, [10], 50, 60
+      assert_wasm_between(wasm, :fibonacci, [10], 50, 60)
     end
 
     test "exact lower bound passes", %{wasm: wasm} do
       # add(0, 0) = 0
-      assert_wasm_between wasm, :add, [0, 0], 0, 10
+      assert_wasm_between(wasm, :add, [0, 0], 0, 10)
     end
 
     test "exact upper bound passes", %{wasm: wasm} do
       # add(5, 5) = 10
-      assert_wasm_between wasm, :add, [5, 5], 0, 10
+      assert_wasm_between(wasm, :add, [5, 5], 0, 10)
     end
 
     test "exact match passes", %{wasm: wasm} do
       # add(4, 4) = 8
-      assert_wasm_between wasm, :add, [4, 4], 8, 8
+      assert_wasm_between(wasm, :add, [4, 4], 8, 8)
     end
 
     test "value below range fails", %{wasm: wasm} do
       assert_raise ExUnit.AssertionError, ~r/assert_wasm_between/, fn ->
         # add(1, 1) = 2, not between 10 and 20
-        assert_wasm_between wasm, :add, [1, 1], 10, 20
+        assert_wasm_between(wasm, :add, [1, 1], 10, 20)
       end
     end
 
     test "value above range fails", %{wasm: wasm} do
       assert_raise ExUnit.AssertionError, ~r/assert_wasm_between/, fn ->
         # add(50, 50) = 100, not between 0 and 10
-        assert_wasm_between wasm, :add, [50, 50], 0, 10
+        assert_wasm_between(wasm, :add, [50, 50], 0, 10)
       end
     end
 
     test "nonexistent function reports error", %{wasm: wasm} do
       assert_raise ExUnit.AssertionError, ~r/assert_wasm_between.*errored/, fn ->
-        assert_wasm_between wasm, :nonexistent, [1], 0, 100
+        assert_wasm_between(wasm, :nonexistent, [1], 0, 100)
       end
     end
 
     test "fibonacci values in expected ranges", %{wasm: wasm} do
       # fib(1) = 1
-      assert_wasm_between wasm, :fibonacci, [1], 0, 5
+      assert_wasm_between(wasm, :fibonacci, [1], 0, 5)
       # fib(5) = 5
-      assert_wasm_between wasm, :fibonacci, [5], 1, 10
+      assert_wasm_between(wasm, :fibonacci, [5], 1, 10)
       # fib(10) = 55
-      assert_wasm_between wasm, :fibonacci, [10], 50, 60
+      assert_wasm_between(wasm, :fibonacci, [10], 50, 60)
     end
   end
 end
diff --git a/test/typed_call_test.exs b/test/typed_call_test.exs
index 33df9c1..b6449e1 100644
--- a/test/typed_call_test.exs
+++ b/test/typed_call_test.exs
@@ -38,8 +38,11 @@ defmodule Firebird.TypedCallTest do
           assert opts[:got] == 1
 
         # If function_type isn't available, it may skip validation
-        {:error, _} -> :ok
-        {:ok, _} -> :ok
+        {:error, _} ->
+          :ok
+
+        {:ok, _} ->
+          :ok
       end
     end
 
@@ -51,8 +54,11 @@ defmodule Firebird.TypedCallTest do
           assert opts[:expected] == 2
           assert opts[:got] == 3
 
-        {:error, _} -> :ok
-        {:ok, _} -> :ok
+        {:error, _} ->
+          :ok
+
+        {:ok, _} ->
+          :ok
       end
     end
 
@@ -64,8 +70,11 @@ defmodule Firebird.TypedCallTest do
           assert opts[:expected] == :i32
           assert opts[:got] == :string
 
-        {:error, _} -> :ok
-        {:ok, _} -> :ok
+        {:error, _} ->
+          :ok
+
+        {:ok, _} ->
+          :ok
       end
     end
 
@@ -77,8 +86,11 @@ defmodule Firebird.TypedCallTest do
           assert opts[:expected] == :i32
           assert opts[:got] == :atom
 
-        {:error, _} -> :ok
-        {:ok, _} -> :ok
+        {:error, _} ->
+          :ok
+
+        {:ok, _} ->
+          :ok
       end
     end
 
@@ -90,8 +102,11 @@ defmodule Firebird.TypedCallTest do
           assert opts[:expected] == :i32
           assert opts[:got] == :list
 
-        {:error, _} -> :ok
-        {:ok, _} -> :ok
+        {:error, _} ->
+          :ok
+
+        {:ok, _} ->
+          :ok
       end
     end
 
diff --git a/test/wasm_concurrent_execution_test.exs b/test/wasm_concurrent_execution_test.exs
index 0ed4c2d..e3a9596 100644
--- a/test/wasm_concurrent_execution_test.exs
+++ b/test/wasm_concurrent_execution_test.exs
@@ -10,16 +10,18 @@ defmodule Firebird.WasmConcurrentExecutionTest do
 
   describe "concurrent execution isolation" do
     test "multiple instances return correct independent results" do
-      pids = for _ <- 1..5 do
-        {:ok, pid} = Firebird.load(@rust_wasm)
-        pid
-      end
+      pids =
+        for _ <- 1..5 do
+          {:ok, pid} = Firebird.load(@rust_wasm)
+          pid
+        end
 
       # Each instance should work independently
-      results = Enum.map(pids, fn pid ->
-        {:ok, [r]} = Firebird.call(pid, :add, [5, 3])
-        r
-      end)
+      results =
+        Enum.map(pids, fn pid ->
+          {:ok, [r]} = Firebird.call(pid, :add, [5, 3])
+          r
+        end)
 
       assert results == [8, 8, 8, 8, 8]
 
@@ -48,12 +50,13 @@ defmodule Firebird.WasmConcurrentExecutionTest do
     test "parallel Task execution" do
       {:ok, pid} = Firebird.load(@rust_wasm)
 
-      tasks = for n <- 1..10 do
-        Task.async(fn ->
-          {:ok, [result]} = Firebird.call(pid, :fibonacci, [n])
-          result
-        end)
-      end
+      tasks =
+        for n <- 1..10 do
+          Task.async(fn ->
+            {:ok, [result]} = Firebird.call(pid, :fibonacci, [n])
+            result
+          end)
+        end
 
       results = Task.await_many(tasks)
       expected = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
@@ -66,30 +69,47 @@ defmodule Firebird.WasmConcurrentExecutionTest do
   describe "run_concurrent with different modules" do
     test "Rust concurrent fibonacci" do
       args_list = for n <- [5, 10, 15, 20, 25], do: [n]
-      {:ok, results} = Firebird.WasmRunner.run_concurrent(@rust_wasm, :fibonacci, args_list, concurrency: 3)
+
+      {:ok, results} =
+        Firebird.WasmRunner.run_concurrent(@rust_wasm, :fibonacci, args_list, concurrency: 3)
+
       assert results == [5, 55, 610, 6765, 75025]
     end
 
     test "Go concurrent fibonacci" do
       args_list = for n <- [5, 10, 15], do: [n]
-      {:ok, results} = Firebird.WasmRunner.run_concurrent(@go_wasm, :fibonacci, args_list, concurrency: 2, wasi: true)
+
+      {:ok, results} =
+        Firebird.WasmRunner.run_concurrent(@go_wasm, :fibonacci, args_list,
+          concurrency: 2,
+          wasi: true
+        )
+
       assert results == [5, 55, 610]
     end
 
     test "concurrent with single item" do
-      {:ok, results} = Firebird.WasmRunner.run_concurrent(@rust_wasm, :add, [[5, 3]], concurrency: 2)
+      {:ok, results} =
+        Firebird.WasmRunner.run_concurrent(@rust_wasm, :add, [[5, 3]], concurrency: 2)
+
       assert results == [8]
     end
 
     test "concurrent is_prime over large range" do
       args_list = for n <- [2, 3, 4, 5, 97, 100, 101, 1009], do: [n]
-      {:ok, results} = Firebird.WasmRunner.run_concurrent(@rust_wasm, :is_prime, args_list, concurrency: 4)
+
+      {:ok, results} =
+        Firebird.WasmRunner.run_concurrent(@rust_wasm, :is_prime, args_list, concurrency: 4)
+
       assert results == [1, 1, 0, 1, 1, 0, 1, 1]
     end
 
     test "concurrent count_primes" do
       args_list = for n <- [10, 100, 1000], do: [n]
-      {:ok, results} = Firebird.WasmRunner.run_concurrent(@rust_wasm, :count_primes, args_list, concurrency: 3)
+
+      {:ok, results} =
+        Firebird.WasmRunner.run_concurrent(@rust_wasm, :count_primes, args_list, concurrency: 3)
+
       assert results == [4, 25, 168]
     end
   end
@@ -100,7 +120,9 @@ defmodule Firebird.WasmConcurrentExecutionTest do
       {:ok, batch_results} = Firebird.WasmRunner.run_batch(@rust_wasm, calls)
 
       args_list = for n <- 1..20, do: [n]
-      {:ok, concurrent_results} = Firebird.WasmRunner.run_concurrent(@rust_wasm, :fibonacci, args_list, concurrency: 4)
+
+      {:ok, concurrent_results} =
+        Firebird.WasmRunner.run_concurrent(@rust_wasm, :fibonacci, args_list, concurrency: 4)
 
       assert batch_results == concurrent_results
     end
@@ -111,7 +133,8 @@ defmodule Firebird.WasmConcurrentExecutionTest do
       {:ok, pid} = Firebird.load(@rust_wasm)
       {time, {:ok, [8]}} = Firebird.WasmRunner.timed_call(pid, :add, [5, 3])
       assert time >= 0
-      assert time < 100_000  # Should be less than 100ms
+      # Should be less than 100ms
+      assert time < 100_000
       Firebird.stop(pid)
     end
 
@@ -140,7 +163,8 @@ defmodule Firebird.WasmConcurrentExecutionTest do
       assert desc.function_count == 22
       assert desc.memory_pages >= 1
       assert desc.memory_bytes > 0
-      assert desc.total_exports > desc.function_count  # includes memory export
+      # includes memory export
+      assert desc.total_exports > desc.function_count
 
       # Check signatures exist
       assert Map.has_key?(desc.signatures, :add)
diff --git a/test/wasm_float_test.exs b/test/wasm_float_test.exs
index bec4c26..1beb1e4 100644
--- a/test/wasm_float_test.exs
+++ b/test/wasm_float_test.exs
@@ -75,10 +75,12 @@ defmodule Firebird.WasmFloatTest do
 
   test "dot_2d", %{instance: pid} do
     {:ok, [r]} = Firebird.call(pid, :dot_2d, [1.0, 0.0, 0.0, 1.0])
-    assert_in_delta r, 0.0, 0.0001  # perpendicular
+    # perpendicular
+    assert_in_delta r, 0.0, 0.0001
 
     {:ok, [r]} = Firebird.call(pid, :dot_2d, [3.0, 4.0, 3.0, 4.0])
-    assert_in_delta r, 25.0, 0.0001  # parallel (magnitude squared)
+    # parallel (magnitude squared)
+    assert_in_delta r, 25.0, 0.0001
   end
 
   test "celsius_to_fahrenheit", %{instance: pid} do
diff --git a/test/wasm_from_elixir_test.exs b/test/wasm_from_elixir_test.exs
index 55bf6b7..4d8b128 100644
--- a/test/wasm_from_elixir_test.exs
+++ b/test/wasm_from_elixir_test.exs
@@ -143,11 +143,13 @@ defmodule WasmFromElixirTest do
 
   describe "batch and runner operations" do
     test "run_batch executes multiple functions" do
-      {:ok, results} = Firebird.WasmRunner.run_batch("fixtures/math.wasm", [
-        {:add, [10, 20]},
-        {:multiply, [5, 6]},
-        {:fibonacci, [8]}
-      ])
+      {:ok, results} =
+        Firebird.WasmRunner.run_batch("fixtures/math.wasm", [
+          {:add, [10, 20]},
+          {:multiply, [5, 6]},
+          {:fibonacci, [8]}
+        ])
+
       assert results == [30, 30, 21]
     end
 
@@ -191,11 +193,12 @@ defmodule WasmFromElixirTest do
     test "call_many executes multiple calls" do
       {:ok, pid} = Firebird.load("fixtures/math.wasm")
 
-      {:ok, results} = Firebird.call_many(pid, [
-        {:add, [1, 2]},
-        {:multiply, [3, 4]},
-        {:factorial, [5]}
-      ])
+      {:ok, results} =
+        Firebird.call_many(pid, [
+          {:add, [1, 2]},
+          {:multiply, [3, 4]},
+          {:factorial, [5]}
+        ])
 
       assert results == [[3], [12], [120]]
       Firebird.stop(pid)
diff --git a/test/wasm_integration_comprehensive_test.exs b/test/wasm_integration_comprehensive_test.exs
index 47df99b..3d5ed1d 100644
--- a/test/wasm_integration_comprehensive_test.exs
+++ b/test/wasm_integration_comprehensive_test.exs
@@ -190,11 +190,12 @@ defmodule Firebird.WasmIntegrationComprehensiveTest do
       {:ok, float} = load_module(:rust_float)
 
       # Animate from 0 to 100 in 10 steps
-      steps = for i <- 0..10 do
-        t = i / 10.0
-        {:ok, [v]} = Firebird.call(float, :lerp, [0.0, 100.0, t])
-        v
-      end
+      steps =
+        for i <- 0..10 do
+          t = i / 10.0
+          {:ok, [v]} = Firebird.call(float, :lerp, [0.0, 100.0, t])
+          v
+        end
 
       assert_in_delta hd(steps), 0.0, 0.001
       assert_in_delta List.last(steps), 100.0, 0.001
@@ -210,13 +211,17 @@ defmodule Firebird.WasmIntegrationComprehensiveTest do
       path = Path.join(@fixtures_dir, "math.wasm")
       {:ok, pool} = Firebird.start_pool(wasm: path, size: 4)
 
-      results = 1..20
-      |> Task.async_stream(fn n ->
-        {:ok, [r]} = Firebird.pool_call(pool, :fibonacci, [n])
-        {n, r}
-      end, max_concurrency: 4)
-      |> Enum.map(fn {:ok, r} -> r end)
-      |> Enum.sort()
+      results =
+        1..20
+        |> Task.async_stream(
+          fn n ->
+            {:ok, [r]} = Firebird.pool_call(pool, :fibonacci, [n])
+            {n, r}
+          end,
+          max_concurrency: 4
+        )
+        |> Enum.map(fn {:ok, r} -> r end)
+        |> Enum.sort()
 
       # Verify fibonacci sequence
       assert {1, 1} in results
@@ -230,17 +235,18 @@ defmodule Firebird.WasmIntegrationComprehensiveTest do
 
   describe "WasmRunner integration" do
     test "batch execution across different modules" do
-      {:ok, results} = Firebird.WasmRunner.run_batch(
-        Path.join(@fixtures_dir, "math.wasm"),
-        [
-          {:add, [1, 2]},
-          {:multiply, [3, 4]},
-          {:fibonacci, [10]},
-          {:factorial, [5]},
-          {:gcd, [48, 18]},
-          {:is_prime, [97]}
-        ]
-      )
+      {:ok, results} =
+        Firebird.WasmRunner.run_batch(
+          Path.join(@fixtures_dir, "math.wasm"),
+          [
+            {:add, [1, 2]},
+            {:multiply, [3, 4]},
+            {:fibonacci, [10]},
+            {:factorial, [5]},
+            {:gcd, [48, 18]},
+            {:is_prime, [97]}
+          ]
+        )
 
       assert results == [3, 12, 55, 120, 6, 1]
     end
@@ -261,11 +267,12 @@ defmodule Firebird.WasmIntegrationComprehensiveTest do
     test "load and stop many instances" do
       path = Path.join(@fixtures_dir, "math.wasm")
 
-      pids = for _ <- 1..20 do
-        {:ok, pid} = Firebird.load(path)
-        {:ok, [8]} = Firebird.call(pid, :add, [5, 3])
-        pid
-      end
+      pids =
+        for _ <- 1..20 do
+          {:ok, pid} = Firebird.load(path)
+          {:ok, [8]} = Firebird.call(pid, :add, [5, 3])
+          pid
+        end
 
       assert length(pids) == 20
       assert Enum.all?(pids, &Process.alive?/1)
diff --git a/test/wasm_module_bitwise_test.exs b/test/wasm_module_bitwise_test.exs
index d397cbb..a1155df 100644
--- a/test/wasm_module_bitwise_test.exs
+++ b/test/wasm_module_bitwise_test.exs
@@ -1,32 +1,32 @@
 defmodule GoBitwise do
   use Firebird.WasmModule, path: "fixtures/go_bitwise.wasm", wasi: true
 
-  wasm_func :bit_and, [:i32, :i32], [:i32]
-  wasm_func :bit_or, [:i32, :i32], [:i32]
-  wasm_func :bit_xor, [:i32, :i32], [:i32]
-  wasm_func :bit_not, [:i32], [:i32]
-  wasm_func :popcount, [:i32], [:i32]
-  wasm_func :is_power_of_two, [:i32], [:i32]
-  wasm_func :next_power_of_two, [:i32], [:i32]
-  wasm_func :hash_djb2, [:i32], [:i32]
-  wasm_func :hash_fnv1a, [:i32], [:i32]
-  wasm_func :hash_combine, [:i32, :i32], [:i32]
-  wasm_func :abs_without_branch, [:i32], [:i32]
-  wasm_func :min_without_branch, [:i32, :i32], [:i32]
-  wasm_func :max_without_branch, [:i32, :i32], [:i32]
+  wasm_func(:bit_and, [:i32, :i32], [:i32])
+  wasm_func(:bit_or, [:i32, :i32], [:i32])
+  wasm_func(:bit_xor, [:i32, :i32], [:i32])
+  wasm_func(:bit_not, [:i32], [:i32])
+  wasm_func(:popcount, [:i32], [:i32])
+  wasm_func(:is_power_of_two, [:i32], [:i32])
+  wasm_func(:next_power_of_two, [:i32], [:i32])
+  wasm_func(:hash_djb2, [:i32], [:i32])
+  wasm_func(:hash_fnv1a, [:i32], [:i32])
+  wasm_func(:hash_combine, [:i32, :i32], [:i32])
+  wasm_func(:abs_without_branch, [:i32], [:i32])
+  wasm_func(:min_without_branch, [:i32, :i32], [:i32])
+  wasm_func(:max_without_branch, [:i32, :i32], [:i32])
 end
 
 defmodule WatBitwise do
   use Firebird.WasmModule, path: "fixtures/wat_bitwise.wasm"
 
-  wasm_func :popcount, [:i32], [:i32]
-  wasm_func :clz, [:i32], [:i32]
-  wasm_func :ctz, [:i32], [:i32]
-  wasm_func :bit_and, [:i32, :i32], [:i32]
-  wasm_func :bit_or, [:i32, :i32], [:i32]
-  wasm_func :bit_xor, [:i32, :i32], [:i32]
-  wasm_func :is_power_of_two, [:i32], [:i32]
-  wasm_func :next_power_of_two, [:i32], [:i32]
+  wasm_func(:popcount, [:i32], [:i32])
+  wasm_func(:clz, [:i32], [:i32])
+  wasm_func(:ctz, [:i32], [:i32])
+  wasm_func(:bit_and, [:i32, :i32], [:i32])
+  wasm_func(:bit_or, [:i32, :i32], [:i32])
+  wasm_func(:bit_xor, [:i32, :i32], [:i32])
+  wasm_func(:is_power_of_two, [:i32], [:i32])
+  wasm_func(:next_power_of_two, [:i32], [:i32])
 end
 
 defmodule Firebird.WasmModuleBitwiseTest do
@@ -65,7 +65,8 @@ defmodule Firebird.WasmModuleBitwiseTest do
       {:ok, [h2]} = GoBitwise.hash_fnv1a(w, 42)
       assert is_integer(h1)
       assert is_integer(h2)
-      assert h1 != h2  # Different hash algorithms
+      # Different hash algorithms
+      assert h1 != h2
     end
 
     test "hash_combine via module wrapper", %{w: w} do
diff --git a/test/wasm_module_go_test.exs b/test/wasm_module_go_test.exs
index 763dba1..e735db7 100644
--- a/test/wasm_module_go_test.exs
+++ b/test/wasm_module_go_test.exs
@@ -7,14 +7,14 @@ defmodule Firebird.WasmModuleGoTest do
   defmodule GoMath do
     use Firebird.WasmModule, path: Path.join(__DIR__, "../fixtures/go_math.wasm"), wasi: true
 
-    wasm_func :add, [:i32, :i32], [:i32]
-    wasm_func :multiply, [:i32, :i32], [:i32]
-    wasm_func :fibonacci, [:i32], [:i32]
-    wasm_func :factorial, [:i32], [:i32]
-    wasm_func :gcd, [:i32, :i32], [:i32]
-    wasm_func :power, [:i32, :i32], [:i32]
-    wasm_func :is_prime, [:i32], [:i32]
-    wasm_func :sum_range, [:i32, :i32], [:i32]
+    wasm_func(:add, [:i32, :i32], [:i32])
+    wasm_func(:multiply, [:i32, :i32], [:i32])
+    wasm_func(:fibonacci, [:i32], [:i32])
+    wasm_func(:factorial, [:i32], [:i32])
+    wasm_func(:gcd, [:i32, :i32], [:i32])
+    wasm_func(:power, [:i32, :i32], [:i32])
+    wasm_func(:is_prime, [:i32], [:i32])
+    wasm_func(:sum_range, [:i32, :i32], [:i32])
   end
 
   describe "Go WasmModule macro" do
diff --git a/test/wasm_module_test.exs b/test/wasm_module_test.exs
index e1c674a..be0e58f 100644
--- a/test/wasm_module_test.exs
+++ b/test/wasm_module_test.exs
@@ -5,14 +5,14 @@ defmodule Firebird.WasmModuleTest do
   defmodule TestMath do
     use Firebird.WasmModule, path: Path.join(__DIR__, "../fixtures/math.wasm")
 
-    wasm_func :add, [:i32, :i32], [:i32]
-    wasm_func :multiply, [:i32, :i32], [:i32]
-    wasm_func :fibonacci, [:i32], [:i32]
-    wasm_func :factorial, [:i32], [:i32]
-    wasm_func :gcd, [:i32, :i32], [:i32]
-    wasm_func :power, [:i32, :i32], [:i32]
-    wasm_func :is_prime, [:i32], [:i32]
-    wasm_func :sum_range, [:i32, :i32], [:i32]
+    wasm_func(:add, [:i32, :i32], [:i32])
+    wasm_func(:multiply, [:i32, :i32], [:i32])
+    wasm_func(:fibonacci, [:i32], [:i32])
+    wasm_func(:factorial, [:i32], [:i32])
+    wasm_func(:gcd, [:i32, :i32], [:i32])
+    wasm_func(:power, [:i32, :i32], [:i32])
+    wasm_func(:is_prime, [:i32], [:i32])
+    wasm_func(:sum_range, [:i32, :i32], [:i32])
   end
 
   describe "WasmModule macro" do
diff --git a/test/wasm_modules_crypto_physics_test.exs b/test/wasm_modules_crypto_physics_test.exs
index f05e6d3..d841763 100644
--- a/test/wasm_modules_crypto_physics_test.exs
+++ b/test/wasm_modules_crypto_physics_test.exs
@@ -17,7 +17,8 @@ defmodule Firebird.WasmModules.CryptoPhysicsTest do
       assert is_binary(result.wasm)
       assert is_binary(result.wat)
 
-      for func <- ~w(djb2_step fnv1a_step simple_checksum rotate_left power_of_two modular_exp is_coprime gcd) do
+      for func <-
+            ~w(djb2_step fnv1a_step simple_checksum rotate_left power_of_two modular_exp is_coprime gcd) do
         assert String.contains?(result.wat, ~s(export "#{func}")),
                "Expected #{func} to be exported"
       end
@@ -43,9 +44,11 @@ defmodule Firebird.WasmModules.CryptoPhysicsTest do
 
     test "DJB2 chained hash steps", %{wasm: w} do
       # Standard DJB2 starts with 5381
-      {:ok, [step1]} = Firebird.call(w, :djb2_step, [5381, 104])  # 'h'
+      # 'h'
+      {:ok, [step1]} = Firebird.call(w, :djb2_step, [5381, 104])
       assert step1 == 5381 * 33 + 104
-      {:ok, [step2]} = Firebird.call(w, :djb2_step, [step1, 101])  # 'e'
+      # 'e'
+      {:ok, [step2]} = Firebird.call(w, :djb2_step, [step1, 101])
       assert step2 == step1 * 33 + 101
     end
   end
@@ -87,6 +90,7 @@ defmodule Firebird.WasmModules.CryptoPhysicsTest do
     test "powers of two", %{wasm: w} do
       for {n, expected} <- [{2, 4}, {3, 8}, {4, 16}, {5, 32}, {10, 1024}] do
         {:ok, [result]} = Firebird.call(w, :power_of_two, [n])
+
         assert result == expected,
                "power_of_two(#{n}) should be #{expected}, got #{result}"
       end
@@ -178,7 +182,8 @@ defmodule Firebird.WasmModules.CryptoPhysicsTest do
       assert {:ok, result} = Compiler.compile_source(source)
       assert is_binary(result.wasm)
 
-      for func <- ~w(distance kinetic_energy gravitational_force momentum acceleration work manhattan_distance abs_diff) do
+      for func <-
+            ~w(distance kinetic_energy gravitational_force momentum acceleration work manhattan_distance abs_diff) do
         assert String.contains?(result.wat, ~s(export "#{func}")),
                "Expected #{func} to be exported"
       end
@@ -304,6 +309,7 @@ defmodule Firebird.WasmModules.CryptoPhysicsTest do
 
       for {a, b} <- pairs do
         {:ok, [wasm_result]} = Firebird.call(w, :gcd, [a, b])
+
         assert wasm_result == Integer.gcd(a, b),
                "gcd(#{a}, #{b}): WASM=#{wasm_result} Elixir=#{Integer.gcd(a, b)}"
       end
@@ -312,6 +318,7 @@ defmodule Firebird.WasmModules.CryptoPhysicsTest do
     test "power_of_two matches Elixir", %{wasm: w} do
       for n <- 0..15 do
         {:ok, [wasm_result]} = Firebird.call(w, :power_of_two, [n])
+
         assert wasm_result == Integer.pow(2, n),
                "power_of_two(#{n}): WASM=#{wasm_result} Elixir=#{Integer.pow(2, n)}"
       end
@@ -323,6 +330,7 @@ defmodule Firebird.WasmModules.CryptoPhysicsTest do
       for {base, exp, mod} <- cases do
         {:ok, [wasm_result]} = Firebird.call(w, :modular_exp, [base, exp, mod])
         expected = Integer.mod(Integer.pow(base, exp), mod)
+
         assert wasm_result == expected,
                "modular_exp(#{base}, #{exp}, #{mod}): WASM=#{wasm_result} Elixir=#{expected}"
       end
diff --git a/test/wasm_runner_advanced_test.exs b/test/wasm_runner_advanced_test.exs
index 70156c6..b96a8bb 100644
--- a/test/wasm_runner_advanced_test.exs
+++ b/test/wasm_runner_advanced_test.exs
@@ -9,37 +9,56 @@ defmodule Firebird.WasmRunnerAdvancedTest do
   @go_wasm Path.join(__DIR__, "../fixtures/go_math.wasm")
   @wat_wasm Path.join(__DIR__, "../fixtures/math.wasm")
 
-
   describe "run_concurrent/4" do
     test "runs fibonacci concurrently across multiple instances" do
       args_list = for n <- 1..20, do: [n]
-      {:ok, results} = Firebird.WasmRunner.run_concurrent(@rust_wasm, :fibonacci, args_list, concurrency: 4)
+
+      {:ok, results} =
+        Firebird.WasmRunner.run_concurrent(@rust_wasm, :fibonacci, args_list, concurrency: 4)
 
       assert length(results) == 20
-      assert Enum.at(results, 0) == 1   # fib(1)
-      assert Enum.at(results, 9) == 55  # fib(10)
-      assert Enum.at(results, 19) == 6765  # fib(20)
+      # fib(1)
+      assert Enum.at(results, 0) == 1
+      # fib(10)
+      assert Enum.at(results, 9) == 55
+      # fib(20)
+      assert Enum.at(results, 19) == 6765
     end
 
     test "runs with Go WASM (auto WASI)" do
       args_list = for n <- [5, 10, 15], do: [n]
-      {:ok, results} = Firebird.WasmRunner.run_concurrent(@go_wasm, :fibonacci, args_list, concurrency: 2, wasi: true)
+
+      {:ok, results} =
+        Firebird.WasmRunner.run_concurrent(@go_wasm, :fibonacci, args_list,
+          concurrency: 2,
+          wasi: true
+        )
+
       assert results == [5, 55, 610]
     end
 
     test "handles single concurrency" do
       args_list = [[5, 3], [10, 20], [100, 200]]
-      {:ok, results} = Firebird.WasmRunner.run_concurrent(@rust_wasm, :add, args_list, concurrency: 1)
+
+      {:ok, results} =
+        Firebird.WasmRunner.run_concurrent(@rust_wasm, :add, args_list, concurrency: 1)
+
       assert results == [8, 30, 300]
     end
 
     test "handles large batch" do
       args_list = for n <- 1..100, do: [n, n]
-      {:ok, results} = Firebird.WasmRunner.run_concurrent(@rust_wasm, :add, args_list, concurrency: 4)
+
+      {:ok, results} =
+        Firebird.WasmRunner.run_concurrent(@rust_wasm, :add, args_list, concurrency: 4)
+
       assert length(results) == 100
-      assert Enum.at(results, 0) == 2    # 1+1
-      assert Enum.at(results, 49) == 100  # 50+50
-      assert Enum.at(results, 99) == 200  # 100+100
+      # 1+1
+      assert Enum.at(results, 0) == 2
+      # 50+50
+      assert Enum.at(results, 49) == 100
+      # 100+100
+      assert Enum.at(results, 99) == 200
     end
 
     test "preserves order of results" do
@@ -62,7 +81,8 @@ defmodule Firebird.WasmRunnerAdvancedTest do
       {:ok, pid} = Firebird.load(@rust_wasm)
       {time_us, {:ok, [55]}} = Firebird.WasmRunner.timed_call(pid, :fibonacci, [10])
       assert time_us >= 0
-      assert time_us < 1_000_000  # Should take less than 1 second
+      # Should take less than 1 second
+      assert time_us < 1_000_000
       Firebird.stop(pid)
     end
 
@@ -139,36 +159,47 @@ defmodule Firebird.WasmRunnerAdvancedTest do
 
     test "raises on error" do
       {:ok, pid} = Firebird.load(@rust_wasm)
+
       assert_raise RuntimeError, fn ->
         Firebird.WasmRunner.call_single!(pid, :nonexistent, [1])
       end
+
       Firebird.stop(pid)
     end
   end
 
   describe "run_batch/3" do
     test "loads, runs, and cleans up automatically" do
-      {:ok, results} = Firebird.WasmRunner.run_batch(@rust_wasm, [
-        {:add, [1, 2]},
-        {:multiply, [3, 4]},
-        {:factorial, [5]},
-        {:fibonacci, [10]},
-        {:gcd, [48, 36]}
-      ])
+      {:ok, results} =
+        Firebird.WasmRunner.run_batch(@rust_wasm, [
+          {:add, [1, 2]},
+          {:multiply, [3, 4]},
+          {:factorial, [5]},
+          {:fibonacci, [10]},
+          {:gcd, [48, 36]}
+        ])
+
       assert results == [3, 12, 120, 55, 12]
     end
 
     test "returns error for bad function" do
-      {:ok, _results_or_error} = Firebird.WasmRunner.run_batch(@rust_wasm, [
-        {:add, [1, 2]}
-      ])
+      {:ok, _results_or_error} =
+        Firebird.WasmRunner.run_batch(@rust_wasm, [
+          {:add, [1, 2]}
+        ])
     end
 
     test "works with Go WASM" do
-      {:ok, results} = Firebird.WasmRunner.run_batch(@go_wasm, [
-        {:add, [10, 20]},
-        {:multiply, [5, 5]}
-      ], wasi: true)
+      {:ok, results} =
+        Firebird.WasmRunner.run_batch(
+          @go_wasm,
+          [
+            {:add, [10, 20]},
+            {:multiply, [5, 5]}
+          ],
+          wasi: true
+        )
+
       assert results == [30, 25]
     end
   end
@@ -184,17 +215,22 @@ defmodule Firebird.WasmRunnerAdvancedTest do
 
     test "rejects wrong arity" do
       {:ok, pid} = Firebird.load(@rust_wasm)
+
       assert {:error, {:arity_mismatch, :add, [expected: 2, got: 1]}} =
-        Firebird.WasmRunner.validate_call(pid, :add, [1])
+               Firebird.WasmRunner.validate_call(pid, :add, [1])
+
       assert {:error, {:arity_mismatch, :add, [expected: 2, got: 3]}} =
-        Firebird.WasmRunner.validate_call(pid, :add, [1, 2, 3])
+               Firebird.WasmRunner.validate_call(pid, :add, [1, 2, 3])
+
       Firebird.stop(pid)
     end
 
     test "rejects unknown functions" do
       {:ok, pid} = Firebird.load(@rust_wasm)
+
       assert {:error, {:unknown_function, :nonexistent}} =
-        Firebird.WasmRunner.validate_call(pid, :nonexistent, [])
+               Firebird.WasmRunner.validate_call(pid, :nonexistent, [])
+
       Firebird.stop(pid)
     end
 
@@ -207,23 +243,28 @@ defmodule Firebird.WasmRunnerAdvancedTest do
 
   describe "compare/3" do
     test "compares results across modules" do
-      {:ok, results} = Firebird.WasmRunner.compare(
-        [@rust_wasm, {@go_wasm, [wasi: true]}, @wat_wasm],
-        :add,
-        [5, 3]
-      )
+      {:ok, results} =
+        Firebird.WasmRunner.compare(
+          [@rust_wasm, {@go_wasm, [wasi: true]}, @wat_wasm],
+          :add,
+          [5, 3]
+        )
+
       assert length(results) == 3
+
       for {_source, result} <- results do
         assert result == {:ok, [8]}
       end
     end
 
     test "compares fibonacci" do
-      {:ok, results} = Firebird.WasmRunner.compare(
-        [@rust_wasm, @wat_wasm],
-        :fibonacci,
-        [20]
-      )
+      {:ok, results} =
+        Firebird.WasmRunner.compare(
+          [@rust_wasm, @wat_wasm],
+          :fibonacci,
+          [20]
+        )
+
       for {_source, result} <- results do
         assert result == {:ok, [6765]}
       end
diff --git a/test/wasm_runner_benchmark_test.exs b/test/wasm_runner_benchmark_test.exs
index b9c1e3a..c1893ed 100644
--- a/test/wasm_runner_benchmark_test.exs
+++ b/test/wasm_runner_benchmark_test.exs
@@ -27,9 +27,8 @@ defmodule Firebird.WasmRunnerBenchmarkTest do
     end
 
     test "benchmarks with custom iterations and warmup" do
-      result = Firebird.WasmRunner.benchmark(@math_wasm, :add, [[1, 2]],
-        iterations: 20, warmup: 5
-      )
+      result =
+        Firebird.WasmRunner.benchmark(@math_wasm, :add, [[1, 2]], iterations: 20, warmup: 5)
 
       assert result.iterations == 20
       assert result.total_calls == 20
@@ -37,9 +36,8 @@ defmodule Firebird.WasmRunnerBenchmarkTest do
     end
 
     test "benchmarks a Go WASM function (WASI auto-detected)" do
-      result = Firebird.WasmRunner.benchmark(@go_math_wasm, :add, [[5, 3]],
-        iterations: 10, warmup: 2
-      )
+      result =
+        Firebird.WasmRunner.benchmark(@go_math_wasm, :add, [[5, 3]], iterations: 10, warmup: 2)
 
       assert result.function == :add
       assert result.iterations == 10
@@ -50,9 +48,7 @@ defmodule Firebird.WasmRunnerBenchmarkTest do
     test "benchmarks with a precompiled module" do
       {:ok, compiled} = Firebird.WasmRunner.precompile(@math_wasm)
 
-      result = Firebird.WasmRunner.benchmark(compiled, :add, [[5, 3]],
-        iterations: 20, warmup: 3
-      )
+      result = Firebird.WasmRunner.benchmark(compiled, :add, [[5, 3]], iterations: 20, warmup: 3)
 
       assert result.function == :add
       assert result.avg_us > 0
@@ -63,18 +59,15 @@ defmodule Firebird.WasmRunnerBenchmarkTest do
     test "benchmarks with multiple arg sets per iteration" do
       args = for n <- 1..5, do: [n, n * 2]
 
-      result = Firebird.WasmRunner.benchmark(@math_wasm, :add, args,
-        iterations: 10, warmup: 2
-      )
+      result = Firebird.WasmRunner.benchmark(@math_wasm, :add, args, iterations: 10, warmup: 2)
 
       assert result.calls_per_iteration == 5
       assert result.total_calls == 50
     end
 
     test "single arg set returns throughput" do
-      result = Firebird.WasmRunner.benchmark(@math_wasm, :multiply, [[4, 7]],
-        iterations: 50, warmup: 5
-      )
+      result =
+        Firebird.WasmRunner.benchmark(@math_wasm, :multiply, [[4, 7]], iterations: 50, warmup: 5)
 
       assert result.throughput_ops_sec > 0
       assert result.calls_per_iteration == 1
@@ -85,11 +78,15 @@ defmodule Firebird.WasmRunnerBenchmarkTest do
 
   describe "benchmark_compare/5" do
     test "compares WASM vs BEAM for simple arithmetic" do
-      result = Firebird.WasmRunner.benchmark_compare(
-        @math_wasm, :add, [[5, 3], [10, 20]],
-        beam_fun: &Kernel.+/2,
-        iterations: 20, warmup: 5
-      )
+      result =
+        Firebird.WasmRunner.benchmark_compare(
+          @math_wasm,
+          :add,
+          [[5, 3], [10, 20]],
+          beam_fun: &Kernel.+/2,
+          iterations: 20,
+          warmup: 5
+        )
 
       assert result.function == :add
       assert result.iterations == 20
@@ -112,11 +109,15 @@ defmodule Firebird.WasmRunnerBenchmarkTest do
     end
 
     test "compares with Go WASM module" do
-      result = Firebird.WasmRunner.benchmark_compare(
-        @go_math_wasm, :add, [[5, 3]],
-        beam_fun: &Kernel.+/2,
-        iterations: 10, warmup: 2
-      )
+      result =
+        Firebird.WasmRunner.benchmark_compare(
+          @go_math_wasm,
+          :add,
+          [[5, 3]],
+          beam_fun: &Kernel.+/2,
+          iterations: 10,
+          warmup: 2
+        )
 
       assert result.function == :add
       assert is_number(result.speedup)
@@ -125,11 +126,15 @@ defmodule Firebird.WasmRunnerBenchmarkTest do
     test "compares with precompiled module" do
       {:ok, compiled} = Firebird.WasmRunner.precompile(@math_wasm)
 
-      result = Firebird.WasmRunner.benchmark_compare(
-        compiled, :multiply, [[4, 7]],
-        beam_fun: &Kernel.*/2,
-        iterations: 15, warmup: 3
-      )
+      result =
+        Firebird.WasmRunner.benchmark_compare(
+          compiled,
+          :multiply,
+          [[4, 7]],
+          beam_fun: &Kernel.*/2,
+          iterations: 15,
+          warmup: 3
+        )
 
       assert result.function == :multiply
       assert is_number(result.speedup)
@@ -140,11 +145,15 @@ defmodule Firebird.WasmRunnerBenchmarkTest do
     test "compares with anonymous function" do
       beam_add = fn a, b -> a + b end
 
-      result = Firebird.WasmRunner.benchmark_compare(
-        @math_wasm, :add, [[5, 3]],
-        beam_fun: beam_add,
-        iterations: 10, warmup: 2
-      )
+      result =
+        Firebird.WasmRunner.benchmark_compare(
+          @math_wasm,
+          :add,
+          [[5, 3]],
+          beam_fun: beam_add,
+          iterations: 10,
+          warmup: 2
+        )
 
       assert is_number(result.speedup)
     end
@@ -152,11 +161,15 @@ defmodule Firebird.WasmRunnerBenchmarkTest do
     test "reports correct calls_per_iteration" do
       args = for n <- [1, 5, 10], do: [n, n]
 
-      result = Firebird.WasmRunner.benchmark_compare(
-        @math_wasm, :add, args,
-        beam_fun: &Kernel.+/2,
-        iterations: 10, warmup: 2
-      )
+      result =
+        Firebird.WasmRunner.benchmark_compare(
+          @math_wasm,
+          :add,
+          args,
+          beam_fun: &Kernel.+/2,
+          iterations: 10,
+          warmup: 2
+        )
 
       assert result.calls_per_iteration == 3
     end
@@ -166,9 +179,8 @@ defmodule Firebird.WasmRunnerBenchmarkTest do
 
   describe "format_benchmark/1" do
     test "formats single benchmark result" do
-      result = Firebird.WasmRunner.benchmark(@math_wasm, :add, [[5, 3]],
-        iterations: 10, warmup: 2
-      )
+      result =
+        Firebird.WasmRunner.benchmark(@math_wasm, :add, [[5, 3]], iterations: 10, warmup: 2)
 
       formatted = Firebird.WasmRunner.format_benchmark(result)
 
@@ -182,11 +194,15 @@ defmodule Firebird.WasmRunnerBenchmarkTest do
     end
 
     test "formats comparison benchmark result" do
-      result = Firebird.WasmRunner.benchmark_compare(
-        @math_wasm, :add, [[5, 3]],
-        beam_fun: &Kernel.+/2,
-        iterations: 10, warmup: 2
-      )
+      result =
+        Firebird.WasmRunner.benchmark_compare(
+          @math_wasm,
+          :add,
+          [[5, 3]],
+          beam_fun: &Kernel.+/2,
+          iterations: 10,
+          warmup: 2
+        )
 
       formatted = Firebird.WasmRunner.format_benchmark(result)
 
@@ -199,9 +215,8 @@ defmodule Firebird.WasmRunnerBenchmarkTest do
     end
 
     test "formats with box-drawing characters" do
-      result = Firebird.WasmRunner.benchmark(@math_wasm, :add, [[1, 2]],
-        iterations: 10, warmup: 2
-      )
+      result =
+        Firebird.WasmRunner.benchmark(@math_wasm, :add, [[1, 2]], iterations: 10, warmup: 2)
 
       formatted = Firebird.WasmRunner.format_benchmark(result)
       assert formatted =~ "╔"
@@ -214,9 +229,8 @@ defmodule Firebird.WasmRunnerBenchmarkTest do
 
   describe "statistics correctness" do
     test "p95 >= median and p99 >= p95" do
-      result = Firebird.WasmRunner.benchmark(@math_wasm, :add, [[1, 2]],
-        iterations: 50, warmup: 5
-      )
+      result =
+        Firebird.WasmRunner.benchmark(@math_wasm, :add, [[1, 2]], iterations: 50, warmup: 5)
 
       assert result.p95_us >= result.median_us
       assert result.p99_us >= result.p95_us
@@ -225,9 +239,8 @@ defmodule Firebird.WasmRunnerBenchmarkTest do
     end
 
     test "stddev is non-negative" do
-      result = Firebird.WasmRunner.benchmark(@math_wasm, :add, [[1, 2]],
-        iterations: 30, warmup: 5
-      )
+      result =
+        Firebird.WasmRunner.benchmark(@math_wasm, :add, [[1, 2]], iterations: 30, warmup: 5)
 
       assert result.stddev_us >= 0
     end
diff --git a/test/wasm_runner_cached_test.exs b/test/wasm_runner_cached_test.exs
index c09758c..0d4149f 100644
--- a/test/wasm_runner_cached_test.exs
+++ b/test/wasm_runner_cached_test.exs
@@ -123,14 +123,16 @@ defmodule Firebird.WasmRunner.CachedTest do
   describe "with_instance/3 with cache: true" do
     test "uses cached loading for with_instance" do
       # First call compiles + caches
-      {:ok, 8} = Firebird.WasmRunner.with_instance("fixtures/math.wasm", [cache: true], fn pid ->
-        Firebird.WasmRunner.call_single!(pid, :add, [5, 3])
-      end)
+      {:ok, 8} =
+        Firebird.WasmRunner.with_instance("fixtures/math.wasm", [cache: true], fn pid ->
+          Firebird.WasmRunner.call_single!(pid, :add, [5, 3])
+        end)
 
       # Second call uses cache
-      {:ok, 8} = Firebird.WasmRunner.with_instance("fixtures/math.wasm", [cache: true], fn pid ->
-        Firebird.WasmRunner.call_single!(pid, :add, [5, 3])
-      end)
+      {:ok, 8} =
+        Firebird.WasmRunner.with_instance("fixtures/math.wasm", [cache: true], fn pid ->
+          Firebird.WasmRunner.call_single!(pid, :add, [5, 3])
+        end)
 
       stats = Firebird.ModuleCache.stats()
       assert stats.hits == 1
@@ -140,18 +142,28 @@ defmodule Firebird.WasmRunner.CachedTest do
 
   describe "run_batch/3 with cache: true" do
     test "uses cached loading for batch operations" do
-      {:ok, results} = Firebird.WasmRunner.run_batch("fixtures/math.wasm", [
-        {:add, [5, 3]},
-        {:add, [10, 20]}
-      ], cache: true)
+      {:ok, results} =
+        Firebird.WasmRunner.run_batch(
+          "fixtures/math.wasm",
+          [
+            {:add, [5, 3]},
+            {:add, [10, 20]}
+          ],
+          cache: true
+        )
 
       assert results == [8, 30]
 
       # Second batch uses cache
-      {:ok, results2} = Firebird.WasmRunner.run_batch("fixtures/math.wasm", [
-        {:add, [1, 2]},
-        {:add, [3, 4]}
-      ], cache: true)
+      {:ok, results2} =
+        Firebird.WasmRunner.run_batch(
+          "fixtures/math.wasm",
+          [
+            {:add, [1, 2]},
+            {:add, [3, 4]}
+          ],
+          cache: true
+        )
 
       assert results2 == [3, 7]
 
@@ -162,10 +174,14 @@ defmodule Firebird.WasmRunner.CachedTest do
 
   describe "with_memory/3 with cache: true" do
     test "uses cached loading for memory operations" do
-      {:ok, result} = Firebird.WasmRunner.with_memory(
-        "fixtures/math.wasm", [cache: true], fn pid, _mem ->
-          Firebird.WasmRunner.call_single!(pid, :add, [5, 3])
-        end)
+      {:ok, result} =
+        Firebird.WasmRunner.with_memory(
+          "fixtures/math.wasm",
+          [cache: true],
+          fn pid, _mem ->
+            Firebird.WasmRunner.call_single!(pid, :add, [5, 3])
+          end
+        )
 
       assert result == 8
 
@@ -192,21 +208,25 @@ defmodule Firebird.WasmRunner.CachedTest do
   describe "cached loading performance" do
     test "cache hit is faster than cache miss" do
       # Cold: compile + cache
-      {cold_us, {:ok, pid1}} = :timer.tc(fn ->
-        Firebird.WasmRunner.start_cached("fixtures/math.wasm")
-      end)
+      {cold_us, {:ok, pid1}} =
+        :timer.tc(fn ->
+          Firebird.WasmRunner.start_cached("fixtures/math.wasm")
+        end)
+
       Firebird.stop(pid1)
 
       # Warm: instantiate from cache
-      {warm_us, {:ok, pid2}} = :timer.tc(fn ->
-        Firebird.WasmRunner.start_cached("fixtures/math.wasm")
-      end)
+      {warm_us, {:ok, pid2}} =
+        :timer.tc(fn ->
+          Firebird.WasmRunner.start_cached("fixtures/math.wasm")
+        end)
+
       Firebird.stop(pid2)
 
       # Cache hit should be noticeably faster (at least 2x for real modules)
       # We use a generous threshold since small fixtures may not show huge gains
       assert warm_us <= cold_us * 2,
-        "Expected cache hit (#{warm_us}μs) to be faster than miss (#{cold_us}μs)"
+             "Expected cache hit (#{warm_us}μs) to be faster than miss (#{cold_us}μs)"
 
       stats = Firebird.ModuleCache.stats()
       assert stats.hits == 1
@@ -215,10 +235,11 @@ defmodule Firebird.WasmRunner.CachedTest do
 
     test "multiple cached instances for Go WASM" do
       # Compile once, instantiate 5 times from cache
-      pids = for _ <- 1..5 do
-        {:ok, pid} = Firebird.WasmRunner.start_cached("fixtures/go_algorithms.wasm")
-        pid
-      end
+      pids =
+        for _ <- 1..5 do
+          {:ok, pid} = Firebird.WasmRunner.start_cached("fixtures/go_algorithms.wasm")
+          pid
+        end
 
       # All should work
       for pid <- pids do
@@ -229,7 +250,8 @@ defmodule Firebird.WasmRunner.CachedTest do
 
       stats = Firebird.ModuleCache.stats()
       assert stats.misses == 1
-      assert stats.hits == 4  # 1 miss + 4 hits = 5 total
+      # 1 miss + 4 hits = 5 total
+      assert stats.hits == 4
     end
   end
 end
diff --git a/test/wasm_runner_collection_test.exs b/test/wasm_runner_collection_test.exs
new file mode 100644
index 0000000..83cdf48
--- /dev/null
+++ b/test/wasm_runner_collection_test.exs
@@ -0,0 +1,186 @@
+defmodule Firebird.WasmRunner.CollectionTest do
+  use ExUnit.Case, async: false
+
+  alias Firebird.WasmRunner
+
+  @math_wasm "fixtures/math.wasm"
+
+  describe "map/4" do
+    test "maps a single-arg function over a range" do
+      assert {:ok, [1, 1, 2, 3, 5]} = WasmRunner.map(@math_wasm, :fibonacci, 1..5)
+    end
+
+    test "maps a two-arg function over tuples" do
+      assert {:ok, [3, 7, 11]} = WasmRunner.map(@math_wasm, :add, [{1, 2}, {3, 4}, {5, 6}])
+    end
+
+    test "maps over explicit arg lists" do
+      assert {:ok, [3, 7]} = WasmRunner.map(@math_wasm, :add, [[1, 2], [3, 4]])
+    end
+
+    test "maps over empty collection" do
+      assert {:ok, []} = WasmRunner.map(@math_wasm, :fibonacci, [])
+    end
+
+    test "handles single element" do
+      assert {:ok, [55]} = WasmRunner.map(@math_wasm, :fibonacci, [10])
+    end
+
+    test "works with precompiled module" do
+      {:ok, compiled} = WasmRunner.precompile(@math_wasm)
+      assert {:ok, [6, 20]} = WasmRunner.map(compiled, :multiply, [{2, 3}, {4, 5}])
+    end
+
+    test "returns error for nonexistent file" do
+      assert {:error, _} = WasmRunner.map("nonexistent.wasm", :add, [{1, 2}])
+    end
+
+    test "returns error for nonexistent function" do
+      assert {:error, _} = WasmRunner.map(@math_wasm, :nonexistent, [1, 2, 3])
+    end
+  end
+
+  describe "map!/4" do
+    test "returns unwrapped results" do
+      assert [1, 1, 2, 3, 5] = WasmRunner.map!(@math_wasm, :fibonacci, 1..5)
+    end
+
+    test "raises on error" do
+      assert_raise RuntimeError, ~r/WASM map failed/, fn ->
+        WasmRunner.map!("nonexistent.wasm", :add, [{1, 2}])
+      end
+    end
+  end
+
+  describe "reduce/5" do
+    test "sums a list using WASM add" do
+      assert {:ok, 15} = WasmRunner.reduce(@math_wasm, :add, [1, 2, 3, 4, 5], 0)
+    end
+
+    test "multiplies a list using WASM multiply" do
+      assert {:ok, 120} = WasmRunner.reduce(@math_wasm, :multiply, [1, 2, 3, 4, 5], 1)
+    end
+
+    test "reduces single element" do
+      assert {:ok, 42} = WasmRunner.reduce(@math_wasm, :add, [42], 0)
+    end
+
+    test "reduces empty list returns initial" do
+      assert {:ok, 0} = WasmRunner.reduce(@math_wasm, :add, [], 0)
+    end
+
+    test "works with precompiled module" do
+      {:ok, compiled} = WasmRunner.precompile(@math_wasm)
+      assert {:ok, 10} = WasmRunner.reduce(compiled, :add, [1, 2, 3, 4], 0)
+    end
+
+    test "returns error for nonexistent file" do
+      assert {:error, _} = WasmRunner.reduce("nonexistent.wasm", :add, [1, 2], 0)
+    end
+  end
+
+  describe "reduce!/5" do
+    test "returns unwrapped result" do
+      assert 15 = WasmRunner.reduce!(@math_wasm, :add, [1, 2, 3, 4, 5], 0)
+    end
+
+    test "raises on error" do
+      assert_raise RuntimeError, ~r/WASM reduce failed/, fn ->
+        WasmRunner.reduce!("nonexistent.wasm", :add, [1, 2], 0)
+      end
+    end
+  end
+
+  describe "filter/4" do
+    test "filters with is_prime predicate" do
+      assert {:ok, [2, 3, 5, 7]} = WasmRunner.filter(@math_wasm, :is_prime, 1..10)
+    end
+
+    test "filter over empty collection" do
+      assert {:ok, []} = WasmRunner.filter(@math_wasm, :is_prime, [])
+    end
+
+    test "filter keeps all when all truthy" do
+      assert {:ok, [2, 3, 5]} = WasmRunner.filter(@math_wasm, :is_prime, [2, 3, 5])
+    end
+
+    test "filter removes all when all falsy" do
+      assert {:ok, []} = WasmRunner.filter(@math_wasm, :is_prime, [1, 4, 6])
+    end
+
+    test "filter preserves original elements for tuples" do
+      # greater_than not available, use add with tuples to verify tuple round-trip
+      # is_prime takes 1 arg, so we filter single values
+      assert {:ok, [2, 3]} = WasmRunner.filter(@math_wasm, :is_prime, [1, 2, 3, 4])
+    end
+
+    test "works with precompiled module" do
+      {:ok, compiled} = WasmRunner.precompile(@math_wasm)
+      assert {:ok, [2, 3, 5, 7]} = WasmRunner.filter(compiled, :is_prime, 1..10)
+    end
+
+    test "returns error for nonexistent file" do
+      assert {:error, _} = WasmRunner.filter("nonexistent.wasm", :is_prime, [1, 2])
+    end
+  end
+
+  describe "filter!/4" do
+    test "returns unwrapped results" do
+      assert [2, 3, 5, 7] = WasmRunner.filter!(@math_wasm, :is_prime, 1..10)
+    end
+
+    test "raises on error" do
+      assert_raise RuntimeError, ~r/WASM filter failed/, fn ->
+        WasmRunner.filter!("nonexistent.wasm", :is_prime, [1, 2])
+      end
+    end
+  end
+
+  describe "each/4" do
+    test "returns :ok on success" do
+      assert :ok = WasmRunner.each(@math_wasm, :fibonacci, 1..5)
+    end
+
+    test "returns :ok for empty collection" do
+      assert :ok = WasmRunner.each(@math_wasm, :fibonacci, [])
+    end
+
+    test "returns error for nonexistent file" do
+      assert {:error, _} = WasmRunner.each("nonexistent.wasm", :add, [{1, 2}])
+    end
+  end
+
+  describe "collection helpers - instance cleanup" do
+    test "map cleans up instance after success" do
+      before = length(Process.list())
+      WasmRunner.map(@math_wasm, :fibonacci, 1..5)
+      Process.sleep(10)
+      after_count = length(Process.list())
+      assert after_count - before <= 2
+    end
+
+    test "reduce cleans up instance after success" do
+      before = length(Process.list())
+      WasmRunner.reduce(@math_wasm, :add, [1, 2, 3], 0)
+      Process.sleep(10)
+      after_count = length(Process.list())
+      assert after_count - before <= 2
+    end
+
+    test "filter cleans up instance after success" do
+      before = length(Process.list())
+      WasmRunner.filter(@math_wasm, :is_prime, 1..10)
+      Process.sleep(10)
+      after_count = length(Process.list())
+      assert after_count - before <= 2
+    end
+
+    test "map cleans up instance after error" do
+      before = length(Process.list())
+      WasmRunner.map(@math_wasm, :nonexistent, [1, 2, 3])
+      Process.sleep(10)
+      after_count = length(Process.list())
+      assert after_count - before <= 2
+    end
+  end
+end
diff --git a/test/wasm_runner_comprehensive_test.exs b/test/wasm_runner_comprehensive_test.exs
index c777c21..d0e4dfd 100644
--- a/test/wasm_runner_comprehensive_test.exs
+++ b/test/wasm_runner_comprehensive_test.exs
@@ -122,7 +122,7 @@ defmodule Firebird.WasmRunnerComprehensiveTest do
       assert {:ok, [1]} = Firebird.call(pid, :is_prime, [7])
       assert {:ok, [0]} = Firebird.call(pid, :is_prime, [4])
       assert {:ok, [0]} = Firebird.call(pid, :is_prime, [1])
-      assert {:ok, [1]} = Firebird.call(pid, :is_prime, [104729])
+      assert {:ok, [1]} = Firebird.call(pid, :is_prime, [104_729])
     end
 
     test "sum_range", %{instance: pid} do
@@ -143,19 +143,21 @@ defmodule Firebird.WasmRunnerComprehensiveTest do
     end
 
     test "call_many executes multiple functions", %{instance: pid} do
-      assert {:ok, [[8], [15], [55]]} = Firebird.call_many(pid, [
-        {:add, [5, 3]},
-        {:multiply, [3, 5]},
-        {:fibonacci, [10]}
-      ])
+      assert {:ok, [[8], [15], [55]]} =
+               Firebird.call_many(pid, [
+                 {:add, [5, 3]},
+                 {:multiply, [3, 5]},
+                 {:fibonacci, [10]}
+               ])
     end
 
     test "call_many stops on first error", %{instance: pid} do
-      assert {:error, _} = Firebird.call_many(pid, [
-        {:add, [5, 3]},
-        {:nonexistent, [1]},
-        {:multiply, [3, 5]}
-      ])
+      assert {:error, _} =
+               Firebird.call_many(pid, [
+                 {:add, [5, 3]},
+                 {:nonexistent, [1]},
+                 {:multiply, [3, 5]}
+               ])
     end
   end
 
@@ -217,7 +219,8 @@ defmodule Firebird.WasmRunnerComprehensiveTest do
     test "memory_size returns positive value", %{instance: pid} do
       {:ok, size} = Firebird.memory_size(pid)
       assert size > 0
-      assert rem(size, 65536) == 0  # multiple of page size
+      # multiple of page size
+      assert rem(size, 65536) == 0
     end
 
     test "write and read memory", %{instance: pid} do
@@ -323,18 +326,22 @@ defmodule Firebird.WasmRunnerComprehensiveTest do
     end
 
     test "with_instance/3 executes block and cleans up" do
-      {:ok, result} = Firebird.with_instance(@rust_wasm, fn instance ->
-        {:ok, [a]} = Firebird.call(instance, :add, [5, 3])
-        {:ok, [b]} = Firebird.call(instance, :multiply, [a, 2])
-        b
-      end)
+      {:ok, result} =
+        Firebird.with_instance(@rust_wasm, fn instance ->
+          {:ok, [a]} = Firebird.call(instance, :add, [5, 3])
+          {:ok, [b]} = Firebird.call(instance, :multiply, [a, 2])
+          b
+        end)
+
       assert result == 16
     end
 
     test "with_instance/3 cleans up on error" do
-      result = Firebird.with_instance("/no/file.wasm", fn _instance ->
-        :should_not_reach
-      end)
+      result =
+        Firebird.with_instance("/no/file.wasm", fn _instance ->
+          :should_not_reach
+        end)
+
       assert {:error, _} = result
     end
 
@@ -464,12 +471,15 @@ defmodule Firebird.WasmRunnerComprehensiveTest do
     test "reverse_bits", %{instance: pid} do
       assert {:ok, [result]} = Firebird.call(pid, :reverse_bits, [1])
       # 1 = 0x00000001, reversed = 0x80000000
-      assert result == -2147483648 or result == 2147483648
+      assert result == -2_147_483_648 or result == 2_147_483_648
     end
 
     test "sort_i32 via memory", %{instance: pid} do
       # Write unsorted i32 array: [5, 3, 1, 4, 2]
-      data = <<5::little-signed-32, 3::little-signed-32, 1::little-signed-32, 4::little-signed-32, 2::little-signed-32>>
+      data =
+        <<5::little-signed-32, 3::little-signed-32, 1::little-signed-32, 4::little-signed-32,
+          2::little-signed-32>>
+
       :ok = Firebird.write_memory(pid, 0, data)
 
       # Sort in place
@@ -483,7 +493,10 @@ defmodule Firebird.WasmRunnerComprehensiveTest do
 
     test "binary_search via memory", %{instance: pid} do
       # Write sorted i32 array: [10, 20, 30, 40, 50]
-      data = <<10::little-signed-32, 20::little-signed-32, 30::little-signed-32, 40::little-signed-32, 50::little-signed-32>>
+      data =
+        <<10::little-signed-32, 20::little-signed-32, 30::little-signed-32, 40::little-signed-32,
+          50::little-signed-32>>
+
       :ok = Firebird.write_memory(pid, 0, data)
 
       assert {:ok, [2]} = Firebird.call(pid, :binary_search, [0, 5, 30])
@@ -504,31 +517,41 @@ defmodule Firebird.WasmRunnerComprehensiveTest do
 
     test "collatz_steps matches Rust", %{instance: pid} do
       {:ok, rust} = Firebird.load(@algo_wasm)
+
       for n <- [1, 7, 27, 100] do
         {:ok, [go_result]} = Firebird.call(pid, :collatz_steps, [n])
         {:ok, [rust_result]} = Firebird.call(rust, :collatz_steps, [n])
-        assert go_result == rust_result, "collatz_steps(#{n}): Go=#{go_result} Rust=#{rust_result}"
+
+        assert go_result == rust_result,
+               "collatz_steps(#{n}): Go=#{go_result} Rust=#{rust_result}"
       end
+
       Firebird.stop(rust)
     end
 
     test "is_palindrome matches Rust", %{instance: pid} do
       {:ok, rust} = Firebird.load(@algo_wasm)
+
       for n <- [0, 7, 121, 12321, 12345] do
         {:ok, [go_result]} = Firebird.call(pid, :is_palindrome, [n])
         {:ok, [rust_result]} = Firebird.call(rust, :is_palindrome, [n])
-        assert go_result == rust_result, "is_palindrome(#{n}): Go=#{go_result} Rust=#{rust_result}"
+
+        assert go_result == rust_result,
+               "is_palindrome(#{n}): Go=#{go_result} Rust=#{rust_result}"
       end
+
       Firebird.stop(rust)
     end
 
     test "popcount matches Rust", %{instance: pid} do
       {:ok, rust} = Firebird.load(@algo_wasm)
+
       for n <- [0, 1, 7, 255, 1024] do
         {:ok, [go_result]} = Firebird.call(pid, :popcount, [n])
         {:ok, [rust_result]} = Firebird.call(rust, :popcount, [n])
         assert go_result == rust_result
       end
+
       Firebird.stop(rust)
     end
   end
@@ -541,32 +564,33 @@ defmodule Firebird.WasmRunnerComprehensiveTest do
       {:ok, rust} = Firebird.load(@rust_wasm)
 
       for {func, args} <- [
-        {:add, [42, 58]},
-        {:add, [0, 0]},
-        {:add, [-10, 10]},
-        {:multiply, [7, 8]},
-        {:multiply, [0, 100]},
-        {:fibonacci, [0]},
-        {:fibonacci, [1]},
-        {:fibonacci, [10]},
-        {:fibonacci, [20]},
-        {:factorial, [0]},
-        {:factorial, [5]},
-        {:factorial, [10]},
-        {:gcd, [48, 18]},
-        {:gcd, [7, 13]},
-        {:power, [2, 10]},
-        {:power, [3, 5]},
-        {:is_prime, [2]},
-        {:is_prime, [97]},
-        {:is_prime, [100]},
-        {:sum_range, [1, 100]},
-        {:sum_range, [1, 1000]}
-      ] do
+            {:add, [42, 58]},
+            {:add, [0, 0]},
+            {:add, [-10, 10]},
+            {:multiply, [7, 8]},
+            {:multiply, [0, 100]},
+            {:fibonacci, [0]},
+            {:fibonacci, [1]},
+            {:fibonacci, [10]},
+            {:fibonacci, [20]},
+            {:factorial, [0]},
+            {:factorial, [5]},
+            {:factorial, [10]},
+            {:gcd, [48, 18]},
+            {:gcd, [7, 13]},
+            {:power, [2, 10]},
+            {:power, [3, 5]},
+            {:is_prime, [2]},
+            {:is_prime, [97]},
+            {:is_prime, [100]},
+            {:sum_range, [1, 100]},
+            {:sum_range, [1, 1000]}
+          ] do
         {:ok, go_result} = Firebird.call(go, func, args)
         {:ok, rust_result} = Firebird.call(rust, func, args)
+
         assert go_result == rust_result,
-          "#{func}(#{inspect(args)}): Go=#{inspect(go_result)} Rust=#{inspect(rust_result)}"
+               "#{func}(#{inspect(args)}): Go=#{inspect(go_result)} Rust=#{inspect(rust_result)}"
       end
 
       Firebird.stop(go)
@@ -587,12 +611,16 @@ defmodule Firebird.WasmRunnerComprehensiveTest do
     test "pool handles concurrent calls" do
       {:ok, pool} = Firebird.start_pool(wasm: @rust_wasm, size: 4)
 
-      results = 1..20
-      |> Task.async_stream(fn i ->
-        {:ok, [r]} = Firebird.pool_call(pool, :add, [i, i])
-        r
-      end, max_concurrency: 4)
-      |> Enum.map(fn {:ok, r} -> r end)
+      results =
+        1..20
+        |> Task.async_stream(
+          fn i ->
+            {:ok, [r]} = Firebird.pool_call(pool, :add, [i, i])
+            r
+          end,
+          max_concurrency: 4
+        )
+        |> Enum.map(fn {:ok, r} -> r end)
 
       assert length(results) == 20
       assert Enum.all?(results, &is_integer/1)
diff --git a/test/wasm_runner_edge_cases_test.exs b/test/wasm_runner_edge_cases_test.exs
index be0b917..5eb55b3 100644
--- a/test/wasm_runner_edge_cases_test.exs
+++ b/test/wasm_runner_edge_cases_test.exs
@@ -79,12 +79,12 @@ defmodule WasmRunnerEdgeCasesTest do
 
     test "unknown function returns error", %{wasm: w} do
       assert {:error, {:unknown_function, :nonexistent}} =
-        Firebird.WasmRunner.validate_call(w, :nonexistent, [1])
+               Firebird.WasmRunner.validate_call(w, :nonexistent, [1])
     end
 
     test "wrong arity returns error", %{wasm: w} do
       assert {:error, {:arity_mismatch, :add, expected: 2, got: 3}} =
-        Firebird.WasmRunner.validate_call(w, :add, [1, 2, 3])
+               Firebird.WasmRunner.validate_call(w, :add, [1, 2, 3])
     end
 
     test "accepts string function names", %{wasm: w} do
@@ -108,20 +108,23 @@ defmodule WasmRunnerEdgeCasesTest do
 
   describe "run_batch/3" do
     test "runs batch of calls on WAT module" do
-      {:ok, results} = Firebird.WasmRunner.run_batch("fixtures/math.wasm", [
-        {:add, [5, 3]},
-        {:multiply, [4, 7]},
-        {:fibonacci, [10]}
-      ])
+      {:ok, results} =
+        Firebird.WasmRunner.run_batch("fixtures/math.wasm", [
+          {:add, [5, 3]},
+          {:multiply, [4, 7]},
+          {:fibonacci, [10]}
+        ])
 
       assert results == [8, 28, 55]
     end
 
     test "runs batch on Go module with auto-WASI" do
-      {:ok, results} = Firebird.WasmRunner.run_batch(
-        "fixtures/go_math.wasm",
-        [{:add, [10, 20]}, {:multiply, [3, 4]}]
-      )
+      {:ok, results} =
+        Firebird.WasmRunner.run_batch(
+          "fixtures/go_math.wasm",
+          [{:add, [10, 20]}, {:multiply, [3, 4]}]
+        )
+
       assert results == [30, 12]
     end
 
@@ -131,20 +134,22 @@ defmodule WasmRunnerEdgeCasesTest do
     end
 
     test "batch with error returns error" do
-      {:error, _} = Firebird.WasmRunner.run_batch("fixtures/math.wasm", [
-        {:add, [1, 2]},
-        {:nonexistent, [1]}
-      ])
+      {:error, _} =
+        Firebird.WasmRunner.run_batch("fixtures/math.wasm", [
+          {:add, [1, 2]},
+          {:nonexistent, [1]}
+        ])
     end
   end
 
   describe "compare/3" do
     test "compares results across modules" do
-      {:ok, results} = Firebird.WasmRunner.compare(
-        ["fixtures/math.wasm", {"fixtures/go_math.wasm", [wasi: true]}],
-        :add,
-        [5, 3]
-      )
+      {:ok, results} =
+        Firebird.WasmRunner.compare(
+          ["fixtures/math.wasm", {"fixtures/go_math.wasm", [wasi: true]}],
+          :add,
+          [5, 3]
+        )
 
       assert length(results) == 2
       # Both should return {:ok, [8]} for add(5, 3)
diff --git a/test/wasm_runner_memory_test.exs b/test/wasm_runner_memory_test.exs
index fcf45d9..70cdaf9 100644
--- a/test/wasm_runner_memory_test.exs
+++ b/test/wasm_runner_memory_test.exs
@@ -12,23 +12,25 @@ defmodule Firebird.WasmRunnerMemoryTest do
 
   describe "with_memory/3" do
     test "provides instance and allocator to callback" do
-      {:ok, result} = WasmRunner.with_memory(@math_wasm, fn pid, mem ->
-        assert is_pid(pid)
-        assert %Memory{} = mem
-        assert mem.instance == pid
-        assert mem.alignment == 8
-        assert mem.base_offset == 1024
-        :works
-      end)
+      {:ok, result} =
+        WasmRunner.with_memory(@math_wasm, fn pid, mem ->
+          assert is_pid(pid)
+          assert %Memory{} = mem
+          assert mem.instance == pid
+          assert mem.alignment == 8
+          assert mem.base_offset == 1024
+          :works
+        end)
 
       assert result == :works
     end
 
     test "cleans up instance after callback returns" do
-      {:ok, captured_pid} = WasmRunner.with_memory(@math_wasm, fn pid, _mem ->
-        assert Process.alive?(pid)
-        pid
-      end)
+      {:ok, captured_pid} =
+        WasmRunner.with_memory(@math_wasm, fn pid, _mem ->
+          assert Process.alive?(pid)
+          pid
+        end)
 
       refute Process.alive?(captured_pid)
     end
@@ -36,10 +38,11 @@ defmodule Firebird.WasmRunnerMemoryTest do
     test "cleans up instance after callback raises" do
       captured = Agent.start_link(fn -> nil end) |> elem(1)
 
-      {:error, _} = WasmRunner.with_memory(@math_wasm, fn pid, _mem ->
-        Agent.update(captured, fn _ -> pid end)
-        raise "boom"
-      end)
+      {:error, _} =
+        WasmRunner.with_memory(@math_wasm, fn pid, _mem ->
+          Agent.update(captured, fn _ -> pid end)
+          raise "boom"
+        end)
 
       pid = Agent.get(captured, & &1)
       refute Process.alive?(pid)
@@ -47,63 +50,73 @@ defmodule Firebird.WasmRunnerMemoryTest do
     end
 
     test "write and read string through memory" do
-      {:ok, result} = WasmRunner.with_memory(@crypto_wasm, fn pid, mem ->
-        {_mem, ptr, len} = Memory.write_string(mem, "hello")
-        {:ok, [hash]} = Firebird.call(pid, :hash_djb2, [ptr, len])
-        hash
-      end)
+      {:ok, result} =
+        WasmRunner.with_memory(@crypto_wasm, fn pid, mem ->
+          {_mem, ptr, len} = Memory.write_string(mem, "hello")
+          {:ok, [hash]} = Firebird.call(pid, :hash_djb2, [ptr, len])
+          hash
+        end)
 
       assert is_integer(result)
       assert result != 0
     end
 
     test "write and read i32 array through memory" do
-      {:ok, result} = WasmRunner.with_memory(@math_wasm, fn _pid, mem ->
-        values = [10, 20, 30, 40, 50]
-        {mem, ptr, count} = Memory.write_i32_array(mem, values)
-        {:ok, read_back} = Memory.read_i32_array(mem, ptr, count)
-        read_back
-      end)
+      {:ok, result} =
+        WasmRunner.with_memory(@math_wasm, fn _pid, mem ->
+          values = [10, 20, 30, 40, 50]
+          {mem, ptr, count} = Memory.write_i32_array(mem, values)
+          {:ok, read_back} = Memory.read_i32_array(mem, ptr, count)
+          read_back
+        end)
 
       assert result == [10, 20, 30, 40, 50]
     end
 
     test "arena pattern for multiple operations" do
-      {:ok, hashes} = WasmRunner.with_memory(@crypto_wasm, fn pid, mem ->
-        strings = ["alpha", "beta", "gamma"]
-
-        Enum.map(strings, fn s ->
-          {hash, _mem} = Memory.with_arena(mem, fn mem ->
-            {mem, ptr, len} = Memory.write_string(mem, s)
-            {:ok, [h]} = Firebird.call(pid, :hash_djb2, [ptr, len])
-            {h, mem}
+      {:ok, hashes} =
+        WasmRunner.with_memory(@crypto_wasm, fn pid, mem ->
+          strings = ["alpha", "beta", "gamma"]
+
+          Enum.map(strings, fn s ->
+            {hash, _mem} =
+              Memory.with_arena(mem, fn mem ->
+                {mem, ptr, len} = Memory.write_string(mem, s)
+                {:ok, [h]} = Firebird.call(pid, :hash_djb2, [ptr, len])
+                {h, mem}
+              end)
+
+            hash
           end)
-          hash
         end)
-      end)
 
       assert length(hashes) == 3
-      assert length(Enum.uniq(hashes)) == 3  # all different
+      # all different
+      assert length(Enum.uniq(hashes)) == 3
     end
 
     test "with custom memory options" do
-      {:ok, result} = WasmRunner.with_memory(@math_wasm,
-        [memory: [alignment: 16, base_offset: 4096]],
-        fn _pid, mem ->
-          assert mem.alignment == 16
-          assert mem.base_offset == 4096
-          :configured
-        end)
+      {:ok, result} =
+        WasmRunner.with_memory(
+          @math_wasm,
+          [memory: [alignment: 16, base_offset: 4096]],
+          fn _pid, mem ->
+            assert mem.alignment == 16
+            assert mem.base_offset == 4096
+            :configured
+          end
+        )
 
       assert result == :configured
     end
 
     test "with wasi option for Go modules" do
-      {:ok, result} = WasmRunner.with_memory(@go_math_wasm, [wasi: true], fn pid, mem ->
-        {_mem, _ptr} = Memory.write_i32(mem, 42)
-        {:ok, [val]} = Firebird.call(pid, :add, [5, 3])
-        val
-      end)
+      {:ok, result} =
+        WasmRunner.with_memory(@go_math_wasm, [wasi: true], fn pid, mem ->
+          {_mem, _ptr} = Memory.write_i32(mem, 42)
+          {:ok, [val]} = Firebird.call(pid, :add, [5, 3])
+          val
+        end)
 
       assert result == 8
     end
@@ -113,38 +126,41 @@ defmodule Firebird.WasmRunnerMemoryTest do
     end
 
     test "encrypt-decrypt round-trip through memory" do
-      {:ok, decrypted} = WasmRunner.with_memory(@crypto_wasm, fn pid, mem ->
-        original = "secret message!!"
-        {mem, ptr, len} = Memory.write_string(mem, original)
-
-        # Encrypt in place
-        {:ok, [^len]} = Firebird.call(pid, :xor_encrypt, [ptr, len, 0xAB])
-        # Read as raw bytes since encrypted data is not valid UTF-8
-        {:ok, encrypted} = Memory.read_bytes(mem, ptr, len)
-        assert encrypted != original
-
-        # Decrypt in place
-        {:ok, [^len]} = Firebird.call(pid, :xor_encrypt, [ptr, len, 0xAB])
-        {:ok, result} = Memory.read_string(mem, ptr, len)
-        result
-      end)
+      {:ok, decrypted} =
+        WasmRunner.with_memory(@crypto_wasm, fn pid, mem ->
+          original = "secret message!!"
+          {mem, ptr, len} = Memory.write_string(mem, original)
+
+          # Encrypt in place
+          {:ok, [^len]} = Firebird.call(pid, :xor_encrypt, [ptr, len, 0xAB])
+          # Read as raw bytes since encrypted data is not valid UTF-8
+          {:ok, encrypted} = Memory.read_bytes(mem, ptr, len)
+          assert encrypted != original
+
+          # Decrypt in place
+          {:ok, [^len]} = Firebird.call(pid, :xor_encrypt, [ptr, len, 0xAB])
+          {:ok, result} = Memory.read_string(mem, ptr, len)
+          result
+        end)
 
       assert decrypted == "secret message!!"
     end
 
     test "struct layout with memory" do
-      {:ok, result} = WasmRunner.with_memory(@math_wasm, fn _pid, mem ->
-        layout = Memory.define_layout([
-          {:x, :f64},
-          {:y, :f64},
-          {:id, :i32}
-        ])
-
-        point = %{x: 1.5, y: 2.5, id: 42}
-        {mem, ptr} = Memory.write_struct(mem, layout, point)
-        {:ok, read_back} = Memory.read_struct(mem, layout, ptr)
-        read_back
-      end)
+      {:ok, result} =
+        WasmRunner.with_memory(@math_wasm, fn _pid, mem ->
+          layout =
+            Memory.define_layout([
+              {:x, :f64},
+              {:y, :f64},
+              {:id, :i32}
+            ])
+
+          point = %{x: 1.5, y: 2.5, id: 42}
+          {mem, ptr} = Memory.write_struct(mem, layout, point)
+          {:ok, read_back} = Memory.read_struct(mem, layout, ptr)
+          read_back
+        end)
 
       assert_in_delta result.x, 1.5, 1.0e-10
       assert_in_delta result.y, 2.5, 1.0e-10
@@ -156,9 +172,12 @@ defmodule Firebird.WasmRunnerMemoryTest do
 
   describe "call_with_strings/4" do
     test "hash a string via WASM" do
-      {:ok, result} = WasmRunner.call_with_strings(
-        @crypto_wasm, :hash_djb2, ["hello"]
-      )
+      {:ok, result} =
+        WasmRunner.call_with_strings(
+          @crypto_wasm,
+          :hash_djb2,
+          ["hello"]
+        )
 
       assert is_list(result)
       [hash] = result
@@ -179,45 +198,60 @@ defmodule Firebird.WasmRunnerMemoryTest do
     end
 
     test "result: :i32 unwraps single value" do
-      {:ok, hash} = WasmRunner.call_with_strings(
-        @crypto_wasm, :hash_djb2, ["hello"],
-        result: :i32
-      )
+      {:ok, hash} =
+        WasmRunner.call_with_strings(
+          @crypto_wasm,
+          :hash_djb2,
+          ["hello"],
+          result: :i32
+        )
 
       assert is_integer(hash)
     end
 
     test "with extra_args for xor_encrypt" do
-      {:ok, result} = WasmRunner.call_with_strings(
-        @crypto_wasm, :xor_encrypt, ["hello"],
-        extra_args: [0x42],
-        result: :i32
-      )
+      {:ok, result} =
+        WasmRunner.call_with_strings(
+          @crypto_wasm,
+          :xor_encrypt,
+          ["hello"],
+          extra_args: [0x42],
+          result: :i32
+        )
 
       # xor_encrypt returns the length
       assert result == 5
     end
 
     test "empty string" do
-      {:ok, [hash]} = WasmRunner.call_with_strings(
-        @crypto_wasm, :hash_djb2, [""]
-      )
+      {:ok, [hash]} =
+        WasmRunner.call_with_strings(
+          @crypto_wasm,
+          :hash_djb2,
+          [""]
+        )
 
       assert is_integer(hash)
     end
 
     test "UTF-8 string" do
-      {:ok, [hash]} = WasmRunner.call_with_strings(
-        @crypto_wasm, :hash_djb2, ["Hello, 世界!"]
-      )
+      {:ok, [hash]} =
+        WasmRunner.call_with_strings(
+          @crypto_wasm,
+          :hash_djb2,
+          ["Hello, 世界!"]
+        )
 
       assert is_integer(hash)
     end
 
     test "returns error for invalid source" do
-      assert {:error, _} = WasmRunner.call_with_strings(
-        "/nonexistent.wasm", :hash, ["hello"]
-      )
+      assert {:error, _} =
+               WasmRunner.call_with_strings(
+                 "/nonexistent.wasm",
+                 :hash,
+                 ["hello"]
+               )
     end
   end
 
@@ -225,41 +259,47 @@ defmodule Firebird.WasmRunnerMemoryTest do
 
   describe "run_memory_batch/3" do
     test "batch hash multiple strings" do
-      {:ok, results} = WasmRunner.run_memory_batch(@crypto_wasm, [
-        %{function: :hash_djb2, strings: ["hello"], result: :i32},
-        %{function: :hash_djb2, strings: ["world"], result: :i32},
-        %{function: :hash_djb2, strings: ["test"], result: :i32}
-      ])
+      {:ok, results} =
+        WasmRunner.run_memory_batch(@crypto_wasm, [
+          %{function: :hash_djb2, strings: ["hello"], result: :i32},
+          %{function: :hash_djb2, strings: ["world"], result: :i32},
+          %{function: :hash_djb2, strings: ["test"], result: :i32}
+        ])
 
       assert length(results) == 3
       assert Enum.all?(results, &is_integer/1)
-      assert length(Enum.uniq(results)) == 3  # all different hashes
+      # all different hashes
+      assert length(Enum.uniq(results)) == 3
     end
 
     test "batch with raw result mode" do
-      {:ok, results} = WasmRunner.run_memory_batch(@crypto_wasm, [
-        %{function: :hash_djb2, strings: ["hello"]},
-        %{function: :hash_djb2, strings: ["world"]}
-      ])
+      {:ok, results} =
+        WasmRunner.run_memory_batch(@crypto_wasm, [
+          %{function: :hash_djb2, strings: ["hello"]},
+          %{function: :hash_djb2, strings: ["world"]}
+        ])
 
       assert length(results) == 2
       assert Enum.all?(results, &is_list/1)
     end
 
     test "batch with extra args" do
-      {:ok, results} = WasmRunner.run_memory_batch(@crypto_wasm, [
-        %{function: :xor_encrypt, strings: ["abc"], args: [0x42], result: :i32},
-        %{function: :xor_encrypt, strings: ["def"], args: [0x42], result: :i32}
-      ])
+      {:ok, results} =
+        WasmRunner.run_memory_batch(@crypto_wasm, [
+          %{function: :xor_encrypt, strings: ["abc"], args: [0x42], result: :i32},
+          %{function: :xor_encrypt, strings: ["def"], args: [0x42], result: :i32}
+        ])
 
-      assert results == [3, 3]  # both return length 3
+      # both return length 3
+      assert results == [3, 3]
     end
 
     test "batch with i32 arrays" do
-      {:ok, results} = WasmRunner.run_memory_batch(@math_wasm, [
-        %{function: :add, args: [5, 3], result: :i32},
-        %{function: :multiply, args: [4, 7], result: :i32}
-      ])
+      {:ok, results} =
+        WasmRunner.run_memory_batch(@math_wasm, [
+          %{function: :add, args: [5, 3], result: :i32},
+          %{function: :multiply, args: [4, 7], result: :i32}
+        ])
 
       assert results == [8, 28]
     end
@@ -274,11 +314,13 @@ defmodule Firebird.WasmRunnerMemoryTest do
       # each call uses with_arena
       large_string = String.duplicate("x", 10_000)
 
-      {:ok, results} = WasmRunner.run_memory_batch(@crypto_wasm,
-        for _ <- 1..50 do
-          %{function: :hash_djb2, strings: [large_string], result: :i32}
-        end
-      )
+      {:ok, results} =
+        WasmRunner.run_memory_batch(
+          @crypto_wasm,
+          for _ <- 1..50 do
+            %{function: :hash_djb2, strings: [large_string], result: :i32}
+          end
+        )
 
       assert length(results) == 50
       # All hashes should be the same (same input)
@@ -286,16 +328,22 @@ defmodule Firebird.WasmRunnerMemoryTest do
     end
 
     test "returns error for invalid source" do
-      assert {:error, _} = WasmRunner.run_memory_batch("/nonexistent.wasm", [
-        %{function: :add, args: [1, 2]}
-      ])
+      assert {:error, _} =
+               WasmRunner.run_memory_batch("/nonexistent.wasm", [
+                 %{function: :add, args: [1, 2]}
+               ])
     end
 
     test "with wasi option for Go modules" do
-      {:ok, results} = WasmRunner.run_memory_batch(@go_math_wasm, [
-        %{function: :add, args: [5, 3], result: :i32},
-        %{function: :fibonacci, args: [10], result: :i32}
-      ], wasi: true)
+      {:ok, results} =
+        WasmRunner.run_memory_batch(
+          @go_math_wasm,
+          [
+            %{function: :add, args: [5, 3], result: :i32},
+            %{function: :fibonacci, args: [10], result: :i32}
+          ],
+          wasi: true
+        )
 
       assert results == [8, 55]
     end
@@ -307,11 +355,12 @@ defmodule Firebird.WasmRunnerMemoryTest do
     test "with_memory accepts precompiled module" do
       {:ok, compiled} = WasmRunner.precompile(@crypto_wasm)
 
-      {:ok, hash} = WasmRunner.with_memory(compiled, fn pid, mem ->
-        {_mem, ptr, len} = Memory.write_string(mem, "precompiled")
-        {:ok, [h]} = Firebird.call(pid, :hash_djb2, [ptr, len])
-        h
-      end)
+      {:ok, hash} =
+        WasmRunner.with_memory(compiled, fn pid, mem ->
+          {_mem, ptr, len} = Memory.write_string(mem, "precompiled")
+          {:ok, [h]} = Firebird.call(pid, :hash_djb2, [ptr, len])
+          h
+        end)
 
       assert is_integer(hash)
     end
@@ -319,10 +368,13 @@ defmodule Firebird.WasmRunnerMemoryTest do
     test "call_with_strings accepts precompiled module" do
       {:ok, compiled} = WasmRunner.precompile(@crypto_wasm)
 
-      {:ok, hash} = WasmRunner.call_with_strings(
-        compiled, :hash_djb2, ["precompiled"],
-        result: :i32
-      )
+      {:ok, hash} =
+        WasmRunner.call_with_strings(
+          compiled,
+          :hash_djb2,
+          ["precompiled"],
+          result: :i32
+        )
 
       assert is_integer(hash)
     end
@@ -330,10 +382,11 @@ defmodule Firebird.WasmRunnerMemoryTest do
     test "run_memory_batch accepts precompiled module" do
       {:ok, compiled} = WasmRunner.precompile(@crypto_wasm)
 
-      {:ok, results} = WasmRunner.run_memory_batch(compiled, [
-        %{function: :hash_djb2, strings: ["a"], result: :i32},
-        %{function: :hash_djb2, strings: ["b"], result: :i32}
-      ])
+      {:ok, results} =
+        WasmRunner.run_memory_batch(compiled, [
+          %{function: :hash_djb2, strings: ["a"], result: :i32},
+          %{function: :hash_djb2, strings: ["b"], result: :i32}
+        ])
 
       assert length(results) == 2
       assert Enum.all?(results, &is_integer/1)
diff --git a/test/wasm_runner_module_test.exs b/test/wasm_runner_module_test.exs
index c8518c7..db0c52e 100644
--- a/test/wasm_runner_module_test.exs
+++ b/test/wasm_runner_module_test.exs
@@ -52,26 +52,35 @@ defmodule Firebird.WasmRunnerModuleTest do
 
   describe "run_batch/3" do
     test "executes batch of calls" do
-      {:ok, results} = WasmRunner.run_batch(@rust_wasm, [
-        {:add, [5, 3]},
-        {:multiply, [4, 7]},
-        {:fibonacci, [10]}
-      ])
+      {:ok, results} =
+        WasmRunner.run_batch(@rust_wasm, [
+          {:add, [5, 3]},
+          {:multiply, [4, 7]},
+          {:fibonacci, [10]}
+        ])
+
       assert results == [8, 28, 55]
     end
 
     test "handles errors in batch" do
-      assert {:error, _} = WasmRunner.run_batch(@rust_wasm, [
-        {:add, [5, 3]},
-        {:nonexistent, [1]}
-      ])
+      assert {:error, _} =
+               WasmRunner.run_batch(@rust_wasm, [
+                 {:add, [5, 3]},
+                 {:nonexistent, [1]}
+               ])
     end
 
     test "batch with Go WASM" do
-      {:ok, results} = WasmRunner.run_batch(@go_wasm, [
-        {:add, [10, 20]},
-        {:multiply, [3, 7]}
-      ], wasi: true)
+      {:ok, results} =
+        WasmRunner.run_batch(
+          @go_wasm,
+          [
+            {:add, [10, 20]},
+            {:multiply, [3, 7]}
+          ],
+          wasi: true
+        )
+
       assert results == [30, 21]
     end
   end
@@ -102,22 +111,23 @@ defmodule Firebird.WasmRunnerModuleTest do
 
     test "unknown function fails", %{instance: pid} do
       assert {:error, {:unknown_function, :nonexistent}} =
-        WasmRunner.validate_call(pid, :nonexistent, [1])
+               WasmRunner.validate_call(pid, :nonexistent, [1])
     end
 
     test "wrong arity fails", %{instance: pid} do
       assert {:error, {:arity_mismatch, :add, expected: 2, got: 3}} =
-        WasmRunner.validate_call(pid, :add, [1, 2, 3])
+               WasmRunner.validate_call(pid, :add, [1, 2, 3])
     end
   end
 
   describe "compare/3" do
     test "compares results across implementations" do
-      {:ok, results} = WasmRunner.compare(
-        [@rust_wasm, {@go_wasm, wasi: true}],
-        :add,
-        [5, 3]
-      )
+      {:ok, results} =
+        WasmRunner.compare(
+          [@rust_wasm, {@go_wasm, wasi: true}],
+          :add,
+          [5, 3]
+        )
 
       assert length(results) == 2
       assert {_, {:ok, [8]}} = Enum.at(results, 0)
diff --git a/test/wasm_runner_pipe_test.exs b/test/wasm_runner_pipe_test.exs
new file mode 100644
index 0000000..30e632c
--- /dev/null
+++ b/test/wasm_runner_pipe_test.exs
@@ -0,0 +1,172 @@
+defmodule Firebird.WasmRunner.PipeTest do
+  use ExUnit.Case, async: false
+
+  alias Firebird.WasmRunner
+
+  @math_wasm "fixtures/math.wasm"
+
+  describe "pipe/3 - basic chaining" do
+    test "chains two calls, feeding result forward" do
+      # add(5, 5) = 10, then fibonacci(10) = 55
+      assert {:ok, 55} =
+               WasmRunner.pipe(@math_wasm, [
+                 {:add, [5, 5]},
+                 {:fibonacci, []}
+               ])
+    end
+
+    test "chains three calls" do
+      # add(5, 3) = 8, fibonacci(8) = 21, multiply(21, 2) = 42
+      assert {:ok, 42} =
+               WasmRunner.pipe(@math_wasm, [
+                 {:add, [5, 3]},
+                 {:fibonacci, []},
+                 {:multiply, [:pipe, 2]}
+               ])
+    end
+
+    test "single call returns its result" do
+      assert {:ok, 8} =
+               WasmRunner.pipe(@math_wasm, [
+                 {:add, [5, 3]}
+               ])
+    end
+
+    test "piped value defaults to first argument" do
+      # add(2, 3) = 5, add(5, 10) = 15
+      assert {:ok, 15} =
+               WasmRunner.pipe(@math_wasm, [
+                 {:add, [2, 3]},
+                 {:add, [10]}
+               ])
+    end
+  end
+
+  describe "pipe/3 - :pipe placeholder" do
+    test "explicit :pipe in first position" do
+      # add(5, 3) = 8, multiply(8, 7) = 56
+      assert {:ok, 56} =
+               WasmRunner.pipe(@math_wasm, [
+                 {:add, [5, 3]},
+                 {:multiply, [:pipe, 7]}
+               ])
+    end
+
+    test "explicit :pipe in second position" do
+      # add(2, 3) = 5, add(2, 5) = 7
+      assert {:ok, 7} =
+               WasmRunner.pipe(@math_wasm, [
+                 {:add, [2, 3]},
+                 {:add, [2, :pipe]}
+               ])
+    end
+
+    test "multiple :pipe placeholders" do
+      # add(3, 3) = 6, add(6, 6) = 12
+      assert {:ok, 12} =
+               WasmRunner.pipe(@math_wasm, [
+                 {:add, [3, 3]},
+                 {:add, [:pipe, :pipe]}
+               ])
+    end
+  end
+
+  describe "pipe/3 - error handling" do
+    test "returns error for empty pipeline" do
+      assert {:error, :no_calls} = WasmRunner.pipe(@math_wasm, [])
+    end
+
+    test "returns error for nonexistent wasm file" do
+      assert {:error, _} =
+               WasmRunner.pipe("nonexistent.wasm", [
+                 {:add, [1, 2]}
+               ])
+    end
+
+    test "returns error when a call in the chain fails" do
+      assert {:error, _} =
+               WasmRunner.pipe(@math_wasm, [
+                 {:add, [5, 3]},
+                 {:nonexistent, []}
+               ])
+    end
+
+    test "returns error on wrong arity in chain" do
+      assert {:error, _} =
+               WasmRunner.pipe(@math_wasm, [
+                 {:add, [5, 3]},
+                 {:add, [:pipe, :pipe, :pipe]}
+               ])
+    end
+  end
+
+  describe "pipe/3 - with options" do
+    test "passes wasi option through" do
+      assert {:ok, _} =
+               WasmRunner.pipe(
+                 "fixtures/go_math.wasm",
+                 [
+                   {:add, [5, 3]},
+                   {:multiply, [:pipe, 2]}
+                 ],
+                 wasi: true
+               )
+    end
+  end
+
+  describe "pipe/3 - with precompiled module" do
+    test "works with precompiled module" do
+      {:ok, compiled} = WasmRunner.precompile(@math_wasm)
+
+      assert {:ok, 55} =
+               WasmRunner.pipe(compiled, [
+                 {:add, [5, 5]},
+                 {:fibonacci, []}
+               ])
+    end
+  end
+
+  describe "pipe!/3" do
+    test "returns unwrapped result" do
+      assert 42 =
+               WasmRunner.pipe!(@math_wasm, [
+                 {:add, [5, 3]},
+                 {:fibonacci, []},
+                 {:multiply, [:pipe, 2]}
+               ])
+    end
+
+    test "raises on error" do
+      assert_raise RuntimeError, ~r/WASM pipe failed/, fn ->
+        WasmRunner.pipe!("nonexistent.wasm", [{:add, [1, 2]}])
+      end
+    end
+
+    test "raises on failed call in chain" do
+      assert_raise RuntimeError, ~r/WASM pipe failed/, fn ->
+        WasmRunner.pipe!(@math_wasm, [
+          {:add, [5, 3]},
+          {:nonexistent, []}
+        ])
+      end
+    end
+  end
+
+  describe "pipe/3 - instance cleanup" do
+    test "instance is cleaned up after successful pipe" do
+      before = length(Process.list())
+      WasmRunner.pipe(@math_wasm, [{:add, [5, 3]}, {:fibonacci, []}])
+      Process.sleep(10)
+      after_count = length(Process.list())
+      assert after_count - before <= 2
+    end
+
+    test "instance is cleaned up after failed pipe" do
+      before = length(Process.list())
+      WasmRunner.pipe(@math_wasm, [{:add, [5, 3]}, {:nonexistent, []}])
+      Process.sleep(10)
+      after_count = length(Process.list())
+      assert after_count - before <= 2
+    end
+  end
+end
diff --git a/test/wasm_runner_precompile_test.exs b/test/wasm_runner_precompile_test.exs
index 90031fb..6668713 100644
--- a/test/wasm_runner_precompile_test.exs
+++ b/test/wasm_runner_precompile_test.exs
@@ -23,9 +23,10 @@ defmodule Firebird.WasmRunnerPrecompileTest do
     test "precompiled module works with with_instance/3" do
       {:ok, compiled} = Firebird.WasmRunner.precompile(@math_wasm)
 
-      {:ok, result} = Firebird.WasmRunner.with_instance(compiled, fn pid ->
-        Firebird.WasmRunner.call_single!(pid, :add, [5, 3])
-      end)
+      {:ok, result} =
+        Firebird.WasmRunner.with_instance(compiled, fn pid ->
+          Firebird.WasmRunner.call_single!(pid, :add, [5, 3])
+        end)
 
       assert result == 8
     end
@@ -33,10 +34,11 @@ defmodule Firebird.WasmRunnerPrecompileTest do
     test "precompiled module works with run_batch/3" do
       {:ok, compiled} = Firebird.WasmRunner.precompile(@math_wasm)
 
-      {:ok, results} = Firebird.WasmRunner.run_batch(compiled, [
-        {:add, [5, 3]},
-        {:multiply, [4, 7]}
-      ])
+      {:ok, results} =
+        Firebird.WasmRunner.run_batch(compiled, [
+          {:add, [5, 3]},
+          {:multiply, [4, 7]}
+        ])
 
       assert results == [8, 28]
     end
@@ -45,7 +47,9 @@ defmodule Firebird.WasmRunnerPrecompileTest do
       {:ok, compiled} = Firebird.WasmRunner.precompile(@math_wasm)
 
       args_list = for n <- 1..10, do: [n, n]
-      {:ok, results} = Firebird.WasmRunner.run_concurrent(compiled, :add, args_list, concurrency: 2)
+
+      {:ok, results} =
+        Firebird.WasmRunner.run_concurrent(compiled, :add, args_list, concurrency: 2)
 
       expected = for n <- 1..10, do: n + n
       assert results == expected
@@ -73,27 +77,33 @@ defmodule Firebird.WasmRunnerPrecompileTest do
 
       # Run multiple times to verify no resource leak
       for _ <- 1..5 do
-        {:ok, result} = Firebird.WasmRunner.with_instance(compiled, fn pid ->
-          Firebird.WasmRunner.call_single!(pid, :add, [10, 20])
-        end)
+        {:ok, result} =
+          Firebird.WasmRunner.with_instance(compiled, fn pid ->
+            Firebird.WasmRunner.call_single!(pid, :add, [10, 20])
+          end)
+
         assert result == 30
       end
     end
 
     test "precompile is faster than repeated loading" do
       # Compile once
-      {compile_time, {:ok, compiled}} = :timer.tc(fn ->
-        Firebird.WasmRunner.precompile(@math_wasm)
-      end)
+      {compile_time, {:ok, compiled}} =
+        :timer.tc(fn ->
+          Firebird.WasmRunner.precompile(@math_wasm)
+        end)
 
       # Instantiate from precompiled (should be faster than full load)
-      instantiate_times = for _ <- 1..3 do
-        {time, {:ok, pid}} = :timer.tc(fn ->
-          Firebird.WasmRunner.start(compiled)
-        end)
-        Firebird.stop(pid)
-        time
-      end
+      instantiate_times =
+        for _ <- 1..3 do
+          {time, {:ok, pid}} =
+            :timer.tc(fn ->
+              Firebird.WasmRunner.start(compiled)
+            end)
+
+          Firebird.stop(pid)
+          time
+        end
 
       avg_instantiate = Enum.sum(instantiate_times) / length(instantiate_times)
 
@@ -101,7 +111,7 @@ defmodule Firebird.WasmRunnerPrecompileTest do
       # (compilation includes parsing + validation + optimization; instantiation
       # only allocates memory and initializes globals)
       assert avg_instantiate < compile_time,
-        "Expected instantiation (#{avg_instantiate}μs) < compilation (#{compile_time}μs)"
+             "Expected instantiation (#{avg_instantiate}μs) < compilation (#{compile_time}μs)"
     end
   end
 
@@ -117,9 +127,10 @@ defmodule Firebird.WasmRunnerPrecompileTest do
     test "precompiled Go WASM works with with_instance" do
       {:ok, compiled} = Firebird.WasmRunner.precompile(@go_wasm, wasi: true)
 
-      {:ok, result} = Firebird.WasmRunner.with_instance(compiled, fn pid ->
-        Firebird.WasmRunner.call_single!(pid, :add, [5, 3])
-      end)
+      {:ok, result} =
+        Firebird.WasmRunner.with_instance(compiled, fn pid ->
+          Firebird.WasmRunner.call_single!(pid, :add, [5, 3])
+        end)
 
       assert result == 8
     end
@@ -127,10 +138,11 @@ defmodule Firebird.WasmRunnerPrecompileTest do
     test "precompiled Go WASM works with run_batch" do
       {:ok, compiled} = Firebird.WasmRunner.precompile(@go_wasm, wasi: true)
 
-      {:ok, results} = Firebird.WasmRunner.run_batch(compiled, [
-        {:add, [5, 3]},
-        {:multiply, [4, 7]}
-      ])
+      {:ok, results} =
+        Firebird.WasmRunner.run_batch(compiled, [
+          {:add, [5, 3]},
+          {:multiply, [4, 7]}
+        ])
 
       assert results == [8, 28]
     end
diff --git a/test/wasm_runner_run_test.exs b/test/wasm_runner_run_test.exs
new file mode 100644
index 0000000..7735e43
--- /dev/null
+++ b/test/wasm_runner_run_test.exs
@@ -0,0 +1,147 @@
+defmodule Firebird.WasmRunner.RunTest do
+  use ExUnit.Case, async: false
+
+  alias Firebird.WasmRunner
+
+  @math_wasm "fixtures/math.wasm"
+
+  describe "run/2 - single call" do
+    test "executes a single function call and returns unwrapped result" do
+      assert {:ok, 8} = WasmRunner.run(@math_wasm, add: [5, 3])
+    end
+
+    test "works with fibonacci" do
+      assert {:ok, 55} = WasmRunner.run(@math_wasm, fibonacci: [10])
+    end
+
+    test "works with multiply" do
+      assert {:ok, 28} = WasmRunner.run(@math_wasm, multiply: [4, 7])
+    end
+
+    test "returns zero correctly" do
+      assert {:ok, 0} = WasmRunner.run(@math_wasm, add: [0, 0])
+    end
+
+    test "handles negative results" do
+      # add(-5, 3) = -2 in i32 math
+      assert {:ok, -2} = WasmRunner.run(@math_wasm, add: [-5, 3])
+    end
+  end
+
+  describe "run/2 - multiple calls" do
+    test "executes multiple calls and returns list of results" do
+      assert {:ok, [8, 28, 55]} =
+               WasmRunner.run(@math_wasm,
+                 add: [5, 3],
+                 multiply: [4, 7],
+                 fibonacci: [10]
+               )
+    end
+
+    test "executes two calls" do
+      assert {:ok, [8, 55]} =
+               WasmRunner.run(@math_wasm,
+                 add: [5, 3],
+                 fibonacci: [10]
+               )
+    end
+
+    test "same function called multiple times" do
+      assert {:ok, [3, 7, 11]} =
+               WasmRunner.run(@math_wasm,
+                 add: [1, 2],
+                 add: [3, 4],
+                 add: [5, 6]
+               )
+    end
+  end
+
+  describe "run/2 - error handling" do
+    test "returns error for no calls" do
+      assert {:error, :no_calls} = WasmRunner.run(@math_wasm, [])
+    end
+
+    test "returns error for nonexistent wasm file" do
+      assert {:error, _} = WasmRunner.run("nonexistent.wasm", add: [1, 2])
+    end
+
+    test "returns error for nonexistent function" do
+      assert {:error, _} = WasmRunner.run(@math_wasm, nonexistent: [1, 2])
+    end
+
+    test "returns error for wrong arity" do
+      assert {:error, _} = WasmRunner.run(@math_wasm, add: [1])
+    end
+  end
+
+  describe "run/2 - with options" do
+    test "passes wasi option through" do
+      # go_math.wasm needs WASI - auto-detected, but explicit works too
+      assert {:ok, _} = WasmRunner.run("fixtures/go_math.wasm", add: [5, 3], wasi: true)
+    end
+
+    test "wasi auto-detection works" do
+      assert {:ok, _} = WasmRunner.run("fixtures/go_math.wasm", add: [5, 3])
+    end
+  end
+
+  describe "run/2 - precompiled module" do
+    test "works with precompiled module" do
+      {:ok, compiled} = WasmRunner.precompile(@math_wasm)
+      assert {:ok, 8} = WasmRunner.run(compiled, add: [5, 3])
+    end
+
+    test "precompiled module with multiple calls" do
+      {:ok, compiled} = WasmRunner.precompile(@math_wasm)
+
+      assert {:ok, [8, 55]} =
+               WasmRunner.run(compiled,
+                 add: [5, 3],
+                 fibonacci: [10]
+               )
+    end
+  end
+
+  describe "run!/2" do
+    test "returns unwrapped result for single call" do
+      assert 8 = WasmRunner.run!(@math_wasm, add: [5, 3])
+    end
+
+    test "returns list for multiple calls" do
+      assert [8, 55] = WasmRunner.run!(@math_wasm, add: [5, 3], fibonacci: [10])
+    end
+
+    test "raises on error" do
+      assert_raise RuntimeError, ~r/WASM run failed/, fn ->
+        WasmRunner.run!("nonexistent.wasm", add: [1, 2])
+      end
+    end
+
+    test "raises on nonexistent function" do
+      assert_raise RuntimeError, ~r/WASM run failed/, fn ->
+        WasmRunner.run!(@math_wasm, nonexistent: [1, 2])
+      end
+    end
+  end
+
+  describe "run/2 - instance cleanup" do
+    test "instance is cleaned up after successful call" do
+      # Get the initial process count
+      before = length(Process.list())
+      WasmRunner.run(@math_wasm, add: [5, 3])
+      # Give a moment for cleanup
+      Process.sleep(10)
+      after_count = length(Process.list())
+      # Should not leak processes (allow small tolerance for runtime fluctuation)
+      assert after_count - before <= 2
+    end
+
+    test "instance is cleaned up after error" do
+      before = length(Process.list())
+      WasmRunner.run(@math_wasm, nonexistent: [1, 2])
+      Process.sleep(10)
+      after_count = length(Process.list())
+      assert after_count - before <= 2
+    end
+  end
+end
diff --git a/test/wasm_runner_timeout_test.exs b/test/wasm_runner_timeout_test.exs
new file mode 100644
index 0000000..5a19933
--- /dev/null
+++ b/test/wasm_runner_timeout_test.exs
@@ -0,0 +1,123 @@
+defmodule Firebird.WasmRunnerTimeoutTest do
+  use ExUnit.Case, async: true
+
+  @math_wasm "fixtures/math.wasm"
+
+  describe "timeout option threading" do
+    test "call_single/4 accepts timeout option" do
+      {:ok, pid} = Firebird.WasmRunner.start(@math_wasm)
+
+      try do
+        {:ok, 8} = Firebird.WasmRunner.call_single(pid, :add, [5, 3], timeout: 10_000)
+      after
+        Firebird.stop(pid)
+      end
+    end
+
+    test "call_single!/4 accepts timeout option" do
+      {:ok, pid} = Firebird.WasmRunner.start(@math_wasm)
+
+      try do
+        assert 8 == Firebird.WasmRunner.call_single!(pid, :add, [5, 3], timeout: 10_000)
+      after
+        Firebird.stop(pid)
+      end
+    end
+
+    test "run/2 passes timeout through to call" do
+      {:ok, 8} = Firebird.WasmRunner.run(@math_wasm, add: [5, 3], timeout: 10_000)
+    end
+
+    test "run/2 with multiple calls and timeout" do
+      {:ok, [8, 55]} =
+        Firebird.WasmRunner.run(@math_wasm,
+          add: [5, 3],
+          fibonacci: [10],
+          timeout: 10_000
+        )
+    end
+
+    test "run!/2 with timeout option" do
+      assert 8 == Firebird.WasmRunner.run!(@math_wasm, add: [5, 3], timeout: 10_000)
+    end
+
+    test "pipe/3 passes timeout through to calls" do
+      {:ok, result} =
+        Firebird.WasmRunner.pipe(
+          @math_wasm,
+          [
+            {:add, [5, 3]},
+            {:fibonacci, []}
+          ],
+          timeout: 10_000
+        )
+
+      # add(5,3) = 8, fibonacci(8) = 21
+      assert result == 21
+    end
+
+    test "pipe!/3 with timeout option" do
+      result =
+        Firebird.WasmRunner.pipe!(
+          @math_wasm,
+          [
+            {:add, [5, 3]},
+            {:fibonacci, []}
+          ],
+          timeout: 10_000
+        )
+
+      assert result == 21
+    end
+
+    test "run_batch/3 passes timeout through to calls" do
+      {:ok, [8, 28]} =
+        Firebird.WasmRunner.run_batch(
+          @math_wasm,
+          [{:add, [5, 3]}, {:multiply, [4, 7]}],
+          timeout: 10_000
+        )
+    end
+
+    test "run_concurrent/4 passes timeout through to calls" do
+      args_list = for n <- 1..5, do: [n, n]
+
+      {:ok, results} =
+        Firebird.WasmRunner.run_concurrent(
+          @math_wasm,
+          :add,
+          args_list,
+          concurrency: 2,
+          timeout: 10_000
+        )
+
+      assert results == [2, 4, 6, 8, 10]
+    end
+
+    test "Firebird.call/4 accepts timeout option" do
+      {:ok, pid} = Firebird.load(@math_wasm)
+
+      try do
+        {:ok, [8]} = Firebird.call(pid, :add, [5, 3], timeout: 10_000)
+      after
+        Firebird.stop(pid)
+      end
+    end
+
+    test "Firebird.call/4 works with default (no opts)" do
+      {:ok, pid} = Firebird.load(@math_wasm)
+
+      try do
+        {:ok, [8]} = Firebird.call(pid, :add, [5, 3])
+      after
+        Firebird.stop(pid)
+      end
+    end
+
+    test "timeout does not affect start options (wasi, cache stay separate)" do
+      # timeout should not be passed to start/2, only to call
+      # This verifies the split works correctly
+      {:ok, 8} = Firebird.WasmRunner.run(@math_wasm, add: [5, 3], timeout: 10_000, cache: false)
+    end
+  end
+end
diff --git a/test/wasm_runner_with_instance_test.exs b/test/wasm_runner_with_instance_test.exs
index ecd2bc6..54b1560 100644
--- a/test/wasm_runner_with_instance_test.exs
+++ b/test/wasm_runner_with_instance_test.exs
@@ -96,7 +96,10 @@ defmodule Firebird.WasmRunnerWithInstanceTest do
 
       {:ok, results} =
         Firebird.WasmRunner.run_concurrent(
-          @rust_wasm, :fibonacci, args_list, concurrency: 2
+          @rust_wasm,
+          :fibonacci,
+          args_list,
+          concurrency: 2
         )
 
       assert length(results) == 10
@@ -110,7 +113,10 @@ defmodule Firebird.WasmRunnerWithInstanceTest do
 
       {:ok, results} =
         Firebird.WasmRunner.run_concurrent(
-          @rust_wasm, :add, args_list, concurrency: 3
+          @rust_wasm,
+          :add,
+          args_list,
+          concurrency: 3
         )
 
       assert results == [2, 4, 6, 10, 16, 26]
diff --git a/test/wasm_string_test.exs b/test/wasm_string_test.exs
index f4d3df2..acd216c 100644
--- a/test/wasm_string_test.exs
+++ b/test/wasm_string_test.exs
@@ -35,7 +35,8 @@ defmodule Firebird.WasmStringTest do
     end
 
     test "call_with_string/3 with longer strings", %{instance: pid} do
-      assert {:ok, "FIREBIRD WASM"} = Firebird.WasmString.call_with_string(pid, :to_uppercase, "firebird wasm")
+      assert {:ok, "FIREBIRD WASM"} =
+               Firebird.WasmString.call_with_string(pid, :to_uppercase, "firebird wasm")
     end
 
     test "write and read empty string", %{instance: pid} do
diff --git a/test/wasm_vs_native_benchmark_test.exs b/test/wasm_vs_native_benchmark_test.exs
index 0a07225..e5dd2b1 100644
--- a/test/wasm_vs_native_benchmark_test.exs
+++ b/test/wasm_vs_native_benchmark_test.exs
@@ -20,6 +20,7 @@ defmodule Firebird.WasmVsNativeBenchmarkTest do
 
   defp native_fibonacci(0), do: 0
   defp native_fibonacci(1), do: 1
+
   defp native_fibonacci(n) do
     {result, _} = Enum.reduce(2..n, {1, 0}, fn _, {b, a} -> {a + b, b} end)
     result
@@ -35,6 +36,7 @@ defmodule Firebird.WasmVsNativeBenchmarkTest do
   defp native_is_prime(n), do: native_is_prime_loop(n, 5)
 
   defp native_is_prime_loop(n, i) when i * i > n, do: 1
+
   defp native_is_prime_loop(n, i) do
     if rem(n, i) == 0 or rem(n, i + 2) == 0, do: 0, else: native_is_prime_loop(n, i + 6)
   end
@@ -51,10 +53,11 @@ defmodule Firebird.WasmVsNativeBenchmarkTest do
     # Warmup
     for _ <- 1..10, do: func.()
 
-    times = for _ <- 1..iterations do
-      {time, _} = :timer.tc(func)
-      time
-    end
+    times =
+      for _ <- 1..iterations do
+        {time, _} = :timer.tc(func)
+        time
+      end
 
     avg = Enum.sum(times) / length(times)
     median = times |> Enum.sort() |> Enum.at(div(length(times), 2))
@@ -75,7 +78,9 @@ defmodule Firebird.WasmVsNativeBenchmarkTest do
     test "add matches native", %{wasm: w} do
       for {a, b} <- [{0, 0}, {1, 2}, {-5, 5}, {100, 200}, {-100, -200}] do
         {:ok, [result]} = Firebird.call(w, :add, [a, b])
-        assert result == native_add(a, b), "add(#{a}, #{b}): wasm=#{result}, native=#{native_add(a, b)}"
+
+        assert result == native_add(a, b),
+               "add(#{a}, #{b}): wasm=#{result}, native=#{native_add(a, b)}"
       end
     end
 
@@ -89,14 +94,18 @@ defmodule Firebird.WasmVsNativeBenchmarkTest do
     test "fibonacci matches native", %{wasm: w} do
       for n <- 0..20 do
         {:ok, [result]} = Firebird.call(w, :fibonacci, [n])
-        assert result == native_fibonacci(n), "fib(#{n}): wasm=#{result}, native=#{native_fibonacci(n)}"
+
+        assert result == native_fibonacci(n),
+               "fib(#{n}): wasm=#{result}, native=#{native_fibonacci(n)}"
       end
     end
 
     test "factorial matches native", %{wasm: w} do
       for n <- 0..12 do
         {:ok, [result]} = Firebird.call(w, :factorial, [n])
-        assert result == native_factorial(n), "factorial(#{n}): wasm=#{result}, native=#{native_factorial(n)}"
+
+        assert result == native_factorial(n),
+               "factorial(#{n}): wasm=#{result}, native=#{native_factorial(n)}"
       end
     end
 
@@ -108,9 +117,11 @@ defmodule Firebird.WasmVsNativeBenchmarkTest do
     end
 
     test "is_prime matches native", %{wasm: w} do
-      for n <- [0, 1, 2, 3, 4, 5, 7, 11, 13, 15, 17, 97, 100, 104729] do
+      for n <- [0, 1, 2, 3, 4, 5, 7, 11, 13, 15, 17, 97, 100, 104_729] do
         {:ok, [result]} = Firebird.call(w, :is_prime, [n])
-        assert result == native_is_prime(n), "is_prime(#{n}): wasm=#{result}, native=#{native_is_prime(n)}"
+
+        assert result == native_is_prime(n),
+               "is_prime(#{n}): wasm=#{result}, native=#{native_is_prime(n)}"
       end
     end
 
@@ -151,7 +162,7 @@ defmodule Firebird.WasmVsNativeBenchmarkTest do
     end
 
     test "is_prime matches native", %{wasm: w} do
-      for n <- [2, 3, 4, 5, 7, 11, 97, 104729] do
+      for n <- [2, 3, 4, 5, 7, 11, 97, 104_729] do
         {:ok, [result]} = Firebird.call(w, :is_prime, [n])
         assert result == native_is_prime(n)
       end
@@ -237,7 +248,10 @@ defmodule Firebird.WasmVsNativeBenchmarkTest do
       # Verify WASM executes in reasonable time (< 1ms per call)
       assert wasm_stats.avg_us < 1000
 
-      IO.puts("\n  add: WASM avg=#{Float.round(wasm_stats.avg_us, 1)}μs, Native avg=#{Float.round(native_stats.avg_us, 1)}μs")
+      IO.puts(
+        "\n  add: WASM avg=#{Float.round(wasm_stats.avg_us, 1)}μs, Native avg=#{Float.round(native_stats.avg_us, 1)}μs"
+      )
+
       safe_stop(w)
     end
 
@@ -249,7 +263,11 @@ defmodule Firebird.WasmVsNativeBenchmarkTest do
       native_stats = bench(fn -> native_fibonacci(30) end)
 
       assert wasm_stats.avg_us < 1000
-      IO.puts("\n  fib(30): WASM avg=#{Float.round(wasm_stats.avg_us, 1)}μs, Native avg=#{Float.round(native_stats.avg_us, 1)}μs")
+
+      IO.puts(
+        "\n  fib(30): WASM avg=#{Float.round(wasm_stats.avg_us, 1)}μs, Native avg=#{Float.round(native_stats.avg_us, 1)}μs"
+      )
+
       safe_stop(w)
     end
 
@@ -261,7 +279,11 @@ defmodule Firebird.WasmVsNativeBenchmarkTest do
       native_stats = bench(fn -> native_count_primes(1000) end, 50)
 
       ratio = wasm_stats.avg_us / max(native_stats.avg_us, 0.1)
-      IO.puts("\n  count_primes(1000): WASM avg=#{Float.round(wasm_stats.avg_us, 1)}μs, Native avg=#{Float.round(native_stats.avg_us, 1)}μs, ratio=#{Float.round(ratio, 2)}x")
+
+      IO.puts(
+        "\n  count_primes(1000): WASM avg=#{Float.round(wasm_stats.avg_us, 1)}μs, Native avg=#{Float.round(native_stats.avg_us, 1)}μs, ratio=#{Float.round(ratio, 2)}x"
+      )
+
       safe_stop(w)
     end
 
@@ -272,7 +294,10 @@ defmodule Firebird.WasmVsNativeBenchmarkTest do
       wasm_stats = bench(fn -> Firebird.call(w, :collatz_steps, [27]) end)
       native_stats = bench(fn -> native_collatz_steps(27) end)
 
-      IO.puts("\n  collatz(27): WASM avg=#{Float.round(wasm_stats.avg_us, 1)}μs, Native avg=#{Float.round(native_stats.avg_us, 1)}μs")
+      IO.puts(
+        "\n  collatz(27): WASM avg=#{Float.round(wasm_stats.avg_us, 1)}μs, Native avg=#{Float.round(native_stats.avg_us, 1)}μs"
+      )
+
       safe_stop(w)
     end
   end
@@ -289,7 +314,9 @@ defmodule Firebird.WasmVsNativeBenchmarkTest do
       safe_stop(go)
       safe_stop(rust)
 
-      IO.puts("\n  add: Go avg=#{Float.round(go_stats.avg_us, 1)}μs, Rust avg=#{Float.round(rust_stats.avg_us, 1)}μs")
+      IO.puts(
+        "\n  add: Go avg=#{Float.round(go_stats.avg_us, 1)}μs, Rust avg=#{Float.round(rust_stats.avg_us, 1)}μs"
+      )
     end
 
     @tag timeout: 30_000
@@ -303,20 +330,23 @@ defmodule Firebird.WasmVsNativeBenchmarkTest do
       safe_stop(go)
       safe_stop(rust)
 
-      IO.puts("\n  fib(30): Go avg=#{Float.round(go_stats.avg_us, 1)}μs, Rust avg=#{Float.round(rust_stats.avg_us, 1)}μs")
+      IO.puts(
+        "\n  fib(30): Go avg=#{Float.round(go_stats.avg_us, 1)}μs, Rust avg=#{Float.round(rust_stats.avg_us, 1)}μs"
+      )
     end
   end
 
   describe "WasmRunner.compare across languages" do
     test "compare Rust vs Go for add" do
-      {:ok, results} = Firebird.WasmRunner.compare(
-        [
-          {@rust_wasm, []},
-          {@go_wasm, [wasi: true]}
-        ],
-        :add,
-        [5, 3]
-      )
+      {:ok, results} =
+        Firebird.WasmRunner.compare(
+          [
+            {@rust_wasm, []},
+            {@go_wasm, [wasi: true]}
+          ],
+          :add,
+          [5, 3]
+        )
 
       assert length(results) == 2
 
@@ -326,14 +356,15 @@ defmodule Firebird.WasmVsNativeBenchmarkTest do
     end
 
     test "compare Rust vs Go for fibonacci" do
-      {:ok, results} = Firebird.WasmRunner.compare(
-        [
-          {@rust_wasm, []},
-          {@go_wasm, [wasi: true]}
-        ],
-        :fibonacci,
-        [10]
-      )
+      {:ok, results} =
+        Firebird.WasmRunner.compare(
+          [
+            {@rust_wasm, []},
+            {@go_wasm, [wasi: true]}
+          ],
+          :fibonacci,
+          [10]
+        )
 
       Enum.each(results, fn {_source, result} ->
         assert {:ok, [55]} = result
diff --git a/test/wat_bitwise_test.exs b/test/wat_bitwise_test.exs
index d9b3ee3..aa39634 100644
--- a/test/wat_bitwise_test.exs
+++ b/test/wat_bitwise_test.exs
@@ -87,7 +87,9 @@ defmodule Firebird.WatBitwiseTest do
       for n <- [0, 1, 2, 3, 4, 7, 8, 15, 16, 1024, 1025] do
         {:ok, [wat_result]} = Firebird.call(wat, :is_power_of_two, [n])
         {:ok, [go_result]} = Firebird.call(go, :is_power_of_two, [n])
-        assert wat_result == go_result, "is_power_of_two(#{n}): WAT=#{wat_result}, Go=#{go_result}"
+
+        assert wat_result == go_result,
+               "is_power_of_two(#{n}): WAT=#{wat_result}, Go=#{go_result}"
       end
 
       Firebird.stop(wat)
@@ -127,10 +129,11 @@ defmodule Firebird.WatBitwiseTest do
       # Warmup
       for _ <- 1..100, do: Firebird.call(w, :popcount, [255])
 
-      times = for _ <- 1..100 do
-        {time, _} = :timer.tc(fn -> Firebird.call(w, :popcount, [255]) end)
-        time
-      end
+      times =
+        for _ <- 1..100 do
+          {time, _} = :timer.tc(fn -> Firebird.call(w, :popcount, [255]) end)
+          time
+        end
 
       avg = Enum.sum(times) / length(times)
       assert avg < 500, "WAT popcount should be < 500μs, got #{Float.round(avg, 1)}μs"
diff --git a/test/wat_examples_test.exs b/test/wat_examples_test.exs
index 6f6c1e0..12d7a1f 100644
--- a/test/wat_examples_test.exs
+++ b/test/wat_examples_test.exs
@@ -27,7 +27,8 @@ defmodule Firebird.WatExamplesTest do
 
   test "divide", %{instance: pid} do
     assert {:ok, [3]} = Firebird.call(pid, :divide, [9, 3])
-    assert {:ok, [2]} = Firebird.call(pid, :divide, [7, 3])  # integer division
+    # integer division
+    assert {:ok, [2]} = Firebird.call(pid, :divide, [7, 3])
   end
 
   test "abs", %{instance: pid} do
@@ -58,7 +59,7 @@ defmodule Firebird.WatExamplesTest do
     assert {:ok, [1]} = Firebird.call(pid, :factorial, [0])
     assert {:ok, [1]} = Firebird.call(pid, :factorial, [1])
     assert {:ok, [120]} = Firebird.call(pid, :factorial, [5])
-    assert {:ok, [3628800]} = Firebird.call(pid, :factorial, [10])
+    assert {:ok, [3_628_800]} = Firebird.call(pid, :factorial, [10])
   end
 
   test "fibonacci", %{instance: pid} do
@@ -70,7 +71,19 @@ defmodule Firebird.WatExamplesTest do
 
   test "exports all expected functions", %{instance: pid} do
     exports = Firebird.exports(pid)
-    for func <- [:add, :subtract, :multiply, :divide, :abs, :max, :min, :clamp, :factorial, :fibonacci] do
+
+    for func <- [
+          :add,
+          :subtract,
+          :multiply,
+          :divide,
+          :abs,
+          :max,
+          :min,
+          :clamp,
+          :factorial,
+          :fibonacci
+        ] do
       assert func in exports, "Missing export: #{func}"
     end
   end
diff --git a/test/wat_math_test.exs b/test/wat_math_test.exs
index 3a61840..9bc6ba5 100644
--- a/test/wat_math_test.exs
+++ b/test/wat_math_test.exs
@@ -98,7 +98,8 @@ defmodule Firebird.WatMathTest do
 
     test "memory operations", %{pid: pid} do
       {:ok, size} = Firebird.memory_size(pid)
-      assert size == 65_536  # 1 page
+      # 1 page
+      assert size == 65_536
 
       :ok = Firebird.write_memory(pid, 0, <<1, 2, 3>>)
       assert {:ok, <<1, 2, 3>>} = Firebird.read_memory(pid, 0, 3)
@@ -111,11 +112,11 @@ defmodule Firebird.WatMathTest do
 
       # Both should give same results for shared functions
       for {func, args} <- [
-        {:add, [42, 58]},
-        {:multiply, [7, 8]},
-        {:fibonacci, [10]},
-        {:fibonacci, [20]}
-      ] do
+            {:add, [42, 58]},
+            {:multiply, [7, 8]},
+            {:fibonacci, [10]},
+            {:fibonacci, [20]}
+          ] do
         {:ok, [w]} = Firebird.call(wat, func, args)
         {:ok, [r]} = Firebird.call(rust, func, args)
         assert w == r, "#{func}(#{inspect(args)}): WAT=#{w} Rust=#{r}"
@@ -130,14 +131,14 @@ defmodule Firebird.WatMathTest do
     defmodule WatMath do
       use Firebird.WasmModule, path: Path.join(__DIR__, "../fixtures/wat_math.wasm")
 
-      wasm_func :add, [:i32, :i32], [:i32]
-      wasm_func :multiply, [:i32, :i32], [:i32]
-      wasm_func :subtract, [:i32, :i32], [:i32]
-      wasm_func :abs, [:i32], [:i32]
-      wasm_func :max, [:i32, :i32], [:i32]
-      wasm_func :min, [:i32, :i32], [:i32]
-      wasm_func :clamp, [:i32, :i32, :i32], [:i32]
-      wasm_func :fibonacci, [:i32], [:i32]
+      wasm_func(:add, [:i32, :i32], [:i32])
+      wasm_func(:multiply, [:i32, :i32], [:i32])
+      wasm_func(:subtract, [:i32, :i32], [:i32])
+      wasm_func(:abs, [:i32], [:i32])
+      wasm_func(:max, [:i32, :i32], [:i32])
+      wasm_func(:min, [:i32, :i32], [:i32])
+      wasm_func(:clamp, [:i32, :i32, :i32], [:i32])
+      wasm_func(:fibonacci, [:i32], [:i32])
     end
 
     setup do