test: add memory benchmarks and leak detection

Add comprehensive memory benchmarking suite using OCaml's Gc module:

bench/mem_bench.ml - Benchmark infrastructure:
- Allocation tracking (minor/major words, GC counts)
- Leak detection via repeated runs with heap monitoring
- Pretty-printed benchmark results

bench/bench_sqlite.ml - SQLite memory benchmarks
bench/bench_postgresql.ml - PostgreSQL memory benchmarks

Benchmarks cover:
- CRUD operations (insert, query, update, delete)
- Transactions
- Query DSL operations
- Complex queries (joins, grouping)

Leak detection runs 50 rounds of 100 operations each,
monitoring heap and live word growth between rounds.

Results (no leaks detected):
- SQLite: 0 word growth across all operations
- PostgreSQL: 0 word growth across all operations

Run with:
dune exec bench/bench_sqlite.exe
dune exec bench/bench_postgresql.exe

bench/bench_postgresql.ml

···
+open Mem_bench
+
+let conninfo =
+  "host=localhost port=5432 dbname=repodb_test user=repodb password=repodb"
+
+let setup () =
+  match Repodb_postgresql.connect conninfo with
+  | Error e -> failwith (Repodb_postgresql.error_message e)
+  | Ok conn ->
+      let _ =
+        Repodb_postgresql.exec conn "DROP TABLE IF EXISTS posts" ~params:[||]
+      in
+      let _ =
+        Repodb_postgresql.exec conn "DROP TABLE IF EXISTS users" ~params:[||]
+      in
+      let _ =
+        Repodb_postgresql.exec conn
+          "CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT NOT NULL, \
+           email TEXT, age INTEGER, active BOOLEAN DEFAULT TRUE)"
+          ~params:[||]
+      in
+      let _ =
+        Repodb_postgresql.exec conn
+          "CREATE TABLE posts (id SERIAL PRIMARY KEY, user_id INTEGER, title \
+           TEXT, body TEXT, created_at TIMESTAMP DEFAULT NOW())"
+          ~params:[||]
+      in
+      let _ =
+        Repodb_postgresql.exec conn
+          "CREATE INDEX idx_posts_user_id ON posts(user_id)" ~params:[||]
+      in
+      conn
+
+let teardown conn =
+  let _ =
+    Repodb_postgresql.exec conn "DROP TABLE IF EXISTS posts" ~params:[||]
+  in
+  let _ =
+    Repodb_postgresql.exec conn "DROP TABLE IF EXISTS users" ~params:[||]
+  in
+  Repodb_postgresql.close conn
+
+module Repo = Repodb.Repo.Make (Repodb_postgresql)
+
+let users_table = Repodb.Schema.table "users"
+
+let insert_user conn name email age =
+  Repo.insert conn ~table:users_table ~columns:[ "name"; "email"; "age" ]
+    ~values:
+      [
+        Repodb.Driver.Value.text name;
+        Repodb.Driver.Value.text email;
+        Repodb.Driver.Value.int age;
+      ]
+
+let query_all_users conn =
+  Repodb_postgresql.query conn "SELECT * FROM users" ~params:[||]
+
+let query_user_by_id conn id =
+  Repodb_postgresql.query_one conn "SELECT * FROM users WHERE id = $1"
+    ~params:[| Repodb.Driver.Value.int id |]
+
+let update_user conn id new_age =
+  Repo.update conn ~table:users_table ~columns:[ "age" ]
+    ~values:[ Repodb.Driver.Value.int new_age ]
+    ~where_column:"id"
+    ~where_value:(Repodb.Driver.Value.int id)
+
+let delete_user conn id =
+  Repo.delete conn ~table:users_table ~where_column:"id"
+    ~where_value:(Repodb.Driver.Value.int id)
+
+let transaction_insert conn =
+  Repo.transaction conn (fun conn ->
+      let _ = insert_user conn "TxUser" "[e-mail]" 30 in
+      Ok ())
+
+let complex_query conn =
+  Repodb_postgresql.query conn
+    "SELECT u.*, COUNT(p.id) as post_count FROM users u LEFT JOIN posts p ON \
+     u.id = p.user_id GROUP BY u.id ORDER BY post_count DESC LIMIT 10"
+    ~params:[||]
+
+let batch_insert conn n =
+  for i = 1 to n do
+    let _ =
+      insert_user conn
+        (Printf.sprintf "User%d" i)
+        (Printf.sprintf "[e-mail]" i)
+        (20 + (i mod 50))
+    in
+    ()
+  done
+
+let run_benchmarks () =
+  Printf.printf "\n";
+  Printf.printf
+    "╔═══════════════════════════════════════════════════════════════════════════════╗\n";
+  Printf.printf
+    "║                   REPODB POSTGRESQL MEMORY \
+     BENCHMARKS                         ║\n";
+  Printf.printf
+    "╚═══════════════════════════════════════════════════════════════════════════════╝\n";
+
+  let conn = setup () in
+
+  let _ = batch_insert conn 100 in
+
+  let benchmarks =
+    [
+      bench "insert (single row)" ~iterations:1000 (fun () ->
+          insert_user conn "Test" "[e-mail]" 25);
+      bench "query_one (by id)" ~iterations:1000 (fun () ->
+          query_user_by_id conn 1);
+      bench "query_all (100+ rows)" ~iterations:100 (fun () ->
+          query_all_users conn);
+      bench "update (single row)" ~iterations:1000 (fun () ->
+          update_user conn 1 26);
+      bench "delete + insert" ~iterations:500 (fun () ->
+          let _ = delete_user conn 1 in
+          insert_user conn "Replaced" "[e-mail]" 30);
+      bench "transaction (insert)" ~iterations:500 (fun () ->
+          transaction_insert conn);
+      bench "complex query (join+group)" ~iterations:100 (fun () ->
+          complex_query conn);
+    ]
+  in
+
+  run_benchmarks "PostgreSQL Operations" benchmarks;
+
+  let query_table = Repodb.Schema.table "users" in
+  let query_benchmarks =
+    [
+      bench "Query.from + all_query" ~iterations:500 (fun () ->
+          let query = Repodb.Query.from query_table in
+          Repo.all_query conn query ~decode:(fun row ->
+              Repodb.Driver.row_int row 0));
+      bench "Query.where + one_query" ~iterations:500 (fun () ->
+          let query =
+            Repodb.Query.(
+              from query_table |> where Repodb.Expr.(raw "id" = int 1))
+          in
+          Repo.one_query conn query ~decode:(fun row ->
+              Repodb.Driver.row_int row 0));
+      bench "Query.order+limit" ~iterations:500 (fun () ->
+          let query =
+            Repodb.Query.(
+              from query_table |> desc (Repodb.Expr.raw "age") |> limit 10)
+          in
+          Repo.all_query conn query ~decode:(fun row ->
+              Repodb.Driver.row_int row 0));
+      bench "Query.delete" ~iterations:100 (fun () ->
+          let _ = insert_user conn "ToDelete" "[e-mail]" 99 in
+          let query =
+            Repodb.Query.(
+              delete_from query_table
+              |> where Repodb.Expr.(raw "email" = string "[e-mail]"))
+          in
+          Repo.delete_query conn query);
+    ]
+  in
+
+  run_benchmarks "Query DSL Operations" query_benchmarks;
+
+  teardown conn;
+
+  let conn = setup () in
+  Printf.printf "\n";
+  Printf.printf
+    "╔═══════════════════════════════════════════════════════════════════════════════╗\n";
+  Printf.printf
+    "║                           MEMORY LEAK \
+     DETECTION                               ║\n";
+  Printf.printf
+    "╚═══════════════════════════════════════════════════════════════════════════════╝\n";
+
+  let _ =
+    leak_check "insert operations" ~rounds:50 ~ops_per_round:100 (fun () ->
+        insert_user conn "LeakTest" "[e-mail]" 25)
+  in
+
+  let _ = batch_insert conn 1000 in
+
+  let _ =
+    leak_check "query operations" ~rounds:50 ~ops_per_round:100 (fun () ->
+        query_all_users conn)
+  in
+
+  let _ =
+    leak_check "transaction operations" ~rounds:50 ~ops_per_round:50 (fun () ->
+        transaction_insert conn)
+  in
+
+  let _ =
+    leak_check "Query DSL operations" ~rounds:50 ~ops_per_round:100 (fun () ->
+        let query =
+          Repodb.Query.(
+            from query_table
+            |> where Repodb.Expr.(raw "age" > int 25)
+            |> limit 10)
+        in
+        Repo.all_query conn query ~decode:(fun row ->
+            Repodb.Driver.row_int row 0))
+  in
+
+  teardown conn;
+
+  Printf.printf "\n";
+  Printf.printf
+    "╔═══════════════════════════════════════════════════════════════════════════════╗\n";
+  Printf.printf
+    "║                          ALLOCATION \
+     ANALYSIS                                  ║\n";
+  Printf.printf
+    "╚═══════════════════════════════════════════════════════════════════════════════╝\n";
+
+  let conn = setup () in
+  let _ = batch_insert conn 100 in
+
+  Printf.printf "\nSingle operation allocation breakdown:\n\n";
+
+  Gc.full_major ();
+  Gc.compact ();
+  let before = get_stats () in
+  let _ = insert_user conn "SingleTest" "[e-mail]" 30 in
+  let after = get_stats () in
+  print_stats "Single INSERT" (diff_stats before after);
+
+  Gc.full_major ();
+  Gc.compact ();
+  let before = get_stats () in
+  let _ = query_all_users conn in
+  let after = get_stats () in
+  print_stats "Single SELECT (100+ rows)" (diff_stats before after);
+
+  Gc.full_major ();
+  Gc.compact ();
+  let before = get_stats () in
+  let _ =
+    let query =
+      Repodb.Query.(
+        from query_table
+        |> where Repodb.Expr.(raw "age" > int 25)
+        |> desc (Repodb.Expr.raw "age")
+        |> limit 10)
+    in
+    Repo.all_query conn query ~decode:(fun row -> Repodb.Driver.row_int row 0)
+  in
+  let after = get_stats () in
+  print_stats "Query DSL (build + execute)" (diff_stats before after);
+
+  Gc.full_major ();
+  Gc.compact ();
+  let before = get_stats () in
+  let _ =
+    Repo.transaction conn (fun conn ->
+        insert_user conn "TxTest" "[e-mail]" 30)
+  in
+  let after = get_stats () in
+  print_stats "Transaction (with INSERT)" (diff_stats before after);
+
+  teardown conn;
+
+  Printf.printf
+    "╔═══════════════════════════════════════════════════════════════════════════════╗\n";
+  Printf.printf
+    "║                            BENCHMARK \
+     COMPLETE                                 ║\n";
+  Printf.printf
+    "╚═══════════════════════════════════════════════════════════════════════════════╝\n"
+
+let () = run_benchmarks ()

bench/bench_sqlite.ml

···
+open Mem_bench
+
+let db_path = "/tmp/repodb_bench.db"
+
+let setup () =
+  (try Sys.remove db_path with Sys_error _ -> ());
+  match Repodb_sqlite.connect db_path with
+  | Error e -> failwith (Repodb_sqlite.error_message e)
+  | Ok conn ->
+      let _ =
+        Repodb_sqlite.exec conn
+          "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT NOT NULL, \
+           email TEXT, age INTEGER, active INTEGER DEFAULT 1)"
+          ~params:[||]
+      in
+      let _ =
+        Repodb_sqlite.exec conn
+          "CREATE TABLE posts (id INTEGER PRIMARY KEY, user_id INTEGER, title \
+           TEXT, body TEXT, created_at TEXT)"
+          ~params:[||]
+      in
+      let _ =
+        Repodb_sqlite.exec conn
+          "CREATE INDEX idx_posts_user_id ON posts(user_id)" ~params:[||]
+      in
+      conn
+
+let teardown conn =
+  Repodb_sqlite.close conn;
+  try Sys.remove db_path with Sys_error _ -> ()
+
+module Repo = Repodb.Repo.Make (Repodb_sqlite)
+
+let users_table = Repodb.Schema.table "users"
+
+let insert_user conn name email age =
+  Repo.insert conn ~table:users_table ~columns:[ "name"; "email"; "age" ]
+    ~values:
+      [
+        Repodb.Driver.Value.text name;
+        Repodb.Driver.Value.text email;
+        Repodb.Driver.Value.int age;
+      ]
+
+let query_all_users conn =
+  Repodb_sqlite.query conn "SELECT * FROM users" ~params:[||]
+
+let query_user_by_id conn id =
+  Repodb_sqlite.query_one conn "SELECT * FROM users WHERE id = ?"
+    ~params:[| Repodb.Driver.Value.int id |]
+
+let update_user conn id new_age =
+  Repo.update conn ~table:users_table ~columns:[ "age" ]
+    ~values:[ Repodb.Driver.Value.int new_age ]
+    ~where_column:"id"
+    ~where_value:(Repodb.Driver.Value.int id)
+
+let delete_user conn id =
+  Repo.delete conn ~table:users_table ~where_column:"id"
+    ~where_value:(Repodb.Driver.Value.int id)
+
+let transaction_insert conn =
+  Repo.transaction conn (fun conn ->
+      let _ = insert_user conn "TxUser" "[e-mail]" 30 in
+      Ok ())
+
+let complex_query conn =
+  Repodb_sqlite.query conn
+    "SELECT u.*, COUNT(p.id) as post_count FROM users u LEFT JOIN posts p ON \
+     u.id = p.user_id GROUP BY u.id ORDER BY post_count DESC LIMIT 10"
+    ~params:[||]
+
+let batch_insert conn n =
+  for i = 1 to n do
+    let _ =
+      insert_user conn
+        (Printf.sprintf "User%d" i)
+        (Printf.sprintf "[e-mail]" i)
+        (20 + (i mod 50))
+    in
+    ()
+  done
+
+let run_benchmarks () =
+  Printf.printf "\n";
+  Printf.printf
+    "╔═══════════════════════════════════════════════════════════════════════════════╗\n";
+  Printf.printf
+    "║                     REPODB SQLITE MEMORY \
+     BENCHMARKS                           ║\n";
+  Printf.printf
+    "╚═══════════════════════════════════════════════════════════════════════════════╝\n";
+
+  let conn = setup () in
+
+  let _ = batch_insert conn 100 in
+
+  let benchmarks =
+    [
+      bench "insert (single row)" ~iterations:1000 (fun () ->
+          insert_user conn "Test" "[e-mail]" 25);
+      bench "query_one (by id)" ~iterations:1000 (fun () ->
+          query_user_by_id conn 1);
+      bench "query_all (100 rows)" ~iterations:100 (fun () ->
+          query_all_users conn);
+      bench "update (single row)" ~iterations:1000 (fun () ->
+          update_user conn 1 26);
+      bench "delete + insert" ~iterations:500 (fun () ->
+          let _ = delete_user conn 1 in
+          insert_user conn "Replaced" "[e-mail]" 30);
+      bench "transaction (insert)" ~iterations:500 (fun () ->
+          transaction_insert conn);
+      bench "complex query (join+group)" ~iterations:100 (fun () ->
+          complex_query conn);
+    ]
+  in
+
+  run_benchmarks "SQLite Operations" benchmarks;
+
+  let query_table = Repodb.Schema.table "users" in
+  let query_benchmarks =
+    [
+      bench "Query.from + all_query" ~iterations:500 (fun () ->
+          let query = Repodb.Query.from query_table in
+          Repo.all_query conn query ~decode:(fun row ->
+              Repodb.Driver.row_int row 0));
+      bench "Query.where + one_query" ~iterations:500 (fun () ->
+          let query =
+            Repodb.Query.(
+              from query_table |> where Repodb.Expr.(raw "id" = int 1))
+          in
+          Repo.one_query conn query ~decode:(fun row ->
+              Repodb.Driver.row_int row 0));
+      bench "Query.order+limit" ~iterations:500 (fun () ->
+          let query =
+            Repodb.Query.(
+              from query_table |> desc (Repodb.Expr.raw "age") |> limit 10)
+          in
+          Repo.all_query conn query ~decode:(fun row ->
+              Repodb.Driver.row_int row 0));
+      bench "Query.delete" ~iterations:100 (fun () ->
+          let _ = insert_user conn "ToDelete" "[e-mail]" 99 in
+          let query =
+            Repodb.Query.(
+              delete_from query_table
+              |> where Repodb.Expr.(raw "email" = string "[e-mail]"))
+          in
+          Repo.delete_query conn query);
+    ]
+  in
+
+  run_benchmarks "Query DSL Operations" query_benchmarks;
+
+  teardown conn;
+
+  let conn = setup () in
+  Printf.printf "\n";
+  Printf.printf
+    "╔═══════════════════════════════════════════════════════════════════════════════╗\n";
+  Printf.printf
+    "║                           MEMORY LEAK \
+     DETECTION                               ║\n";
+  Printf.printf
+    "╚═══════════════════════════════════════════════════════════════════════════════╝\n";
+
+  let _ =
+    leak_check "insert operations" ~rounds:50 ~ops_per_round:100 (fun () ->
+        insert_user conn "LeakTest" "[e-mail]" 25)
+  in
+
+  let _ = batch_insert conn 1000 in
+
+  let _ =
+    leak_check "query operations" ~rounds:50 ~ops_per_round:100 (fun () ->
+        query_all_users conn)
+  in
+
+  let _ =
+    leak_check "transaction operations" ~rounds:50 ~ops_per_round:50 (fun () ->
+        transaction_insert conn)
+  in
+
+  let _ =
+    leak_check "Query DSL operations" ~rounds:50 ~ops_per_round:100 (fun () ->
+        let query =
+          Repodb.Query.(
+            from query_table
+            |> where Repodb.Expr.(raw "age" > int 25)
+            |> limit 10)
+        in
+        Repo.all_query conn query ~decode:(fun row ->
+            Repodb.Driver.row_int row 0))
+  in
+
+  teardown conn;
+
+  Printf.printf "\n";
+  Printf.printf
+    "╔═══════════════════════════════════════════════════════════════════════════════╗\n";
+  Printf.printf
+    "║                          ALLOCATION \
+     ANALYSIS                                  ║\n";
+  Printf.printf
+    "╚═══════════════════════════════════════════════════════════════════════════════╝\n";
+
+  let conn = setup () in
+  let _ = batch_insert conn 100 in
+
+  Printf.printf "\nSingle operation allocation breakdown:\n\n";
+
+  Gc.full_major ();
+  Gc.compact ();
+  let before = get_stats () in
+  let _ = insert_user conn "SingleTest" "[e-mail]" 30 in
+  let after = get_stats () in
+  print_stats "Single INSERT" (diff_stats before after);
+
+  Gc.full_major ();
+  Gc.compact ();
+  let before = get_stats () in
+  let _ = query_all_users conn in
+  let after = get_stats () in
+  print_stats "Single SELECT (100 rows)" (diff_stats before after);
+
+  Gc.full_major ();
+  Gc.compact ();
+  let before = get_stats () in
+  let _ =
+    let query =
+      Repodb.Query.(
+        from query_table
+        |> where Repodb.Expr.(raw "age" > int 25)
+        |> desc (Repodb.Expr.raw "age")
+        |> limit 10)
+    in
+    Repo.all_query conn query ~decode:(fun row -> Repodb.Driver.row_int row 0)
+  in
+  let after = get_stats () in
+  print_stats "Query DSL (build + execute)" (diff_stats before after);
+
+  Gc.full_major ();
+  Gc.compact ();
+  let before = get_stats () in
+  let _ =
+    Repo.transaction conn (fun conn ->
+        insert_user conn "TxTest" "[e-mail]" 30)
+  in
+  let after = get_stats () in
+  print_stats "Transaction (with INSERT)" (diff_stats before after);
+
+  teardown conn;
+
+  Printf.printf
+    "╔═══════════════════════════════════════════════════════════════════════════════╗\n";
+  Printf.printf
+    "║                            BENCHMARK \
+     COMPLETE                                 ║\n";
+  Printf.printf
+    "╚═══════════════════════════════════════════════════════════════════════════════╝\n"
+
+let () = run_benchmarks ()

bench/dune

···
+(library
+ (name mem_bench)
+ (modules mem_bench)
+ (libraries unix))
+
+(executable
+ (name bench_sqlite)
+ (libraries mem_bench repodb repodb_sqlite unix)
+ (modules bench_sqlite))
+
+(executable
+ (name bench_postgresql)
+ (libraries mem_bench repodb repodb_postgresql unix)
+ (modules bench_postgresql))

bench/mem_bench.ml

···
+type alloc_stats = {
+  minor_words : float;
+  major_words : float;
+  minor_collections : int;
+  major_collections : int;
+  heap_words : int;
+  live_words : int;
+}
+
+let get_stats () =
+  Gc.full_major ();
+  let stat = Gc.stat () in
+  {
+    minor_words = stat.minor_words;
+    major_words = stat.major_words;
+    minor_collections = stat.minor_collections;
+    major_collections = stat.major_collections;
+    heap_words = stat.heap_words;
+    live_words = stat.live_words;
+  }
+
+let diff_stats before after =
+  {
+    minor_words = after.minor_words -. before.minor_words;
+    major_words = after.major_words -. before.major_words;
+    minor_collections = after.minor_collections - before.minor_collections;
+    major_collections = after.major_collections - before.major_collections;
+    heap_words = after.heap_words - before.heap_words;
+    live_words = after.live_words - before.live_words;
+  }
+
+let print_stats label stats =
+  Printf.printf "=== %s ===\n" label;
+  Printf.printf "  Minor words: %.0f (%.2f KB)\n" stats.minor_words
+    (stats.minor_words *. 8.0 /. 1024.0);
+  Printf.printf "  Major words: %.0f (%.2f KB)\n" stats.major_words
+    (stats.major_words *. 8.0 /. 1024.0);
+  Printf.printf "  Minor GCs: %d\n" stats.minor_collections;
+  Printf.printf "  Major GCs: %d\n" stats.major_collections;
+  Printf.printf "  Heap words: %d (%.2f KB)\n" stats.heap_words
+    (float_of_int stats.heap_words *. 8.0 /. 1024.0);
+  Printf.printf "  Live words: %d (%.2f KB)\n" stats.live_words
+    (float_of_int stats.live_words *. 8.0 /. 1024.0);
+  Printf.printf "\n"
+
+type bench_result = {
+  name : string;
+  iterations : int;
+  total_time_ms : float;
+  per_op_time_us : float;
+  allocs : alloc_stats;
+  allocs_per_op : float;
+}
+
+let print_bench_result r =
+  Printf.printf "%-30s | %6d iters | %8.2f ms | %8.2f µs/op | %10.0f words/op\n"
+    r.name r.iterations r.total_time_ms r.per_op_time_us r.allocs_per_op
+
+let bench name ~iterations f =
+  Gc.full_major ();
+  Gc.compact ();
+  let before = get_stats () in
+  let t0 = Unix.gettimeofday () in
+  for _ = 1 to iterations do
+    ignore (f ())
+  done;
+  let t1 = Unix.gettimeofday () in
+  let after = get_stats () in
+  let allocs = diff_stats before after in
+  let total_time_ms = (t1 -. t0) *. 1000.0 in
+  let per_op_time_us = total_time_ms *. 1000.0 /. float_of_int iterations in
+  let allocs_per_op = allocs.minor_words /. float_of_int iterations in
+  { name; iterations; total_time_ms; per_op_time_us; allocs; allocs_per_op }
+
+let leak_check name ~rounds ~ops_per_round f =
+  Printf.printf "\n=== Leak Check: %s ===\n" name;
+  Printf.printf "Running %d rounds of %d operations each...\n\n" rounds
+    ops_per_round;
+  let heap_sizes = Array.make rounds 0 in
+  let live_sizes = Array.make rounds 0 in
+  for round = 0 to rounds - 1 do
+    for _ = 1 to ops_per_round do
+      ignore (f ())
+    done;
+    Gc.full_major ();
+    Gc.compact ();
+    let stat = Gc.stat () in
+    heap_sizes.(round) <- stat.heap_words;
+    live_sizes.(round) <- stat.live_words;
+    if round mod 10 = 0 || round = rounds - 1 then
+      Printf.printf "  Round %3d: heap=%d words, live=%d words\n" (round + 1)
+        stat.heap_words stat.live_words
+  done;
+  let first_heap = heap_sizes.(0) in
+  let last_heap = heap_sizes.(rounds - 1) in
+  let first_live = live_sizes.(0) in
+  let last_live = live_sizes.(rounds - 1) in
+  let heap_growth = last_heap - first_heap in
+  let live_growth = last_live - first_live in
+  Printf.printf "\nResults:\n";
+  Printf.printf "  Heap growth: %d words (%.2f KB)\n" heap_growth
+    (float_of_int heap_growth *. 8.0 /. 1024.0);
+  Printf.printf "  Live growth: %d words (%.2f KB)\n" live_growth
+    (float_of_int live_growth *. 8.0 /. 1024.0);
+  if live_growth > 1000 then
+    Printf.printf "  ⚠️  POTENTIAL LEAK: Live memory grew by %d words\n"
+      live_growth
+  else Printf.printf "  ✓ No significant memory leak detected\n";
+  (heap_growth, live_growth)
+
+let run_benchmarks name benchmarks =
+  Printf.printf "\n";
+  Printf.printf
+    "╔═══════════════════════════════════════════════════════════════════════════════╗\n";
+  Printf.printf "║ %-77s ║\n" (Printf.sprintf "BENCHMARK: %s" name);
+  Printf.printf
+    "╠═══════════════════════════════════════════════════════════════════════════════╣\n";
+  Printf.printf "║ %-30s | %6s | %8s | %11s | %14s ║\n" "Operation" "Iters"
+    "Total" "Per Op" "Allocs/Op";
+  Printf.printf
+    "╠═══════════════════════════════════════════════════════════════════════════════╣\n";
+  List.iter
+    (fun r ->
+      Printf.printf "║ %-30s | %6d | %6.1f ms | %8.2f µs | %11.0f w ║\n" r.name
+        r.iterations r.total_time_ms r.per_op_time_us r.allocs_per_op)
+    benchmarks;
+  Printf.printf
+    "╚═══════════════════════════════════════════════════════════════════════════════╝\n"