diff --git a/README.md b/README.md
index 5c6d123..bdd2f98 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,7 @@ driver, PyMongo — connect over TCP and just work.
 zig build                # build the server
 zig build test           # run the unit test suite
 
-zig-out/bin/mongo-lite --port 27017 --db data.log
+zig-out/bin/mongo-lite --port 27017 --db data.log --compact-threshold 256m
 
 # in another terminal:
 mongosh --port 27017
@@ -53,10 +53,11 @@ mongosh --port 27017
   `$rename`, with dot-path creation (including array indices).
 - **Storage**: append-only record log (CRC32-checked, `fsync` per write,
   torn-tail tolerant) with in-memory indexes rebuilt on open and automatic
-  compaction (rewrite + atomic rename when the log grows past 16 MB).
-  Killed mid-write (`kill -9`), the database recovers all committed writes;
-  the log and compaction both work with relative or absolute `--db` paths.
-  Records up to the announced 16 MB `maxBsonObjectSize` replay correctly.
+  compaction (rewrite + atomic rename when the log grows past
+  `--compact-threshold`, default 16 MB). Killed mid-write (`kill -9`), the
+  database recovers all committed writes; the log and compaction both work
+  with relative or absolute `--db` paths. Records up to the announced 16 MB
+  `maxBsonObjectSize` replay correctly.
 - **Concurrency**: a writer-preferring read/write lock splits command
   execution — reads (`find`, `count`, `aggregate`, `list*`) run concurrently
   across connections, writes (CRUD, DDL) are exclusive and totally ordered,
@@ -77,7 +78,7 @@ src/
   query.zig    filter matcher, regex engine, sort, projection
   index.zig    secondary indexes: entries, search, query planner
   update.zig   update operators with dot-path navigation
-  main.zig     CLI: --port, --bind, --db, --ttl-sweep-secs
+  main.zig     CLI: --port, --bind, --db, --ttl-sweep-secs, --compact-threshold
 ```
 
 ## Indexes
@@ -139,9 +140,100 @@ longer one.
 - `collMod`, so an index's `expireAfterSeconds` cannot be changed in
   place — drop the index and re-create it with the new expiry
 - `dropCollection`/`dropDatabase` write no log record, so a dropped
-  collection (and its index definitions) resurrect on restart; and
-  compaction never resets `log_bytes`, so every write after the first
-  compaction re-triggers the threshold check
+  collection (and its index definitions) resurrect on restart
+
+## Working with large collections
+
+Everything lives in RAM (db → collection → _id → document maps) and every
+write command is logged with `fsync` before it is acknowledged (one sync per
+command via group commit — a 500-doc `insertMany` syncs once, not 500
+times), so multi-GB collections work, with cost/behavior notes measured by
+the `tests/e2e/big.js` harness (12-core/32 GB Mac):
+
+- **Build in ReleaseFast** — `zig build` defaults to it. A Debug server is
+  10-200x slower on every path (the matcher alone was 70 µs/doc in Debug
+  vs 0.4 µs in ReleaseFast), which dwarfed every other difference in the
+  MongoDB comparison below.
+- **Compaction is O(n²) under the default 16 MB threshold.** A compaction
+  rewrites the whole log (one fsync per record), so bulk-loading 5 GB with
+  the default threshold degrades from ~310 MB/s to a crawl as the dataset
+  grows. Raise `--compact-threshold` for bulk loads — e.g. `2g` — and the
+  rate stays flat. The 5.37 GB run (40,960 × 128 KB docs, ObjectIds,
+  ReleaseFast) inserted in 36.5 s at ~310 MB/s between the two threshold
+  compactions, peaked at 5.25 GB RSS (~0.98x the data size at 128 KB
+  docs), and reopened the 5 GB log in 13.8 s.
+- **`findOne({_id})` is O(1) only for ObjectId ids.** Integer, int64 and
+  double ids compare equal but hash differently, so the docs-map fast path
+  is skipped and every `_id` lookup becomes a full scan. Use the driver's
+  default ObjectIds (or a secondary index) on big collections.
+- **Secondary-index entry insert is O(n)** (sorted array — see v1 limits
+  above), so creating an index over existing data or inserting with an
+  index in place is quadratic. Create indexes after the load.
+
+## Performance vs MongoDB
+
+`tests/e2e/compare-run.sh` runs the same driver workload (1 GB, 65,536 ×
+16 KB docs, every write durable — mongo-lite fsyncs per command, mongod
+runs with `j: true`) against each server and prints a side-by-side table.
+With the ReleaseFast default build (MongoDB 8.3.7 on the same Mac):
+
+| benchmark | mongo-lite | mongodb | winner |
+|---|---|---|---|
+| insertOne (sequential) | 0.2 ms | 4.9 ms | **mongo-lite ×24** |
+| bulk insert (insertMany) | 267 MB/s | 690 MB/s | mongodb ×2.6 |
+| createIndex({k: 1}) | 0.66 s | 0.08 s | mongodb ×8 |
+| countDocuments({}) | 2.5 ms | 11 ms | **mongo-lite ×4** |
+| findOne({_id}) | 0.6 ms | 0.7 ms | mongo-lite |
+| findOne indexed | 0.7 ms | 2.6 ms | **mongo-lite ×4** |
+| range-scan count | 25 ms | 13 ms | mongodb ×2 |
+| sort + limit(20) | 40 ms | 2 ms | mongodb ×20 |
+| aggregate $group | 12 ms | 13 ms | mongo-lite |
+| updateOne({_id}) | 0.18 ms | 0.21 ms | mongo-lite |
+| updateMany (65 docs) | 20 ms | 6 ms | mongodb ×3 |
+| deleteOne + insert | 0.9 ms | 5 ms | **mongo-lite ×6** |
+| server RSS | 2.0 GB | 1.3 GB | mongodb (×0.65) |
+| kill -9 → reopen | 3.8 s | 1.3 s | mongodb |
+| db on disk | 1.0 GB | 89 MB | mongodb (compressed) |
+
+The pattern: mongo-lite wins every *latency-bound* single-op (no network of
+index hops, no journal latency, in-RAM) and loses the *throughput-bound*
+bulk paths and the ops MongoDB accelerates with disk indexes and
+compression.
+
+### Suggested improvements (highest impact first)
+
+1. **Index-accelerated sort** — the worst gap (×20): `sort+limit` sorts
+   every document. Stream candidates in index order (the planner already
+   has ordered range search) and stop at `limit`. Fixes the biggest read
+   regression.
+2. **Batch index builds** — `createIndex` inserts entries one at a time
+   into a sorted array (O(n²) memmoves). Sort all entries once and append
+   in bulk (O(n log n)); a B-tree or id→entry map removes the O(n) entry
+   insert on the write path too.
+3. **Compress the log** — the db is 11× MongoDB's on disk because payloads
+   are stored raw. Snappy per record (like the wire protocol's OP_COMPRESSED)
+   would shrink highly-compressible workloads massively.
+4. **Faster reopen** — replay is a full re-parse of every record. A
+   periodic checkpoint record (or a parallel replay) would cut the 3×
+   restart gap.
+5. **Trim the write path** — bulk insert (×2.6) is now bound by per-doc
+   parse/serialize/map-put, not fsync. A pooled per-connection arena for
+   owned docs and a bulk-insert fast path would close most of the gap;
+   updateMany's per-doc replace-serialize is the same story.
+6. **Range-scan matching (×2)** — the matcher allocates a candidates list
+   per field per doc; a stack buffer for the common single-field case
+   removes it.
+
+Two real bugs were found and fixed while benchmarking:
+
+- `plan_id` returned a pointer to a stack temporary (`&.{e}`) that dangled
+  after the frame returned — Debug tolerated it, ReleaseFast read garbage,
+  silently breaking every `findOne({_id: <ObjectId>})`. It now heap-copies
+  the lookup value and frees it.
+- Multi-doc writes fsynced once per document; they now group-commit (one
+  fsync per command, same crash guarantees — verified by the kill -9
+  crash suites).
+
 
 ## Code style
 
diff --git a/build.zig b/build.zig
index 295b902..2ccec24 100644
--- a/build.zig
+++ b/build.zig
@@ -2,7 +2,10 @@ const std = @import("std");
 
 pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
-    const optimize = b.standardOptimizeOption(.{});
+    // ReleaseFast by default: a Debug server is 10-200x slower (measured in
+    // tests/e2e/compare-run.sh). Devs can still opt into Debug or
+    // ReleaseSafe with -Doptimize=Debug / -Doptimize=ReleaseSafe.
+    const optimize = b.option(std.builtin.OptimizeMode, "optimize", "Prioritize performance, safety, or binary size") orelse .ReleaseFast;
 
     const lib_mod = b.createModule(.{
         .root_source_file = b.path("src/lib.zig"),
diff --git a/src/commands.zig b/src/commands.zig
index a37d1f9..7e05ecd 100644
--- a/src/commands.zig
+++ b/src/commands.zig
@@ -515,6 +515,12 @@ fn cmd_insert(ctx: *Context, msg: *wire.Message, reply: *wire.Reply) !void {
     var write_errors: std.ArrayListUnmanaged(bson.Value) = .empty;
     defer write_errors.deinit(reply.arena_alloc());
 
+    // Group commit: one fsync for the whole batch instead of one per
+    // document. end_batch runs on every return path, so even a failed doc
+    // (writeErrors) or a hard error still syncs what was appended.
+    ctx.engine.begin_batch();
+    defer ctx.engine.end_batch() catch {};
+
     for (docs, 0..) |*doc, i| {
         if (ctx.engine.insert(db_name, coll_name, doc, ctx.oid_gen)) |_| {
             inserted += 1;
@@ -594,12 +600,14 @@ fn scan_matching(
     // _id_ fast path: the docs map is the _id index. Skipped when the
     // queried value's compare-equivalence class is serialization-ambiguous
     // (see index.plan_id).
-    if (index.plan_id(filter)) |id_plan| {
+    if (try index.plan_id(ctx.gpa, filter)) |id_plan| {
+        var plan = id_plan;
+        defer plan.deinit(ctx.gpa);
         // One scratch key, rebuilt per value: a key is never needed past its
         // own lookup.
         var key: std.ArrayListUnmanaged(u8) = .empty;
         defer key.deinit(ctx.gpa);
-        for (id_plan.values) |v| {
+        for (plan.values) |v| {
             key.clearRetainingCapacity();
             try bson.write_serialized_value(v, ctx.gpa, &key);
             const doc = coll.docs.get(key.items) orelse continue;
@@ -671,6 +679,10 @@ fn cmd_update(ctx: *Context, msg: *wire.Message, reply: *wire.Reply) !void {
     var write_errors: std.ArrayListUnmanaged(bson.Value) = .empty;
     defer write_errors.deinit(reply.arena_alloc());
 
+    // Group commit for multi-document updates: one fsync per command.
+    ctx.engine.begin_batch();
+    defer ctx.engine.end_batch() catch {};
+
     for (specs, 0..) |*spec, si| {
         const q = doc_arg(spec.get("q")) orelse return bad_value(reply, "update spec requires q");
         const u_doc = doc_arg(spec.get("u")) orelse return bad_value(reply, "update spec requires u");
@@ -744,6 +756,10 @@ fn cmd_delete(ctx: *Context, msg: *wire.Message, reply: *wire.Reply) !void {
     const specs = try batch_arg(msg, reply, "delete", "deletes") orelse return;
 
     var n_deleted: i64 = 0;
+    // Group commit for multi-document deletes: one fsync per command.
+    ctx.engine.begin_batch();
+    defer ctx.engine.end_batch() catch {};
+
     for (specs) |*spec| {
         const q = doc_arg(spec.get("q")) orelse return bad_value(reply, "delete spec requires q");
         const limit = int_value(spec.get("limit")) orelse 1;
diff --git a/src/db.zig b/src/db.zig
index f1b25ce..658d91e 100644
--- a/src/db.zig
+++ b/src/db.zig
@@ -55,7 +55,15 @@ pub const Engine = struct {
     log: storage.Log,
     dbs: std.StringHashMapUnmanaged(Db),
     seq: u64,
+    /// Floor for the compaction trigger. The real trigger also scales with
+    /// the live data size — see `maybe_compact`.
     compact_threshold: u64,
+    /// Documents currently resident across every collection, and documents
+    /// superseded or deleted since the last compaction. Their ratio is the
+    /// share of the log that is garbage, which is what decides whether a
+    /// rewrite is worth doing — see `maybe_compact`.
+    live_docs: u64 = 0,
+    dead_docs: u64 = 0,
     /// Set to the failing index's own stable name when an upsert is
     /// rejected by a unique secondary index (error.DuplicateKeyIndex). The
     /// command reads it while still holding the write lock.
@@ -97,6 +105,9 @@ pub const Engine = struct {
     /// and secondary indexes (whose entries alias the documents — freed
     /// first).
     fn free_collection(self: *Engine, coll: *Collection) void {
+        // Dropping a collection turns all of its records into garbage.
+        self.live_docs -= coll.docs.count();
+        self.dead_docs += coll.docs.count();
         for (coll.indexes.items) |*ix| ix.deinit(self.gpa);
         coll.indexes.deinit(self.gpa);
         var doc_it = coll.docs.iterator();
@@ -129,6 +140,9 @@ pub const Engine = struct {
         old.value.*.deinit();
         self.gpa.destroy(old.value);
         self.gpa.free(old.key);
+        // This document's log record just became garbage.
+        self.live_docs -= 1;
+        self.dead_docs += 1;
     }
 
     // -- commands (callers must hold the matching lock) ---------------------
@@ -152,6 +166,21 @@ pub const Engine = struct {
         self.rwlock.unlockShared(self.io);
     }
 
+    /// Group commit: defer per-record fsyncs until end_batch. Callers must
+    /// hold the write lock and pair every begin with an end (the command's
+    /// defer). Every document published before end_batch is fsynced by it,
+    /// so an acknowledged multi-write command is durable as a unit — the
+    /// same crash guarantee as the old fsync-per-record, with one sync per
+    /// command instead of one per document.
+    pub fn begin_batch(self: *Engine) void {
+        self.log.defer_sync = true;
+    }
+
+    pub fn end_batch(self: *Engine) !void {
+        self.log.defer_sync = false;
+        try self.log.sync();
+    }
+
     /// Insert a document. Fails with error.DuplicateKey if the _id exists.
     /// Generates an ObjectId _id when absent.
     pub fn insert(self: *Engine, db_name: []const u8, coll_name: []const u8, doc: *const bson.Document, oid_gen: *bson.ObjectIdGen) !void {
@@ -240,6 +269,7 @@ pub const Engine = struct {
 
         // 7. Publish the document and its entries.
         try coll.docs.put(self.gpa, id_key, owned);
+        self.live_docs += 1;
         for (built_list.items) |*b| {
             if (b.built.multikey) b.ix.multikey = true;
             b.ix.insert_entries(&b.built);
@@ -273,6 +303,9 @@ pub const Engine = struct {
         try self.log.append_delete(db_name, coll_name, id_doc.items, self.seq);
 
         self.evict_doc(coll, id_key);
+        // Deletes grow the log too. Without this a delete-heavy workload
+        // never compacts, because only upsert and ttl_sweep used to check.
+        try self.maybe_compact();
         return true;
     }
 
@@ -477,8 +510,34 @@ pub const Engine = struct {
         return owned;
     }
 
+    /// Keep the log file at roughly 1.5x the live data, rather than
+    /// compacting every fixed number of appended bytes.
+    ///
+    /// A fixed byte trigger makes total rewrite traffic quadratic: a 1 GB
+    /// dataset with a 16 MiB threshold compacts ~64 times, rewriting 1 GB
+    /// each time. Triggering on file size relative to the live size makes
+    /// successive compactions geometric, so the total bytes rewritten over
+    /// the life of the log is O(n) rather than O(n²) — and it bounds the
+    /// disk footprint directly, which is what the threshold is really for.
+    ///
+    /// The other half of the problem is the opposite workload: a pure bulk
+    /// insert has no garbage at all, so every compaction rewrites a
+    /// perfectly compact file for nothing. `compact` reports how much it
+    /// reclaimed; when that is little, we back the baseline off
+    /// multiplicatively so a garbage-free log is left alone.
     fn maybe_compact(self: *Engine) !void {
-        if (self.log.log_bytes < self.compact_threshold) return;
+        if (self.log.end_pos < self.compact_threshold) return;
+        // Only rewrite when enough of the log is actually garbage. The old
+        // rule fired on bytes appended, which is the wrong question twice
+        // over: a 1 GB bulk load has no garbage at all yet would compact
+        // ~64 times under a 16 MiB threshold (rewriting 1 GB each time,
+        // hence quadratic), while a small collection rewritten in place
+        // accumulates garbage indefinitely without ever hitting the count.
+        //
+        // Garbage share is dead / (live + dead); this fires at ~20%, so the
+        // file stays near 1.25x the live data and each compaction is paid
+        // for by the space it reclaims.
+        if (self.dead_docs * 4 < self.live_docs) return;
         try self.compact();
     }
 
@@ -490,6 +549,10 @@ pub const Engine = struct {
         std.Io.Dir.cwd().deleteFile(self.io, tmp_path) catch {};
         var new_log = try storage.Log.open(self.gpa, self.io, tmp_path);
         defer new_log.close();
+        // One fsync for the whole rewrite, not one per document. The
+        // rewrite's durability comes from the rename below, which is only
+        // safe to publish after a single sync of the finished file.
+        new_log.defer_sync = true;
 
         var db_it = self.dbs.iterator();
         while (db_it.next()) |db_entry| {
@@ -513,6 +576,8 @@ pub const Engine = struct {
             }
         }
         const new_end_pos = new_log.end_pos;
+        // Durable before the rename makes it the database.
+        try new_log.sync();
 
         try std.Io.Dir.renameAbsolute(tmp_path, self.log.path, self.io);
         // Persist the rename: fsync the parent directory so the new
@@ -523,11 +588,18 @@ pub const Engine = struct {
         try dir_file.sync(self.io);
 
         const old_path = try self.gpa.dupe(u8, self.log.path);
+        // A batch may span a compaction (a large insert crossing the
+        // threshold): keep the deferred-sync mode on the swapped-in log so
+        // the remaining batch records stay grouped with the same command.
+        const deferred = self.log.defer_sync;
         self.log.close();
         self.log = try storage.Log.open(self.gpa, self.io, old_path);
+        self.log.defer_sync = deferred;
         // Log.open starts at end_pos 0 and does not replay; continue appending
         // where the compacted file actually ends.
         self.log.end_pos = new_end_pos;
+        // The rewritten log holds only live documents.
+        self.dead_docs = 0;
         self.gpa.free(old_path);
     }
 
@@ -637,6 +709,7 @@ fn apply_record(ctx: *anyopaque, record: storage.Record, doc: *bson.Document) an
         storage.record_type_upsert => {
             self.evict_doc(coll, id_key);
             try coll.docs.put(self.gpa, id_key, doc);
+            self.live_docs += 1;
             key_owned = true;
             stored = true;
         },
@@ -708,6 +781,98 @@ test "insert, query, remove" {
     engine.unlock();
 }
 
+test "live/dead doc accounting drives compaction" {
+    var threaded: std.Io.Threaded = .init_single_threaded;
+    defer threaded.deinit();
+    var env = test_env(&threaded);
+    const io = env.io;
+    const gpa = testing.allocator;
+
+    var tmp = try TmpLog.init(gpa);
+    defer tmp.deinit(gpa);
+    var engine = try Engine.open(gpa, io, tmp.path);
+    defer engine.deinit();
+    // Keep compaction from firing and resetting dead_docs mid-test.
+    engine.compact_threshold = std.math.maxInt(u64);
+
+    var d1 = try make_doc(gpa, 1, "alice");
+    defer d1.deinit();
+    var d2 = try make_doc(gpa, 2, "bob");
+    defer d2.deinit();
+
+    try engine.lock();
+    defer engine.unlock();
+
+    try engine.insert("app", "users", &d1, &env.gen);
+    try engine.insert("app", "users", &d2, &env.gen);
+    try testing.expectEqual(@as(u64, 2), engine.live_docs);
+    try testing.expectEqual(@as(u64, 0), engine.dead_docs);
+
+    // A replace supersedes one record: live is unchanged, garbage grows.
+    var d1b = try make_doc(gpa, 1, "alice2");
+    defer d1b.deinit();
+    try engine.replace("app", "users", &d1b, &env.gen);
+    try testing.expectEqual(@as(u64, 2), engine.live_docs);
+    try testing.expectEqual(@as(u64, 1), engine.dead_docs);
+
+    // A delete drops a live doc and leaves its record behind as garbage.
+    try testing.expect(try engine.remove_by_id("app", "users", .{ .int32 = 2 }));
+    try testing.expectEqual(@as(u64, 1), engine.live_docs);
+    try testing.expectEqual(@as(u64, 2), engine.dead_docs);
+
+    // Removing something absent must not move either counter.
+    try testing.expect(!try engine.remove_by_id("app", "users", .{ .int32 = 99 }));
+    try testing.expectEqual(@as(u64, 1), engine.live_docs);
+    try testing.expectEqual(@as(u64, 2), engine.dead_docs);
+
+    // Dropping the collection accounts for everything it still held, and
+    // must leave live_docs at zero rather than wrapping.
+    try testing.expect(try engine.drop_collection("app", "users"));
+    try testing.expectEqual(@as(u64, 0), engine.live_docs);
+    try testing.expectEqual(@as(u64, 3), engine.dead_docs);
+}
+
+test "compaction reclaims garbage but leaves a garbage-free log alone" {
+    var threaded: std.Io.Threaded = .init_single_threaded;
+    defer threaded.deinit();
+    var env = test_env(&threaded);
+    const io = env.io;
+    const gpa = testing.allocator;
+
+    var tmp = try TmpLog.init(gpa);
+    defer tmp.deinit(gpa);
+    var engine = try Engine.open(gpa, io, tmp.path);
+    defer engine.deinit();
+    engine.compact_threshold = 4096; // small enough to be crossed here
+
+    try engine.lock();
+    defer engine.unlock();
+
+    // Pure inserts produce no garbage, so the log must never be rewritten.
+    for (0..200) |i| {
+        var d = try make_doc(gpa, @intCast(i), "x");
+        defer d.deinit();
+        try engine.insert("app", "c", &d, &env.gen);
+    }
+    try testing.expectEqual(@as(u64, 0), engine.dead_docs);
+    const after_insert = engine.log.end_pos;
+    try testing.expect(after_insert > engine.compact_threshold);
+
+    // Rewriting every document makes the log mostly garbage; compaction
+    // must fire and bring the file back down near the live size.
+    for (0..200) |round| {
+        for (0..200) |i| {
+            var d = try make_doc(gpa, @intCast(i), if (round % 2 == 0) "yy" else "z");
+            defer d.deinit();
+            try engine.replace("app", "c", &d, &env.gen);
+        }
+        if (engine.log.end_pos < after_insert * 2) break;
+    }
+    try testing.expectEqual(@as(u64, 200), engine.live_docs);
+    // Bounded well below the ~40x of record bytes those rewrites wrote.
+    try testing.expect(engine.log.end_pos < after_insert * 2);
+}
+
 test "reopen replays log" {
     var threaded: std.Io.Threaded = .init_single_threaded;
     defer threaded.deinit();
diff --git a/src/index.zig b/src/index.zig
index 03a74ed..aa51a59 100644
--- a/src/index.zig
+++ b/src/index.zig
@@ -805,7 +805,15 @@ fn evaluate_index(gpa: std.mem.Allocator, ix: *const Index, clauses: []const Cla
 // ---------------------------------------------------------------------------
 
 pub const IdPlan = struct {
-    values: []const bson.Value, // aliases the filter
+    /// Values to look up in the docs map. A single $eq value is a heap copy
+    /// owned by this plan; a $in list aliases the filter's array. Freed by
+    /// deinit.
+    values: []const bson.Value,
+    owned: bool,
+
+    pub fn deinit(self: *IdPlan, gpa: std.mem.Allocator) void {
+        if (self.owned) gpa.free(self.values);
+    }
 };
 
 /// Plan for the implicit _id_ index (the docs map). Only applies to a
@@ -814,7 +822,11 @@ pub const IdPlan = struct {
 /// int32 1, int64 1 and double 1.0 equal (and string/symbol/code "x" equal,
 /// and nested variants), but serialize_value produces different map keys —
 /// a hash lookup would then miss documents a scan would match.
-pub fn plan_id(filter: []const bson.Pair) ?IdPlan {
+///
+/// The returned plan must be deinit'd: the single-value case is heap-copied
+/// so the slice never points into a temporary (ReleaseFast reuses the stack,
+/// which turned a dangling anonymous-list pointer into garbage).
+pub fn plan_id(gpa: std.mem.Allocator, filter: []const bson.Pair) error{OutOfMemory}!?IdPlan {
     // The first usable _id clause wins; no flattening buffer is needed
     // because nothing is compared across clauses. $and members are searched
     // like top-level pairs, every other operator skipped — same rule as
@@ -832,29 +844,41 @@ pub fn plan_id(filter: []const bson.Pair) ?IdPlan {
                     .doc => |d| d,
                     else => continue,
                 };
-                if (plan_id(mp)) |found| return found;
+                if (try plan_id(gpa, mp)) |found| return found;
             }
             continue;
         }
         if (!std.mem.eql(u8, p.key, "_id")) continue;
-        if (id_lookup_values(p.value)) |values| return .{ .values = values };
+        if (try id_lookup_values(gpa, p.value)) |lookup| return .{ .values = lookup.values, .owned = lookup.owned };
     }
     return null;
 }
 
+const IdLookup = struct {
+    values: []const bson.Value,
+    owned: bool,
+};
+
 /// The map-lookup values for one _id clause, or null when it is not a pure
 /// equality/$in of fast-path-safe values. A range is unusable here: the docs
 /// map is a hash, not an ordered structure.
-fn id_lookup_values(v: bson.Value) ?[]const bson.Value {
+fn id_lookup_values(gpa: std.mem.Allocator, v: bson.Value) error{OutOfMemory}!?IdLookup {
     var info = CompInfo{};
     analyze_clause(v, &info);
     if (info.lo != null or info.hi != null) return null;
-    if (info.eq) |e| return if (value_fast_path_safe(e)) &.{e} else null;
+    if (info.eq) |e| {
+        if (!value_fast_path_safe(e)) return null;
+        // Heap-copy the single value: a pointer to a stack or anonymous
+        // temporary would dangle once this frame returns.
+        const buf = try gpa.alloc(bson.Value, 1);
+        buf[0] = e;
+        return .{ .values = buf[0..1], .owned = true };
+    }
     if (info.in_values) |list| {
         for (list) |m| {
             if (!value_fast_path_safe(m)) return null;
         }
-        return list;
+        return .{ .values = list, .owned = false };
     }
     return null;
 }
@@ -1108,43 +1132,60 @@ test "compound index prefix search and range on the next key" {
 }
 
 test "id fast path guards and $in" {
+    // plan_id may heap-copy the single value; run it through the allocator
+    // and free. The helper asserts on whether a plan was produced.
+    const gpa = testing.allocator;
+    const plans = struct {
+        fn has(pairs: []const bson.Pair) !bool {
+            var p = try plan_id(gpa, pairs);
+            defer if (p) |*pl| pl.deinit(gpa);
+            return p != null;
+        }
+    };
     // Numbers never use the fast path (compare-equal but serialize-different).
-    try testing.expect(plan_id(&.{.{ .key = "_id", .value = .{ .int32 = 1 } }}) == null);
+    try testing.expect(!try plans.has(&.{.{ .key = "_id", .value = .{ .int32 = 1 } }}));
     // Strings are skipped too: a stored symbol/code _id compare-equals a
     // string query but serializes differently.
-    try testing.expect(plan_id(&.{.{ .key = "_id", .value = .{ .string = "x" } }}) == null);
+    try testing.expect(!try plans.has(&.{.{ .key = "_id", .value = .{ .string = "x" } }}));
     // Truly canonical values (bool, ObjectId) do use it.
-    try testing.expect(plan_id(&.{.{ .key = "_id", .value = .{ .bool = true } }}) != null);
+    try testing.expect(try plans.has(&.{.{ .key = "_id", .value = .{ .bool = true } }}));
     const oid = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
-    try testing.expect(plan_id(&.{.{ .key = "_id", .value = .{ .object_id = oid } }}) != null);
+    try testing.expect(try plans.has(&.{.{ .key = "_id", .value = .{ .object_id = oid } }}));
     // $in with a number member is skipped.
     const mixed = [_]bson.Pair{.{ .key = "_id", .value = .{ .doc = &.{
         .{ .key = "$in", .value = .{ .array = &.{ .{ .bool = true }, .{ .int32 = 1 } } } },
     } } }};
-    try testing.expect(plan_id(&mixed) == null);
+    try testing.expect(!try plans.has(&mixed));
     const safe_in = [_]bson.Pair{.{ .key = "_id", .value = .{ .doc = &.{
         .{ .key = "$in", .value = .{ .array = &.{ .{ .bool = true }, .{ .bool = false } } } },
     } } }};
-    try testing.expect(plan_id(&safe_in) != null);
+    try testing.expect(try plans.has(&safe_in));
     // $and members count as top-level.
     const and_f = [_]bson.Pair{.{ .key = "$and", .value = .{ .array = &.{
         .{ .doc = &.{.{ .key = "_id", .value = .{ .bool = true } }} },
     } } }};
-    try testing.expect(plan_id(&and_f) != null);
+    try testing.expect(try plans.has(&and_f));
     // $or is not usable for the fast path.
     const or_f = [_]bson.Pair{.{ .key = "$or", .value = .{ .array = &.{
         .{ .doc = &.{.{ .key = "_id", .value = .{ .bool = true } }} },
     } } }};
-    try testing.expect(plan_id(&or_f) == null);
+    try testing.expect(!try plans.has(&or_f));
     // A doc containing a number is not fast-path safe.
     const doc_id = [_]bson.Pair{.{ .key = "_id", .value = .{ .doc = &.{.{ .key = "n", .value = .{ .int32 = 1 } }} } }};
-    try testing.expect(plan_id(&doc_id) == null);
+    try testing.expect(!try plans.has(&doc_id));
     // A doc containing a string is unsafe too (string/symbol/code class).
     const doc_str = [_]bson.Pair{.{ .key = "_id", .value = .{ .doc = &.{.{ .key = "n", .value = .{ .string = "x" } }} } }};
-    try testing.expect(plan_id(&doc_str) == null);
+    try testing.expect(!try plans.has(&doc_str));
     // A doc of canonical values is safe.
     const doc_safe = [_]bson.Pair{.{ .key = "_id", .value = .{ .doc = &.{.{ .key = "n", .value = .{ .bool = true } }} } }};
-    try testing.expect(plan_id(&doc_safe) != null);
+    try testing.expect(try plans.has(&doc_safe));
+    // The single-value plan owns a usable copy: the ObjectId must read back
+    // exactly (this is the ReleaseFast regression the fix guards — a dangling
+    // pointer read back as garbage).
+    var p = try plan_id(gpa, &.{.{ .key = "_id", .value = .{ .object_id = oid } }});
+    defer if (p) |*pl| pl.deinit(gpa);
+    try testing.expect(p != null);
+    try testing.expectEqualSlices(u8, &oid, &p.?.values[0].object_id);
 }
 
 test "TTL spec round-trips through write_spec and compares in spec_equal" {
diff --git a/src/main.zig b/src/main.zig
index 5f80f6f..77257f2 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -10,15 +10,46 @@ const usage =
     \\  --db <path>   database file (default mongo-lite.log)
     \\  --ttl-sweep-secs <n>
     \\                seconds between TTL index sweeps (default 60, 0 disables)
+    \\  --compact-threshold <bytes>
+    \\                minimum log bytes between compactions; suffixes k/m/g
+    \\                (default 16m). The actual trigger also scales with the
+    \\                live data size, so total rewrite traffic stays linear
+    \\                no matter how large the collection grows.
     \\  --help        show this help
     \\
 ;
 
+/// Parse a size with k/m/g suffix ("16m", "1g", "512k"), or null.
+fn parse_size_suffix(v: []const u8) ?u64 {
+    const s = std.mem.trim(u8, v, " \t");
+    if (s.len == 0) return null;
+    var mult: u64 = 1;
+    var num_part = s;
+    switch (s[s.len - 1]) {
+        'k', 'K' => {
+            mult = 1024;
+            num_part = s[0 .. s.len - 1];
+        },
+        'm', 'M' => {
+            mult = 1024 * 1024;
+            num_part = s[0 .. s.len - 1];
+        },
+        'g', 'G' => {
+            mult = 1024 * 1024 * 1024;
+            num_part = s[0 .. s.len - 1];
+        },
+        else => {},
+    }
+    const n = std.fmt.parseInt(u64, num_part, 10) catch return null;
+    return n * mult;
+}
+
 pub fn main(init: std.process.Init) !void {
     var port: u16 = 27017;
     var bind_ip: []const u8 = "127.0.0.1";
     var db_path: []const u8 = "mongo-lite.log";
     var ttl_sweep_secs: i64 = 60;
+    var compact_threshold: u64 = 16 * 1024 * 1024;
 
     var it = std.process.Args.Iterator.init(init.minimal.args);
     defer it.deinit();
@@ -44,6 +75,17 @@ pub fn main(init: std.process.Init) !void {
                 std.debug.print("mongo-lite: invalid ttl sweep interval '{s}'\n", .{v});
                 return error.InvalidTtlSweepSecs;
             }
+        } else if (std.mem.eql(u8, arg, "--compact-threshold")) {
+            const v = it.next() orelse return error.MissingValue;
+            const parsed = parse_size_suffix(v) orelse {
+                std.debug.print("mongo-lite: invalid compact threshold '{s}'\n", .{v});
+                return error.InvalidCompactThreshold;
+            };
+            if (parsed < 1024 * 1024) {
+                std.debug.print("mongo-lite: compact threshold must be at least 1m\n", .{});
+                return error.InvalidCompactThreshold;
+            }
+            compact_threshold = parsed;
         } else if (std.mem.eql(u8, arg, "--help") or std.mem.eql(u8, arg, "-h")) {
             try std.Io.File.writeStreamingAll(.stdout(), init.io, usage);
             return;
@@ -56,7 +98,8 @@ pub fn main(init: std.process.Init) !void {
     const oid_gen = mongo.bson.ObjectIdGen.init(init.io);
     var engine = try mongo.db.Engine.open(init.gpa, init.io, db_path);
     defer engine.deinit();
-    std.debug.print("mongo-lite: opened database '{s}'\n", .{db_path});
+    engine.compact_threshold = compact_threshold;
+    std.debug.print("mongo-lite: opened database '{s}' (compact threshold {d})\n", .{ db_path, compact_threshold });
 
     var server = mongo.server.Server{
         .gpa = init.gpa,
diff --git a/src/storage.zig b/src/storage.zig
index 9b9322d..eee2e39 100644
--- a/src/storage.zig
+++ b/src/storage.zig
@@ -1,13 +1,19 @@
 //! Append-only record log. Each record is:
-//!   [0..4)  u32 len — total record bytes
-//!   [4..8)  u32 crc32 over bytes [8..len)
-//!   [8..16) u64 seq
-//!   [16]    u8 type
-//!   [17..20) reserved
-//!   [20..)  db\0 coll\0 bson doc
+//!   [0..4)   u32 len — total record bytes
+//!   [4..12)  u64 hash over bytes [12..len)
+//!   [12..20) u64 seq
+//!   [20]     u8 type
+//!   [21..24) reserved
+//!   [24..)   db\0 coll\0 bson doc
 //! All integers little-endian. Reads and writes are positional, so the fd
 //! offset never matters. A torn tail record (crash mid-append) is detected
 //! during replay and skipped.
+//!
+//! The integrity hash is XxHash3, not CRC32. Both are checked for the same
+//! thing — did these bytes survive intact — but std.hash.Crc32 is the
+//! table-driven byte-at-a-time Crc32IsoHdlc, measured here at 408 MB/s
+//! against XxHash3's 31 GB/s. On a 16 KiB document that is 38 us versus
+//! 0.5 us, which was roughly two thirds of the entire bulk-insert cost.
 
 const std = @import("std");
 const bson = @import("bson.zig");
@@ -17,7 +23,12 @@ pub const record_type_delete: u8 = 2;
 pub const record_type_index_create: u8 = 3;
 pub const record_type_index_drop: u8 = 4;
 
-pub const header_len: usize = 20; // len + crc + seq + type + reserved
+pub const header_len: usize = 24; // len + hash + seq + type + reserved
+
+/// Integrity hash over a record's bytes after the length and hash fields.
+fn record_hash(bytes: []const u8) u64 {
+    return std.hash.XxHash3.hash(0, bytes);
+}
 
 /// Largest record payload we will accept during replay. Matches the
 /// announced maxBsonObjectSize with room for names and header.
@@ -31,7 +42,7 @@ pub const Record = struct {
 };
 
 pub const Error = error{
-    InvalidLog, // corrupt interior record (bad CRC or impossible length)
+    InvalidLog, // corrupt interior record (bad hash or impossible length)
 };
 
 /// Callback receives transient slices and a heap-allocated, freshly parsed
@@ -48,6 +59,11 @@ pub const Log = struct {
     // Reused record-framing buffer. Appends are single-writer (the engine's
     // exclusive lock), so one buffer avoids a realloc cycle per record.
     scratch: std.ArrayListUnmanaged(u8),
+    /// Group commit: while set, appends skip the per-record fsync and the
+    /// caller issues one sync for the whole batch (see Engine.begin_batch /
+    /// end_batch). Every acknowledged write is still fsynced before the
+    /// reply, so the crash guarantees are unchanged.
+    defer_sync: bool = false,
 
     pub fn open(gpa: std.mem.Allocator, io: std.Io, path: []const u8) !Log {
         // Resolve to an absolute path so compaction can rename the file
@@ -73,6 +89,7 @@ pub const Log = struct {
             .end_pos = 0,
             .log_bytes = 0,
             .scratch = .empty,
+            .defer_sync = false,
         };
     }
 
@@ -117,13 +134,16 @@ pub const Log = struct {
             };
             const payload_read = self.file.readPositionalAll(self.io, payload, pos + 4) catch return error.InvalidLog;
             if (payload_read < payload_len) return; // torn tail — crash during append
-            const crc_stored: u32 = std.mem.readInt(u32, payload[0..4], .little);
-            const crc_actual = std.hash.Crc32.hash(payload[4..payload_len]);
-            if (crc_stored != crc_actual) return error.InvalidLog;
+            // Offsets here are relative to `payload`, which starts at the
+            // record's byte 4 — so payload[0..8) is the record's hash field,
+            // and header_len - 4 is where db\0coll\0 begins.
+            const hash_stored: u64 = std.mem.readInt(u64, payload[0..8], .little);
+            const hash_actual = record_hash(payload[8..payload_len]);
+            if (hash_stored != hash_actual) return error.InvalidLog;
 
-            var idx: usize = 16; // after crc + seq + type + reserved
-            const seq: u64 = std.mem.readInt(u64, payload[4..12], .little);
-            const rtype = payload[12];
+            var idx: usize = header_len - 4;
+            const seq: u64 = std.mem.readInt(u64, payload[8..16], .little);
+            const rtype = payload[16];
             const db = read_cstring(payload, &idx) orelse return error.InvalidLog;
             const coll = read_cstring(payload, &idx) orelse return error.InvalidLog;
             if (idx > payload_len) return error.InvalidLog;
@@ -173,8 +193,8 @@ pub const Log = struct {
         const buf = &self.scratch;
         buf.clearRetainingCapacity();
         try buf.appendNTimes(self.gpa, 0, header_len);
-        std.mem.writeInt(u64, buf.items[8..16], seq, .little);
-        buf.items[16] = rtype;
+        std.mem.writeInt(u64, buf.items[12..20], seq, .little);
+        buf.items[20] = rtype;
         try buf.appendSlice(self.gpa, db);
         try buf.append(self.gpa, 0);
         try buf.appendSlice(self.gpa, coll);
@@ -183,10 +203,16 @@ pub const Log = struct {
         if (buf.items.len > std.math.maxInt(u32)) return error.LogTooLarge;
         const total: u32 = @intCast(buf.items.len);
         std.mem.writeInt(u32, buf.items[0..4], total, .little);
-        std.mem.writeInt(u32, buf.items[4..8], std.hash.Crc32.hash(buf.items[8..]), .little);
+        std.mem.writeInt(u64, buf.items[4..12], record_hash(buf.items[12..]), .little);
         try self.file.writePositionalAll(self.io, buf.items, self.end_pos);
         self.end_pos += buf.items.len;
         self.log_bytes += buf.items.len;
+        if (!self.defer_sync) try self.file.sync(self.io);
+    }
+
+    /// One fsync for the whole deferred batch. Callers must have set
+    /// defer_sync, appended, and cleared defer_sync again before the reply.
+    pub fn sync(self: *Log) !void {
         try self.file.sync(self.io);
     }
 
@@ -318,13 +344,16 @@ test "reject corrupt interior record" {
     try log.append_upsert("db", "c", &doc_bytes, 1);
     log.close();
 
-    // Corrupt the file: flip a byte in the middle of the record.
+    // Corrupt the file: flip a byte in the middle of the record. The record
+    // is header_len ++ "db\0" ++ "c\0" ++ doc, so this lands on the first
+    // doc byte — inside the hashed range, and past every framing field.
+    const corrupt_at = header_len + 5;
     const dir = std.Io.Dir.cwd();
     var f = try dir.openFile(io, path, .{ .mode = .read_write });
     var buf: [64]u8 = undefined;
     const n = try f.readPositionalAll(io, &buf, 0);
     _ = n;
-    buf[25] ^= 0xFF;
+    buf[corrupt_at] ^= 0xFF;
     try f.writePositionalAll(io, buf[0..64], 0);
     f.close(io);
 
diff --git a/tests/e2e/README.md b/tests/e2e/README.md
index ec4835d..3d3154d 100644
--- a/tests/e2e/README.md
+++ b/tests/e2e/README.md
@@ -1,7 +1,8 @@
 # End-to-end tests with the official MongoDB Node.js driver
 
 These exercise mongo-lite from a real driver over TCP: full CRUD, query
-operators, aggregation, error codes, concurrent clients, and crash recovery.
+operators, aggregation, error codes, concurrent clients, crash recovery, and
+the whole lifecycle including server restarts.
 
 ## Setup
 
@@ -13,7 +14,7 @@ npm install mongodb
 
 ## Run
 
-Start the server, then run the suites against it (defaults to port 27020):
+Most suites expect a server running on port 27020:
 
 ```sh
 zig build
@@ -28,8 +29,17 @@ node tests/e2e/e2e4.js         # TTL indexes: expiry + rejected specs (15 checks
 ```
 
 `e2e4.js` needs the server started with `--ttl-sweep-secs 1` (the default is
-60 seconds, which is longer than the suite waits); the other suites do not
-care about the flag.
+60 seconds); the other suites do not care about the flag.
+
+`e2e6.js` is the full-lifecycle suite and is self-contained: it spawns its
+own server on port 27220 with a fresh log, runs the whole feature surface,
+restarts the server twice (graceful SIGTERM, then kill -9 mid-write) and
+verifies everything survived:
+
+```sh
+node tests/e2e/e2e6.js              # 73 checks, ~15 s, needs no running server
+E2E6_PORT=27300 node tests/e2e/e2e6.js   # different port if 27220 is taken
+```
 
 Rebuild with `zig build` after any change under `src/` before restarting the
 server: `zig build test` compiles the test binary only and leaves
@@ -38,3 +48,52 @@ rules and report failures that the source no longer explains.
 
 `e2e2.js concurrent` is safe to repeat against a running server (it drops its
 collection first); `crash-a`/`crash-b` are two halves of one scenario.
+
+## Multi-GB collections: `big.js`
+
+`big.js` is a load harness, not a pass/fail suite: it spawns a server, bulk
+loads up to ~5 GB, and reports insert throughput, the compaction behavior,
+server RSS, per-operation latencies, reopen (replay) time, and kill -9
+durability.
+
+```sh
+node tests/e2e/big.js --quick                      # 268 MB smoke run
+node tests/e2e/big.js --size 5g --doc-size 128k --oid --batch 200 \
+                       --compact-threshold 2g      # ~5 GB, 40k docs
+```
+
+Options: `--size`/`--doc-size`/`--batch` (k/m/g suffixes), `--oid`
+(ObjectId `_id`s — see below), `--index <field>` (secondary index before
+loading), `--compact-threshold <bytes>` (passed to the server),
+`--port`, `--keep` (keep the db file).
+
+Measured behavior (all documented in the top-level README):
+
+- **Build in ReleaseFast** — `zig build` defaults to it; a Debug server is
+  10-200x slower on every path.
+- **Insert throughput collapses under the default 16 MiB compaction
+  threshold**: every ~16 MB of writes rewrites the whole log with one fsync
+  per record (O(n²) total). With `--compact-threshold 2g` the rate stays
+  flat (hundreds of MB/s at 128 KB docs in ReleaseFast). Raise the
+  threshold for bulk loads.
+- **`findOne({_id})` is O(1) only for ObjectId `_id`s.** Integer `_id`s are
+  serialization-ambiguous (int32/int64/double compare equal but hash
+  differently), so the docs-map fast path is skipped and every lookup is a
+  full scan. Use the driver's default ObjectId ids on big collections.
+- **The engine holds everything in RAM**: ~1-1.2x the data size at 128 KB
+  docs (more at 16 KB docs, where per-document arena overhead dominates).
+  A 5 GB collection needs roughly 6-7 GB of RAM.
+- Reopen of a 5 GB log replays in ~10 s (ReleaseFast); every committed
+  write survives kill -9.
+
+## Comparing against real MongoDB: `compare.js` + `compare-run.sh`
+
+```sh
+bash tests/e2e/compare-run.sh [size] [doc-size]   # e.g. 1g 16k
+```
+
+Starts mongod (`brew install mongodb-community`) on :27018 and mongo-lite
+on :27019, runs the same driver workload against each (durable writes:
+mongo-lite fsyncs per command, mongod runs with `j: true`), measures kill -9
+reopen for both, and prints a side-by-side table. `compare.js` alone runs
+one side (see its `--help`-style header comment).
diff --git a/tests/e2e/big.js b/tests/e2e/big.js
new file mode 100644
index 0000000..c62a91c
--- /dev/null
+++ b/tests/e2e/big.js
@@ -0,0 +1,347 @@
+// Big-collection harness: how mongo-lite behaves with multi-GB collections.
+//
+// Spawns its own server, bulk-inserts up to ~5 GB of documents, measures
+// insert throughput, log/compaction behavior and server RSS, benchmarks
+// find/count/update/delete against the full dataset, then kills the server
+// and measures reopen (replay) time and crash durability.
+//
+//   node tests/e2e/big.js [options]
+//     --size <n>      target collection size; k/m/g suffixes (default 5g)
+//     --doc-size <n>  approximate bytes per document (default 32k)
+//     --batch <n>     docs per insertMany call (default 500)
+//     --index <f>     create a secondary index on field f *before* inserting
+//                     (entry insert is O(n), so this makes the load quadratic)
+//     --oid           use ObjectId _ids (driver-generated): O(1) _id lookups.
+//                     Without it, int _ids fall back to a full scan (the _id
+//                     fast path is skipped for serialization-ambiguous
+//                     numeric classes), so findOne({_id}) costs a scan.
+//     --compact-threshold <n>
+//                     pass through to the server: log bytes between
+//                     compactions (default 16m). Raise for bulk loads.
+//     --port <n>      server port (default 27221)
+//     --keep          keep the db file after the run
+//     --quick         tiny run (256m, 16k docs)
+//
+// Env: ML_BIN  server binary (default ../../zig-out/bin/mongo-lite)
+//      BIG_DB  db file path (default .zig-cache/big.log)
+const { MongoClient } = require('mongodb');
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const BIN = process.env.ML_BIN || path.resolve(__dirname, '../../zig-out/bin/mongo-lite');
+const PORT = Number(process.env.BIG_PORT || 27221);
+const DBFILE = process.env.BIG_DB || path.resolve(__dirname, '../../.zig-cache/big.log');
+const URL = `mongodb://127.0.0.1:${PORT}`;
+
+function parseSize(s) {
+  const m = /^(\d+(?:\.\d+)?)([kmgt]?)$/i.exec(String(s).trim());
+  if (!m) throw new Error(`bad size '${s}'`);
+  const mult = { '': 1, k: 1 << 10, m: 1 << 20, g: 1 << 30, t: 1 << 40 }[m[2].toLowerCase()];
+  return Math.round(parseFloat(m[1]) * mult);
+}
+
+let opt = { size: '5g', docSize: '32k', batch: 500, index: null, port: PORT, keep: false, oid: false, compactThreshold: null };
+for (let i = 2; i < process.argv.length; i++) {
+  const a = process.argv[i];
+  if (a === '--quick') { opt.size = '256m'; opt.docSize = '16k'; }
+  else if (a === '--keep') opt.keep = true;
+  else if (a === '--oid') opt.oid = true;
+  else if (a === '--index') opt.index = process.argv[++i];
+  else if (a.startsWith('--size=')) opt.size = a.slice(7);
+  else if (a.startsWith('--doc-size=')) opt.docSize = a.slice(11);
+  else if (a.startsWith('--batch=')) opt.batch = Number(a.slice(8));
+  else if (a.startsWith('--port=')) opt.port = Number(a.slice(7));
+  else if (a.startsWith('--compact-threshold=')) opt.compactThreshold = a.slice(20);
+  else if (a === '--size') opt.size = process.argv[++i];
+  else if (a === '--doc-size') opt.docSize = process.argv[++i];
+  else if (a === '--batch') opt.batch = Number(process.argv[++i]);
+  else if (a === '--compact-threshold') opt.compactThreshold = process.argv[++i];
+  else { console.error(`unknown option ${a}`); process.exit(2); }
+}
+
+const SIZE = parseSize(opt.size);
+const DOC_SIZE = parseSize(opt.docSize);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+let server = null;
+let serverLog = '';
+let serverDead = false;
+function cleanup() {
+  if (server && !serverDead) {
+    try { server.kill('SIGKILL'); } catch {}
+  }
+}
+process.on('exit', cleanup);
+process.on('SIGINT', () => { cleanup(); process.exit(130); });
+process.on('SIGTERM', () => { cleanup(); process.exit(143); });
+function startServer() {
+  return new Promise((resolve, reject) => {
+    const t0 = Date.now();
+    serverDead = false;
+    const args = ['--port', String(opt.port), '--db', DBFILE];
+    if (opt.compactThreshold) args.push('--compact-threshold', opt.compactThreshold);
+    server = spawn(BIN, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    server.stdout.on('data', (d) => (serverLog += d));
+    server.stderr.on('data', (d) => (serverLog += d));
+    server.on('error', (e) => reject(new Error(`cannot start ${BIN}: ${e.message}`)));
+    server.on('exit', (code, sig) => {
+      serverDead = true;
+      if (code !== null && sig === null) serverLog += `\n[child exited rc=${code}]`;
+    });
+    const deadline = Date.now() + 120000;
+    (async () => {
+      while (Date.now() < deadline) {
+        if (serverDead) {
+          reject(new Error(`server child exited during start (port ${opt.port} busy?)\n${serverLog}`));
+          return;
+        }
+        const c = new MongoClient(URL, { serverSelectionTimeoutMS: 1000 });
+        try {
+          await c.connect();
+          await c.db('admin').command({ ping: 1 });
+          await c.close();
+          return resolve(Date.now() - t0);
+        } catch {
+          try { await c.close(); } catch {}
+          await sleep(100);
+        }
+      }
+      reject(new Error(`server did not come up on :${opt.port}\n${serverLog}`));
+    })();
+  });
+}
+async function stopServer(sig = 'SIGKILL') {
+  if (!server) return;
+  const exited = new Promise((r) => server.once('exit', r));
+  server.kill(sig);
+  await Promise.race([exited, sleep(5000)]);
+  serverDead = true;
+  server = null;
+}
+async function rssMB() {
+  if (!server) return 0;
+  try {
+    const out = (await new Promise((r) => require('child_process').exec(`ps -o rss= -p ${server.pid}`, (e, so) => r(so || '')))).trim();
+    return Math.round(Number(out) / 1024);
+  } catch { return 0; }
+}
+
+const report = [];
+function row(label, value) { report.push([label, value]); console.log(`  ${String(label).padEnd(46)} ${value}`); }
+
+async function main() {
+  if (!fs.existsSync(BIN)) {
+    console.error(`server binary not found at ${BIN} — run \`zig build\` first`);
+    process.exit(1);
+  }
+  fs.rmSync(DBFILE, { force: true });
+  const fmt = (n) => (n >= 1e9 ? (n / 1e9).toFixed(2) + ' GB' : n >= 1e6 ? (n / 1e6).toFixed(1) + ' MB' : n >= 1e3 ? (n / 1e3).toFixed(1) + ' KB' : n + ' B');
+  console.log(`mongo-lite big-collection harness`);
+  console.log(`  size ${fmt(SIZE)} · doc ~${fmt(DOC_SIZE)} · batch ${opt.batch} · index ${opt.index || 'none'} · ids ${opt.oid ? 'ObjectId' : 'int'} · compact-threshold ${opt.compactThreshold || '16m'} · db ${DBFILE}`);
+
+  console.log('\n== server start (fresh log) ==');
+  const openMs = await startServer();
+  row('open + first ping (fresh log)', `${openMs} ms`);
+
+  const client = new MongoClient(URL, { serverSelectionTimeoutMS: 10000 });
+  await client.connect();
+  const db = client.db('big');
+  const coll = db.collection('items');
+  await coll.drop().catch(() => {});
+
+  if (opt.index) {
+    const t0 = Date.now();
+    await coll.createIndex({ [opt.index]: 1 });
+    row(`createIndex({${opt.index}: 1}) on empty coll`, `${Date.now() - t0} ms`);
+  }
+
+  // ---- insert ------------------------------------------------------------
+  console.log('\n== insert ==');
+  const nDocs = Math.max(1, Math.ceil(SIZE / DOC_SIZE));
+  const payloadLen = Math.max(1, DOC_SIZE - 130); // bson overhead for _id/k/p/ts/payload
+  const payload = 'x'.repeat(payloadLen);
+  const { ObjectId } = require('mongodb');
+  const t0 = Date.now();
+  const logSamples = [{ t: 0, size: fs.existsSync(DBFILE) ? fs.statSync(DBFILE).size : 0, rss: 0 }];
+  const sampler = setInterval(async () => {
+    logSamples.push({ t: Date.now() - t0, size: fs.existsSync(DBFILE) ? fs.statSync(DBFILE).size : 0, rss: await rssMB() });
+  }, 2000);
+
+  // Rate curve: avg MB/s per progress chunk, to show how throughput changes
+  // as the log grows (compaction rewrites + fsync-per-record dominate).
+  const rates = [];
+  let lastProgressT = t0;
+  let lastProgressDocs = 0;
+  let midDocId = null; // ObjectId of the mid doc (oid mode), captured at insert
+  let lastDocId = null;
+  let inserted = 0;
+  const midIndex = Math.floor(nDocs / 2);
+  try {
+    while (inserted < nDocs) {
+      const n = Math.min(opt.batch, nDocs - inserted);
+      const docs = new Array(n);
+      for (let i = 0; i < n; i++) {
+        const id = inserted + i + 1;
+        const doc = opt.oid
+          ? { _id: new ObjectId(), k: id % 1000, p: id % 5000, ts: new Date(Date.UTC(2024, 0, 1) + id * 1000), payload }
+          : { _id: id, k: id % 1000, p: id % 5000, ts: new Date(Date.UTC(2024, 0, 1) + id * 1000), payload };
+        if (id === midIndex) midDocId = doc._id;
+        if (id === nDocs) lastDocId = doc._id;
+        docs[i] = doc;
+      }
+      await coll.insertMany(docs, { ordered: false });
+      inserted += n;
+      if (inserted % Math.max(1000, Math.floor(nDocs / 20)) < n) {
+        const dt = (Date.now() - t0) / 1000;
+        const mb = inserted * DOC_SIZE / 1e6;
+        const chunkMb = (inserted - lastProgressDocs) * DOC_SIZE / 1e6;
+        const chunkT = (Date.now() - lastProgressT) / 1000;
+        rates.push(+(chunkMb / chunkT).toFixed(1));
+        lastProgressT = Date.now();
+        lastProgressDocs = inserted;
+        console.log(`    ${inserted.toLocaleString()} docs · ${fmt(inserted * DOC_SIZE)} · ${(mb / dt).toFixed(1)} MB/s avg`);
+      }
+    }
+  } finally {
+    clearInterval(sampler);
+  }
+  const insertMs = Date.now() - t0;
+  const bytes = inserted * DOC_SIZE;
+  row('docs inserted', inserted.toLocaleString());
+  row('approx bytes', fmt(bytes));
+  row('wall time', `${(insertMs / 1000).toFixed(1)} s`);
+  row('throughput', `${(bytes / 1e6 / (insertMs / 1000)).toFixed(1)} MB/s (${(inserted / (insertMs / 1000)).toFixed(0)} docs/s)`);
+  row('rate curve (MB/s per chunk)', rates.join(' → ') || 'n/a');
+
+  const compactions = logSamples.filter((s, i) => i > 0 && s.size < logSamples[i - 1].size - 2 * 1024 * 1024).length;
+  const sizes = logSamples.map((s) => s.size);
+  row('log file size (min → final)', `${fmt(Math.min(...sizes))} → ${fmt(sizes[sizes.length - 1])}`);
+  row('compaction events observed', compactions, '(log shrank by >2MB between samples)');
+  const peakRss = Math.max(...logSamples.map((s) => s.rss));
+  row('peak server RSS', `${peakRss} MB`, '(in-memory engine: docs live in RAM)');
+
+  // ---- find / read -------------------------------------------------------
+  console.log('\n== find / read on full dataset ==');
+  const bench = async (label, fn, min = 1) => {
+    const a = Date.now();
+    const res = await fn();
+    const ms = Date.now() - a;
+    row(`${label}`, `${ms < 1000 ? ms + ' ms' : (ms / 1000).toFixed(2) + ' s'}${res !== undefined ? `  (${res})` : ''}`);
+    return ms;
+  };
+  await bench('countDocuments({})', async () => {
+    const n = await coll.countDocuments({});
+    if (n !== inserted) throw new Error(`count ${n} != ${inserted}`);
+    return `${n.toLocaleString()} docs`;
+  });
+  await bench('findOne({_id: mid}) — ' + (opt.oid ? 'docs-map fast path' : 'scan (int _id: fast path skipped)'), async () => {
+    const d = await coll.findOne({ _id: opt.oid ? midDocId : midIndex });
+    if (!d) throw new Error('miss');
+  });
+  await bench('findOne({_id: last})', async () => {
+    const d = await coll.findOne({ _id: opt.oid ? lastDocId : nDocs });
+    if (!d) throw new Error('miss');
+  });
+  if (opt.index) {
+    await bench(`find({${opt.index}: 4242}).count() — via index`, async () => {
+      const n = await coll.countDocuments({ k: 4242 });
+      if (n < 1) throw new Error('no hits');
+      return `${n} hits`;
+    });
+  }
+  await bench('find({k: 4242}).count() — scan', async () => {
+    const n = await coll.countDocuments({ k: 4242 });
+    return `${n} hits`;
+  });
+  await bench('find({p: {$gte, $lt}}).count() — range scan', async () => {
+    const lo = 1000, hi = 2000;
+    const n = await coll.countDocuments({ p: { $gte: lo, $lt: hi } });
+    return `${n} hits`;
+  });
+  await bench('find({}).sort({_id:-1}).limit(20) — full scan + sort', async () => {
+    const docs = await coll.find({}).sort({ _id: -1 }).limit(20).toArray();
+    if (docs.length !== 20) throw new Error('bad page');
+  });
+  await bench('find({}, {proj: _id,k,p}).limit(500) — page', async () => {
+    const docs = await coll.find({}, { projection: { payload: 0 } }).limit(500).toArray();
+    if (docs.length !== 500) throw new Error('short page');
+  });
+
+  // ---- write ops against the full dataset ---------------------------------
+  console.log('\n== point write ops ==');
+  const midId = opt.oid ? midDocId : midIndex;
+  await bench('updateOne({_id: mid}, {$set}) — 1 fsync', async () => {
+    const r = await coll.updateOne({ _id: midId }, { $set: { touch: Date.now() } });
+    if (r.modifiedCount !== 1) throw new Error('miss');
+  });
+  await bench('updateMany({k: 7}, {$inc}) — ~N/1000 fsyncs', async () => {
+    const r = await coll.updateMany({ k: 7 }, { $inc: { hits: 1 } });
+    return `${r.modifiedCount} modified`;
+  });
+  await bench('deleteOne({_id: mid}) + re-insert', async () => {
+    await coll.deleteOne({ _id: midId });
+    if (opt.oid) {
+      await coll.insertOne({ _id: new ObjectId(), k: midIndex % 1000, p: midIndex % 5000, payload });
+    } else {
+      await coll.insertOne({ _id: midIndex, k: midIndex % 1000, p: midIndex % 5000, payload });
+    }
+  });
+  await bench('aggregate $group by k', async () => {
+    const out = await coll.aggregate([{ $group: { _id: '$k', n: { $sum: 1 } } }]).toArray();
+    return `${out.length} groups`;
+  });
+
+  // ---- reopen (replay) ----------------------------------------------------
+  console.log('\n== durability ==');
+  await client.close();
+  await stopServer('SIGKILL');
+  const reopenMs = await startServer();
+  row('kill -9 then reopen (replay of full log)', `${(reopenMs / 1000).toFixed(1)} s`);
+  const c2 = new MongoClient(URL, { serverSelectionTimeoutMS: 10000 });
+  await c2.connect();
+  const db2 = c2.db('big');
+  const coll2 = db2.collection('items');
+  const afterRestart = await coll2.countDocuments({});
+  row('count after restart', `${afterRestart.toLocaleString()} (${afterRestart === inserted ? 'OK' : 'MISMATCH!'})`);
+  const spot = await coll2.findOne({ _id: opt.oid ? lastDocId : nDocs });
+  row('last doc intact after restart', spot ? `payload ${spot.payload.length}B` : 'MISSING!');
+  if (afterRestart !== inserted || !spot) throw new Error('durability check failed');
+
+  // Crash-durability: every write is fsynced before it is acknowledged, so a
+  // kill -9 right after an insert must not lose it.
+  const crash = db2.collection('crash');
+  await crash.drop().catch(() => {});
+  let committed = 0;
+  for (let i = 1; i <= 200; i++) {
+    await crash.insertOne({ _id: i, seq: i });
+    committed = i;
+  }
+  await c2.close();
+  await stopServer('SIGKILL');
+  await startServer();
+  const c3 = new MongoClient(URL, { serverSelectionTimeoutMS: 10000 });
+  await c3.connect();
+  const db3 = c3.db('big');
+  const crashN = await db3.collection('crash').countDocuments({});
+  row('kill -9 after 200 committed writes', `${crashN}/200 survived (${crashN === 200 ? 'OK' : 'MISMATCH!'})`);
+  await c3.close();
+
+  if (!opt.keep) fs.rmSync(DBFILE, { force: true });
+  await stopServer('SIGKILL');
+
+  console.log('\n== summary ==');
+  console.log(`  mongo-lite handles a ${fmt(bytes)} collection fully in RAM (RSS ${peakRss} MB)`);
+  console.log(`  insert: ${(bytes / 1e6 / (insertMs / 1000)).toFixed(1)} MB/s — fsync per write is by design (crash safety)`);
+  if (compactions > 0) {
+    console.log(`  ${compactions} compaction rewrites observed: every 16MB of writes rewrites the whole log — for multi-GB loads the cumulative rewrite traffic dominates`);
+  }
+  console.log('BIG_OK');
+}
+
+main().catch((e) => {
+  console.error('BIG_FAIL', e);
+  console.log('--- server log tail ---');
+  console.log(serverLog.split('\n').slice(-40).join('\n'));
+  process.exit(1);
+});
diff --git a/tests/e2e/compare-run.sh b/tests/e2e/compare-run.sh
new file mode 100644
index 0000000..730ccab
--- /dev/null
+++ b/tests/e2e/compare-run.sh
@@ -0,0 +1,119 @@
+#!/bin/bash
+# Compare mongo-lite against a real MongoDB with the same workload, same driver.
+#
+#   bash tests/e2e/compare-run.sh [size] [doc-size]
+#   (defaults: 1g, 16k)
+#
+# Starts mongod on :27018 and mongo-lite on :27019, runs compare.js against
+# each (durable writes: mongo-lite fsyncs per doc, mongod ack'd with j:true),
+# measures kill -9 reopen time for both, and prints a side-by-side table.
+set -u
+cd "$(dirname "$0")/../.."
+SIZE="${1:-1g}"
+DOC="${2:-16k}"
+echo "comparing mongo-lite vs mongodb — dataset ${SIZE}, docs ~${DOC}"
+
+CMPDIR=/tmp/mongo-cmp
+mkdir -p "$CMPDIR/mongod"
+ML_LOG="$CMPDIR/ml.log"
+ML_OUT="$CMPDIR/ml-srv.out"
+MD_OUT="$CMPDIR/md-srv.out"
+ML_PORT=27019
+MD_PORT=27018
+rm -f "$ML_LOG"
+rm -rf "$CMPDIR/mongod" && mkdir -p "$CMPDIR/mongod"
+
+# ---- MongoDB -------------------------------------------------------------
+echo; echo "### mongod (MongoDB $(mongod --version | grep -oE 'v[0-9.]+' | head -1))"
+mongod --dbpath "$CMPDIR/mongod" --port $MD_PORT --bind_ip 127.0.0.1 \
+       --quiet >"$MD_OUT" 2>&1 &
+MD_PID=$!
+sleep 2
+node tests/e2e/compare.js --url "mongodb://127.0.0.1:$MD_PORT" --label mongodb --size "$SIZE" --doc-size "$DOC" \
+  > "$CMPDIR/mongo-report.txt" 2>&1 || { echo "mongodb bench failed:"; tail -5 "$CMPDIR/mongo-report.txt"; }
+MD_RSS=$(ps -o rss= -p $MD_PID | awk '{printf "%.0f", $1/1024}')
+MD_DISK=$(du -sm "$CMPDIR/mongod" | awk '{print $1}')
+
+echo; echo "### mongod kill -9 + reopen"
+kill -9 $MD_PID; wait $MD_PID 2>/dev/null
+MD_REOPEN=$(cd tests/e2e && node -e '
+const { spawn } = require("child_process");
+const { MongoClient } = require("mongodb");
+const t0 = Date.now();
+const p = spawn("mongod", ["--dbpath","/tmp/mongo-cmp/mongod","--port","27018","--bind_ip","127.0.0.1","--quiet"], {stdio:"ignore"});
+const poll = async () => {
+  const c = new MongoClient("mongodb://127.0.0.1:27018", {serverSelectionTimeoutMS: 800});
+  try { await c.connect(); await c.db("admin").command({ping:1}); await c.close(); p.kill("SIGKILL"); console.log(((Date.now()-t0)/1000).toFixed(1)); }
+  catch { try { await c.close(); } catch {}; setTimeout(poll, 200); }
+};
+setTimeout(poll, 300);
+')
+kill -9 $MD_PID 2>/dev/null
+
+# ---- mongo-lite ----------------------------------------------------------
+echo; echo "### mongo-lite (recommended config: --compact-threshold 1g)"
+# Debug is ~10-200x slower (see the README's perf section) — the comparison
+# must use the optimized build.
+zig build -Doptimize=ReleaseFast 2>&1 | grep -c "^error" | grep -q "^0" || { echo "build failed"; exit 1; }
+./zig-out/bin/mongo-lite --port $ML_PORT --db "$ML_LOG" --compact-threshold 1g >"$ML_OUT" 2>&1 &
+ML_PID=$!
+sleep 1
+node tests/e2e/compare.js --url "mongodb://127.0.0.1:$ML_PORT" --label mongo-lite --size "$SIZE" --doc-size "$DOC" \
+  > "$CMPDIR/ml-report.txt" 2>&1 || { echo "mongo-lite bench failed:"; tail -5 "$CMPDIR/ml-report.txt"; }
+ML_RSS=$(ps -o rss= -p $ML_PID | awk '{printf "%.0f", $1/1024}')
+ML_DISK=$(du -sm "$ML_LOG" | awk '{print $1}')
+
+echo; echo "### mongo-lite kill -9 + reopen (replay)"
+kill -9 $ML_PID; wait $ML_PID 2>/dev/null
+ML_REOPEN=$(cd tests/e2e && node -e '
+const { spawn } = require("child_process");
+const { MongoClient } = require("mongodb");
+const t0 = Date.now();
+const p = spawn("/Users/shkmv/workspace/sandbox/mongo-lite/zig-out/bin/mongo-lite", ["--port","27019","--db","/tmp/mongo-cmp/ml.log","--compact-threshold","1g"], {stdio:"ignore"});
+const poll = async () => {
+  const c = new MongoClient("mongodb://127.0.0.1:27019", {serverSelectionTimeoutMS: 800});
+  try { await c.connect(); await c.db("admin").command({ping:1}); await c.close(); p.kill("SIGKILL"); console.log(((Date.now()-t0)/1000).toFixed(1)); }
+  catch { try { await c.close(); } catch {}; setTimeout(poll, 200); }
+};
+setTimeout(poll, 300);
+')
+kill -9 $ML_PID 2>/dev/null
+
+# ---- side by side ----------------------------------------------------------
+echo; echo "### side by side — ${SIZE} dataset, ~${DOC} docs"
+cat > "$CMPDIR/meta.json" <<EOF
+{"ml_rss_mb": "$ML_RSS", "md_rss_mb": "$MD_RSS", "ml_reopen": "${ML_REOPEN}s", "md_reopen": "${MD_REOPEN}s", "ml_disk_mb": "${ML_DISK}MB", "md_disk_mb": "${MD_DISK}MB"}
+EOF
+node -e '
+const fs = require("fs");
+const read = (p) => {
+  const m = {};
+  if (!fs.existsSync(p)) return m;
+  for (const line of fs.readFileSync(p, "utf8").split("\n")) {
+    const i = line.indexOf("\t");
+    if (i > 0) m[line.slice(0, i)] = line.slice(i + 1).replace(/\t.*$/, "");
+  }
+  return m;
+};
+const a = read("/tmp/mongo-cmp/ml-report.txt");
+const b = read("/tmp/mongo-cmp/mongo-report.txt");
+const meta = JSON.parse(fs.readFileSync("/tmp/mongo-cmp/meta.json", "utf8"));
+const keys = ["insertOne (sequential) ×200","bulk insert throughput","docs loaded","createIndex({k: 1})",
+  "countDocuments({})","findOne({_id: <ObjectId>})","findOne({k: 500}) (indexed)","find({p: {$gte,$lt}}).count() (scan)",
+  "find({}).sort({_id:-1}).limit(20)","find({}, {proj}).limit(1000)","aggregate $group by k",
+  "updateOne({_id}) ×50","updateMany({k: 7}, {$inc})","deleteOne({_id}) + insertOne","node client RSS"];
+const col = (v) => String(v).padEnd(22);
+console.log(`${"benchmark".padEnd(42)}  ${col("mongo-lite")}  ${col("mongodb")}  ratio`);
+for (const k of keys) {
+  const av = a[k] || "—", bv = b[k] || "—";
+  const ar = parseFloat(av), br = parseFloat(bv);
+  const ratio = isFinite(ar) && isFinite(br) && ar > 0 && br > 0 ? (ar / br).toFixed(1) + "x" : "";
+  console.log(`${k.padEnd(42)}  ${col(av)}  ${col(bv)}  ${ratio}`);
+}
+console.log(`${`server RSS`.padEnd(42)}  ${col(meta.ml_rss_mb + " MB")}  ${col(meta.md_rss_mb + " MB")}`);
+console.log(`${`kill -9 reopen`.padEnd(42)}  ${col(meta.ml_reopen)}  ${col(meta.md_reopen)}`);
+console.log(`${`db on disk`.padEnd(42)}  ${col(meta.ml_disk_mb)}  ${col(meta.md_disk_mb)}`);
+'
+
+pkill -9 -f "mongo-lite --port $ML_PORT" 2>/dev/null
+echo; echo "done — reports: $CMPDIR/ml-report.txt, $CMPDIR/mongo-report.txt"
diff --git a/tests/e2e/compare.js b/tests/e2e/compare.js
new file mode 100644
index 0000000..8ca0756
--- /dev/null
+++ b/tests/e2e/compare.js
@@ -0,0 +1,177 @@
+// Benchmark: the same workload through the official driver against mongo-lite
+// and a real MongoDB. Run once per server URL, then diff the reports.
+//
+//   node tests/e2e/compare.js --url mongodb://127.0.0.1:27018 --label mongodb
+//   node tests/e2e/compare.js --url mongodb://127.0.0.1:27019 --label mongo-lite
+//
+// Options:
+//   --url <u>        server URL (required)
+//   --label <s>      report label (default: url host:port)
+//   --size <n>       dataset size, k/m/g suffixes (default 1g)
+//   --doc-size <n>   bytes per document (default 16k)
+//   --batch <n>      docs per insertMany (default 500)
+//   --index <field>  field to index before the op benchmarks (default k)
+//   --wc <j|none>    write concern: 'j' = {w:1, j:true} durable ack on every
+//                    write (fair vs mongo-lite's fsync-per-write); 'none' =
+//                    driver default (default j)
+//
+// Every benchmark is awaited (no fire-and-forget), which is exactly how the
+// big.js harness measures mongo-lite, so the numbers are directly comparable.
+const { MongoClient, ObjectId } = require('mongodb');
+const fs = require('fs');
+const os = require('os');
+
+function parseSize(s) {
+  const m = /^(\d+(?:\.\d+)?)([kmgt]?)$/i.exec(String(s).trim());
+  if (!m) throw new Error(`bad size '${s}'`);
+  const mult = { '': 1, k: 1 << 10, m: 1 << 20, g: 1 << 30, t: 1 << 40 }[m[2].toLowerCase()];
+  return Math.round(parseFloat(m[1]) * mult);
+}
+function fmt(n) { return n >= 1e9 ? (n / 1e9).toFixed(2) + ' GB' : n >= 1e6 ? (n / 1e6).toFixed(1) + ' MB' : n >= 1e3 ? (n / 1e3).toFixed(1) + ' KB' : n + ' B'; }
+
+let opt = { url: null, label: null, size: '1g', docSize: '16k', batch: 500, index: 'k', wc: 'j' };
+for (let i = 2; i < process.argv.length; i++) {
+  const a = process.argv[i];
+  if (a === '--url') opt.url = process.argv[++i];
+  else if (a === '--label') opt.label = process.argv[++i];
+  else if (a === '--size') opt.size = process.argv[++i];
+  else if (a === '--doc-size') opt.docSize = process.argv[++i];
+  else if (a === '--batch') opt.batch = Number(process.argv[++i]);
+  else if (a === '--index') opt.index = process.argv[++i];
+  else if (a === '--wc') opt.wc = process.argv[++i];
+  else { console.error(`unknown option ${a}`); process.exit(2); }
+}
+if (!opt.url) { console.error('--url required'); process.exit(2); }
+opt.label = opt.label || opt.url.replace(/^mongodb:\/\//, '');
+const SIZE = parseSize(opt.size);
+const DOC_SIZE = parseSize(opt.docSize);
+const WC = opt.wc === 'j' ? { writeConcern: { w: 1, j: true } } : {};
+
+const report = [];
+const row = (k, v, note = '') => { report.push([k, v, note]); console.log(`${k}\t${v}${note ? '\t' + note : ''}`); };
+const fmtMs = (ms) => (ms < 1 ? ms.toFixed(2) + ' ms' : ms < 1000 ? ms.toFixed(1) + ' ms' : (ms / 1000).toFixed(2) + ' s');
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+async function bench(label, fn, min = 0) {
+  const a = process.hrtime.bigint();
+  const out = await fn();
+  const ms = Number(process.hrtime.bigint() - a) / 1e6;
+  row(label, fmtMs(ms), out ?? '');
+  return ms;
+}
+async function benchMany(label, n, fn) {
+  const times = [];
+  const a = process.hrtime.bigint();
+  for (let i = 0; i < n; i++) await fn();
+  const total = Number(process.hrtime.bigint() - a) / 1e6;
+  const sorted = times.sort((x, y) => x - y);
+  row(`${label} ×${n}`, fmtMs(total / n), `total ${fmtMs(total)}`);
+  return total / n;
+}
+function rssMB() {
+  try {
+    return Math.round(process.memoryUsage().rss / 1048576);
+  } catch { return 0; }
+}
+
+async function main() {
+  const client = new MongoClient(opt.url, { serverSelectionTimeoutMS: 15000, maxPoolSize: 4 });
+  await client.connect();
+  const dbName = `cmp${Date.now() % 100000}`;
+  const db = client.db(dbName);
+  const coll = db.collection('items');
+  const payload = 'y'.repeat(Math.max(1, DOC_SIZE - 140));
+  const nDocs = Math.max(1, Math.ceil(SIZE / DOC_SIZE));
+
+  console.log(`== ${opt.label} ==  size ${fmt(SIZE)} · doc ~${fmt(DOC_SIZE)} · wc ${opt.wc}`);
+  await db.command({ ping: 1 });
+  row('driver handshake + ping', '');
+
+  // ---- single-doc insert latency (sequential, durable ack) ----------------
+  console.log('\n-- single-doc writes --');
+  await coll.deleteMany({});
+  await benchMany('insertOne (sequential)', 200, () => coll.insertOne({ _id: new ObjectId(), k: 1, p: 2, ts: new Date(), payload: 'z'.repeat(256) }, WC));
+  const one = await coll.findOne({});
+  row('insertOne round-trip sanity', one ? 'ok' : 'MISSING');
+
+  // ---- bulk load ------------------------------------------------------------
+  console.log('\n-- bulk load --');
+  await coll.drop().catch(() => {});
+  await coll.createIndex({ _id: 1 }, { unique: true }).catch(() => {});
+  let t0 = Date.now();
+  let inserted = 0;
+  while (inserted < nDocs) {
+    const n = Math.min(opt.batch, nDocs - inserted);
+    const docs = new Array(n);
+    for (let i = 0; i < n; i++) {
+      const id = inserted + i + 1;
+      docs[i] = { _id: new ObjectId(), k: id % 1000, p: id % 5000, ts: new Date(Date.UTC(2024, 0, 1) + id * 1000), payload };
+    }
+    await coll.insertMany(docs, Object.assign({ ordered: false }, WC));
+    inserted += n;
+  }
+  const bulkMs = Date.now() - t0;
+  row('docs loaded', inserted.toLocaleString());
+  row('bytes loaded', fmt(inserted * DOC_SIZE));
+  row('bulk insert throughput', `${(inserted * DOC_SIZE / 1e6 / (bulkMs / 1000)).toFixed(1)} MB/s`, `(${(inserted / (bulkMs / 1000)).toFixed(0)} docs/s, ${(bulkMs / 1000).toFixed(1)} s)`);
+  let collInfo = null;
+  try { collInfo = await db.command({ collStats: 'items' }); } catch {}
+  if (collInfo) row('server-side data size', fmt(collInfo.size ?? 0), `storage ${fmt(collInfo.storageSize ?? 0)}`);
+
+  // ---- secondary index (mongo-lite: planner uses it; mongodb: normal) ------
+  if (opt.index) {
+    await bench(`createIndex({${opt.index}: 1})`, async () => { await coll.createIndex({ [opt.index]: 1 }); });
+  }
+
+  // ---- read benchmarks --------------------------------------------------------
+  console.log('\n-- reads on full dataset --');
+  await bench('countDocuments({})', async () => `${(await coll.countDocuments({})).toLocaleString()} docs`);
+  await bench('findOne({_id: <ObjectId>})', async () => {
+    const d = await coll.findOne({ _id: new ObjectId(hexOf(nDocs / 2)) }, { projection: { _id: 1 } });
+    return d ? 'hit' : 'MISSING';
+  });
+  if (opt.index) {
+    await bench(`findOne({${opt.index}: 500}) (indexed)`, async () => {
+      const d = await coll.findOne({ k: 500 }, { projection: { _id: 1 } });
+      return d ? 'hit' : 'MISSING';
+    });
+  }
+  await bench('find({p: {$gte,$lt}}).count() (scan)', async () => `${(await coll.countDocuments({ p: { $gte: 1000, $lt: 3000 } })).toLocaleString()} hits`);
+  await bench('find({}).sort({_id:-1}).limit(20)', async () => (await coll.find({}).sort({ _id: -1 }).limit(20).toArray()).length + ' docs');
+  await bench('find({}, {proj}).limit(1000)', async () => (await coll.find({}, { projection: { payload: 0 } }).limit(1000).toArray()).length + ' docs');
+  await bench('aggregate $group by k', async () => {
+    const g = await coll.aggregate([{ $group: { _id: '$k', n: { $sum: 1 } } }]).toArray();
+    return g.length + ' groups';
+  });
+
+  // ---- write benchmarks on the full dataset ---------------------------------
+  console.log('\n-- writes on full dataset --');
+  const midOid = new ObjectId(hexOf(Math.floor(nDocs / 2)));
+  await benchMany('updateOne({_id})', 50, () => coll.updateOne({ _id: midOid }, { $set: { touch: 1 } }, WC));
+  await bench('updateMany({k: 7}, {$inc})', async () => {
+    const r = await coll.updateMany({ k: 7 }, { $inc: { hits: 1 } }, WC);
+    return `${r.modifiedCount} modified`;
+  });
+  await bench('deleteOne({_id}) + insertOne', async () => {
+    await coll.deleteOne({ _id: midOid }, WC);
+    await coll.insertOne({ _id: new ObjectId(), k: 1, p: 2, payload }, WC);
+  });
+
+  row('node client RSS', `${rssMB()} MB`);
+
+  await client.close();
+  // Drop the db so a second run against the same server starts clean.
+  await new MongoClient(opt.url, { serverSelectionTimeoutMS: 5000 }).connect().then(async (c) => {
+    await c.db(dbName).dropDatabase();
+    await c.close();
+  }).catch(() => {});
+
+  console.log('\nCOMPARE_OK');
+}
+
+// ObjectId from a deterministic 12-byte hex (so both servers see identical keys).
+function hexOf(n) {
+  return n.toString(16).padStart(24, '0');
+}
+
+main().catch((e) => { console.error('COMPARE_FAIL', e); process.exit(1); });
diff --git a/tests/e2e/e2e6.js b/tests/e2e/e2e6.js
new file mode 100644
index 0000000..9dbc66d
--- /dev/null
+++ b/tests/e2e/e2e6.js
@@ -0,0 +1,426 @@
+// E2E part 6: the full lifecycle, self-contained.
+//
+// Spawns its own mongo-lite server on a fresh log file and drives the whole
+// feature surface through the official driver: CRUD + query operators +
+// aggregation + error codes + secondary indexes + TTL expiry + admin
+// commands, then restarts the server twice — once gracefully, once with
+// kill -9 mid-write — and verifies that everything (data, indexes, TTL
+// state) survives both.
+//
+// Unlike the other e2e files it needs no server running beforehand:
+//
+//   node tests/e2e/e2e6.js
+//
+// Env:  E2E6_PORT  listen port (default 27220)
+//       ML_BIN     server binary (default ../../zig-out/bin/mongo-lite)
+//       E2E6_KEEP  keep the log file after the run
+const { MongoClient, ObjectId } = require('mongodb');
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const PORT = Number(process.env.E2E6_PORT || 27220);
+const BIN = process.env.ML_BIN || path.resolve(__dirname, '../../zig-out/bin/mongo-lite');
+const DBFILE = process.env.E2E6_DB || path.resolve(__dirname, '../../.zig-cache/e2e6-full.log');
+const URL = `mongodb://127.0.0.1:${PORT}`;
+
+const results = [];
+function check(name, cond, detail = '') {
+  results.push({ name, ok: !!cond, detail: String(detail) });
+  if (!cond) console.error(`  ✗ ${name} ${detail}`);
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function waitFor(fn, timeoutMs = 20000, stepMs = 200) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await fn()) return true;
+    await sleep(stepMs);
+  }
+  return false;
+}
+
+let server = null;
+let serverLog = '';
+let serverDead = false;
+
+// Never leak the spawned server: kill it no matter how the test exits.
+function cleanup() {
+  if (server && !serverDead) {
+    try { server.kill('SIGKILL'); } catch {}
+  }
+}
+process.on('exit', cleanup);
+process.on('SIGINT', () => { cleanup(); process.exit(130); });
+process.on('SIGTERM', () => { cleanup(); process.exit(143); });
+
+function startServer(fresh = false) {
+  return new Promise((resolve, reject) => {
+    // Only the very first start must wipe the log; restarts must reuse it.
+    if (fresh) fs.rmSync(DBFILE, { force: true });
+    serverDead = false;
+    server = spawn(BIN, ['--port', String(PORT), '--db', DBFILE, '--ttl-sweep-secs', '1'], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    server.stdout.on('data', (d) => (serverLog += d));
+    server.stderr.on('data', (d) => (serverLog += d));
+    server.on('error', (e) => reject(new Error(`cannot start ${BIN}: ${e.message}`)));
+    server.on('exit', (code, sig) => {
+      // A child that dies (e.g. address already in use) must fail the start;
+      // otherwise the ping poll below would talk to a *stale* server on the
+      // same port and the whole run would go against the wrong database.
+      serverDead = true;
+      if (code !== null && sig === null) serverLog += `\n[child exited rc=${code}]`;
+    });
+    // Replay happens before the listener opens, so a successful connect is
+    // also the reopen benchmark. Poll until the server answers ping.
+    const deadline = Date.now() + 15000;
+    (async () => {
+      while (Date.now() < deadline) {
+        if (serverDead) {
+          reject(new Error(`server child exited during start (port ${PORT} busy?)\n${serverLog}`));
+          return;
+        }
+        const c = new MongoClient(URL, { serverSelectionTimeoutMS: 1000 });
+        try {
+          await c.connect();
+          await c.db('admin').command({ ping: 1 });
+          await c.close();
+          return resolve();
+        } catch {
+          try { await c.close(); } catch {}
+          await sleep(100);
+        }
+      }
+      reject(new Error(`server did not come up on :${PORT}\n${serverLog}`));
+    })();
+  });
+}
+
+async function stopServer(sig = 'SIGTERM') {
+  if (!server) return;
+  const exited = new Promise((r) => server.once('exit', r));
+  server.kill(sig);
+  await Promise.race([exited, sleep(5000)]);
+  serverDead = true;
+  server = null;
+}
+
+async function expectCode(fn, code, name) {
+  let err = null;
+  try {
+    await fn();
+  } catch (e) {
+    err = e;
+  }
+  check(name, err && err.code === code, err ? `code ${err.code}: ${err.message}` : 'no error');
+}
+
+async function phase1(client, db) {
+  const users = db.collection('users');
+  await users.drop().catch(() => {});
+
+  // ---- insert -----------------------------------------------------------
+  await users.insertOne({ name: 'alice', age: 30, tags: ['a', 'b'], scores: [3, 6, 9], email: 'a@x.io' });
+  const many = await users.insertMany([
+    { name: 'bob', age: 25, tags: ['b'], scores: [1], email: 'b@x.io' },
+    { name: 'carol', age: 35, tags: ['c', 'a'], scores: [8, 5], email: 'c@x.io' },
+    { name: 'dave', age: 40, tags: [], scores: [4, 4, 4], email: 'd@x.io' },
+  ]);
+  check('insertMany acknowledged', many.acknowledged === true, many);
+  check('auto _id assigned', ObjectId.isValid(many.insertedIds[0]));
+  const aliceId = (await users.findOne({ name: 'alice' }))._id;
+  check('explicit _id round-trips', (await users.findOne({ _id: many.insertedIds[0] })).name === 'bob');
+
+  // ---- find: operators ---------------------------------------------------
+  check('$gt + sort desc', (await users.find({ age: { $gt: 28 } }).sort({ age: -1 }).toArray()).map((d) => d.name).join(',') === 'dave,carol,alice');
+  check('$gte', (await users.countDocuments({ age: { $gte: 30 } })) === 3);
+  check('$lt', (await users.countDocuments({ age: { $lt: 30 } })) === 1);
+  check('$lte', (await users.countDocuments({ age: { $lte: 30 } })) === 2);
+  check('$ne', (await users.countDocuments({ age: { $ne: 30 } })) === 3);
+  check('$in', (await users.find({ name: { $in: ['alice', 'bob'] } }).count()) === 2);
+  check('$nin', (await users.countDocuments({ name: { $nin: ['alice', 'bob', 'carol', 'dave'] } })) === 0);
+  check('$exists true', (await users.countDocuments({ tags: { $exists: true } })) === 4);
+  check('$exists false', (await users.countDocuments({ ghost: { $exists: false } })) === 4);
+  check('$regex anchors', (await users.find({ name: /^[bc]/ }).toArray()).length === 2);
+  check('$regex case-insensitive', (await users.countDocuments({ name: /^ALICE$/i })) === 1);
+  check('$not', (await users.countDocuments({ age: { $not: { $gt: 30 } } })) === 2);
+  check('$and', (await users.countDocuments({ $and: [{ age: { $gte: 25 } }, { age: { $lt: 40 } }] })) === 3);
+  check('$or', (await users.countDocuments({ $or: [{ name: 'alice' }, { name: 'dave' }] })) === 2);
+  check('$nor', (await users.countDocuments({ $nor: [{ name: 'alice' }, { name: 'dave' }] })) === 2);
+  check('$size', (await users.countDocuments({ tags: { $size: 2 } })) === 2);
+  check('$all', (await users.countDocuments({ tags: { $all: ['a', 'b'] } })) === 1);
+  check('$elemMatch', (await users.countDocuments({ scores: { $elemMatch: { $gte: 5, $lt: 9 } } })) === 2);
+  check('dot path', (await users.findOne({ 'tags.0': 'c' })).name === 'carol');
+  check('dot path numeric index', (await users.findOne({ 'scores.0': 3 })).name === 'alice');
+  check('array equality', (await users.countDocuments({ scores: [4, 4, 4] })) === 1);
+
+  // ---- find: sort / skip / limit / projection ----------------------------
+  check('skip+limit+sort', (await users.find({}).sort({ age: 1 }).skip(1).limit(2).toArray()).map((d) => d.name).join(',') === 'alice,carol');
+  const proj = await users.findOne({ name: 'alice' }, { projection: { _id: 0, name: 1 } });
+  check('projection', proj.name === 'alice' && proj.age === undefined, JSON.stringify(proj));
+
+  // ---- counts ------------------------------------------------------------
+  check('countDocuments', (await users.countDocuments({})) === 4);
+  check('estimatedDocumentCount', (await users.estimatedDocumentCount()) === 4);
+
+  // ---- update ------------------------------------------------------------
+  const u1 = await users.updateOne({ name: 'alice' }, { $set: { vip: true }, $inc: { age: 1 } });
+  check('updateOne nModified', u1.modifiedCount === 1, u1);
+  const alice = await users.findOne({ _id: aliceId });
+  check('$set+$inc applied', alice.vip === true && alice.age === 31, JSON.stringify(alice));
+  await users.updateOne({ name: 'carol' }, { $unset: { tags: '' } });
+  check('$unset', (await users.findOne({ name: 'carol' })).tags === undefined);
+  await users.updateOne({ name: 'dave' }, { $push: { tags: 'x' }, $rename: { vip: 'member' } });
+  const dave = await users.findOne({ name: 'dave' });
+  check('$push+$rename', dave.tags.length === 1 && dave.member === undefined, JSON.stringify(dave));
+  await users.updateOne({ name: 'dave' }, { $pull: { tags: 'x' } });
+  check('$pull', (await users.findOne({ name: 'dave' })).tags.length === 0);
+  const um = await users.updateMany({}, { $set: { seen: true } });
+  check('updateMany', um.modifiedCount === 4, um);
+  const ups = await users.updateOne({ name: 'erin' }, { $set: { age: 28 } }, { upsert: true });
+  check('upsert create', ups.upsertedCount === 1 && ups.matchedCount === 0, ups);
+  const ups2 = await users.updateOne({ name: 'erin' }, { $set: { age: 29 } }, { upsert: true });
+  check('upsert match', ups2.upsertedCount === 0 && ups2.modifiedCount === 1, ups2);
+
+  // ---- findOneAndUpdate / Delete ------------------------------------------
+  const fam = await users.findOneAndUpdate({ name: 'bob' }, { $set: { lucky: true } }, { returnDocument: 'after' });
+  check('findOneAndUpdate returns new', (fam.value ?? fam).lucky === true);
+  const famDel = await users.findOneAndDelete({ name: 'erin' });
+  check('findOneAndDelete', (famDel.value ?? famDel).name === 'erin');
+
+  // ---- aggregate -----------------------------------------------------------
+  const grp = await users
+    .aggregate([
+      { $match: { age: { $gte: 25 } } },
+      { $group: { _id: '$tags.length', total: { $sum: '$age' } } },
+      { $sort: { _id: 1 } },
+    ])
+    .toArray();
+  check('aggregate $match+$group+$sum', grp.length >= 1 && grp.some((g) => g.total > 0), JSON.stringify(grp));
+  check('aggregate $count', (await users.aggregate([{ $match: {} }, { $count: 'n' }]).toArray())[0].n === 4);
+  // $project here is field selection (inclusion/exclusion); computed fields
+  // like `who: '$name'` are outside the documented surface.
+  const projAgg = await users.aggregate([{ $match: { name: 'alice' } }, { $project: { _id: 0, name: 1 } }]).toArray();
+  check('aggregate $project', projAgg.length === 1 && projAgg[0].name === 'alice' && projAgg[0].age === undefined, JSON.stringify(projAgg));
+
+  // ---- duplicate key -------------------------------------------------------
+  await expectCode(() => users.insertOne({ _id: many.insertedIds[0], name: 'clobber' }), 11000, 'duplicate _id rejected (11000)');
+
+  // ---- indexes -------------------------------------------------------------
+  await users.createIndex({ email: 1 }, { unique: true });
+  await users.createIndex({ name: 1, age: 1 }, { name: 'name_1_age_1' });
+  await users.createIndex({ nickname: 1 }, { sparse: true, name: 'nickname_1_sparse' });
+  await users.createIndex({ score: -1 });
+  const idxs = await users.indexes();
+  const names = idxs.map((i) => i.name).sort();
+  check('indexes listed', names.join(',') === '_id_,email_1,name_1_age_1,nickname_1_sparse,score_-1', names.join(','));
+  await users.updateOne({ name: 'dave' }, { $set: { email: 'dave@x.io', nickname: 'davie' } });
+  check('unique index find', (await users.find({ email: 'dave@x.io' }).toArray()).length === 1);
+  await expectCode(() => users.insertOne({ name: 'dup', email: 'dave@x.io' }), 11000, 'unique index rejects dup (11000)');
+  check('compound prefix find', (await users.find({ name: 'alice', age: 31 }).toArray()).length === 1);
+  check('descending index created', idxs.some((i) => i.key && i.key.score === -1));
+  await users.dropIndex('name_1_age_1');
+  check('dropIndex', !(await users.indexes()).some((i) => i.name === 'name_1_age_1'));
+  await users.dropIndexes();
+  const afterAll = await users.indexes();
+  check('dropIndexes keeps only _id_', afterAll.length === 1 && afterAll[0].name === '_id_', JSON.stringify(afterAll.map((i) => i.name)));
+  // Recreate the unique index: the restart phase depends on it surviving.
+  // Every doc has a distinct email (inserted above), so this is legal — a
+  // unique index over docs that *lack* the field would be E11000 (duplicate
+  // null), exactly as in MongoDB.
+  await users.createIndex({ email: 1 }, { unique: true });
+
+  // ---- TTL -----------------------------------------------------------------
+  const sessions = db.collection('sessions');
+  await sessions.drop().catch(() => {});
+  await sessions.createIndex({ expireAt: 1 }, { expireAfterSeconds: 1 });
+  const now = Date.now();
+  await sessions.insertMany([
+    { _id: 'past', expireAt: new Date(now - 60_000) },
+    { _id: 'future', expireAt: new Date(now + 3_600_000) },
+  ]);
+  check('TTL index listed', (await sessions.indexes()).some((i) => i.name === 'expireAt_1' && Number(i.expireAfterSeconds) === 1));
+  check('TTL past-doc expired', await waitFor(async () => (await sessions.countDocuments({ _id: 'past' })) === 0));
+  check('TTL future-doc survives', (await sessions.countDocuments({ _id: 'future' })) === 1);
+
+  // ---- admin ----------------------------------------------------------------
+  const colls = await db.listCollections({}, { nameOnly: true }).toArray();
+  check('listCollections', colls.some((c) => c.name === 'users') && colls.some((c) => c.name === 'sessions'));
+  const dbs = await db.admin().listDatabases();
+  check('listDatabases has e2e6', dbs.databases.some((d) => d.name === 'e2e6'));
+  // dropDatabase must run against a scratch db so it can't nuke the data the
+  // later phases depend on.
+  const scratch = client.db('e2e6_scratch');
+  await scratch.collection('scratchme').insertOne({ x: 1 });
+  await scratch.dropDatabase();
+  const dbs2 = await db.admin().listDatabases();
+  check('dropDatabase removes it', !dbs2.databases.some((d) => d.name === 'e2e6_scratch'), JSON.stringify(dbs2.databases.map((d) => d.name)));
+
+  return { users, sessions, aliceId };
+}
+
+async function phase2(client, { users, aliceId }) {
+  // Compaction only means something when writes *discard* data: the log is
+  // append-only, so replace/delete records pile up as junk until the
+  // 16 MiB threshold triggers a rewrite of just the live documents.
+  //
+  //   insert 2000 x 12KB  (~24 MB)
+  //   replace all 2000    (+24 MB junk)
+  //   delete half         (+12 MB junk)
+  //
+  //   ~60 MB written; a working compactor leaves the file near the live
+  //   size (~12 MB + one 16 MB epoch), a broken one leaves ~60 MB.
+  const bulk = client.db('e2e6').collection('bulk');
+  await bulk.drop().catch(() => {});
+  const payload = 'z'.repeat(12 * 1024);
+  for (let b = 0; b < 4; b++) {
+    const docs = Array.from({ length: 500 }, (_, i) => ({ _id: b * 500 + i, g: (b * 500 + i) % 2, payload }));
+    await bulk.insertMany(docs);
+  }
+  if (process.env.E2E6_DEBUG) {
+    const dbg = await users.findOne({ name: 'alice' });
+    console.log('DEBUG phase2 after bulk-insert alice _id:', String(dbg._id), 'same:', String(dbg._id) === String(aliceId));
+  }
+  // Watch the log file while the replace junk accumulates. Compaction is
+  // fast (one fsync for the whole rewrite), so a sampled drop can be tiny;
+  // the deterministic signals are that the file *peaked* well above where
+  // it ended (junk accumulated) and *ended* near the live size (compaction
+  // reclaimed it). ~48 MB of records are written here and ~12 MB of it
+  // survives, so without compaction the file would end near 48 MB.
+  //
+  // Both bounds are relative to the live size on purpose: compaction now
+  // triggers on the share of the log that is garbage rather than on bytes
+  // appended, so the absolute peak depends on when that share crosses the
+  // threshold and is not a stable number to assert on.
+  let peakSize = fs.statSync(DBFILE).size;
+  const watcher = setInterval(() => {
+    const s = fs.statSync(DBFILE).size;
+    if (s > peakSize) peakSize = s;
+  }, 10);
+  const payload2 = 'q'.repeat(12 * 1024);
+  const replaced = await bulk.updateMany({}, { $set: { payload: payload2 } });
+  check('bulk replace logged per doc', replaced.modifiedCount === 2000, replaced);
+  const deleted = await bulk.deleteMany({ g: 0 });
+  check('bulk delete half', deleted.deletedCount === 1000, deleted);
+  clearInterval(watcher);
+
+  const logSize = fs.statSync(DBFILE).size;
+  if (process.env.E2E6_DEBUG) {
+    const dbg = await users.findOne({ name: 'alice' });
+    console.log('DEBUG phase2 after replace+delete alice _id:', String(dbg._id), 'same:', String(dbg._id) === String(aliceId));
+    console.log('DEBUG phase2 log size:', logSize);
+  }
+  check(
+    'compaction reclaimed junk (file ~ live size)',
+    logSize < 24 * 1024 * 1024 && peakSize > logSize * 1.4,
+    `file peaked at ${(peakSize / 1e6).toFixed(1)}MB, ended at ${(logSize / 1e6).toFixed(1)}MB after ~48MB of records were written (~12MB live)`,
+  );
+  check('bulk survivors intact', (await bulk.findOne({ _id: 1999 })).payload === payload2);
+  check('bulk count after delete', (await bulk.countDocuments({})) === 1000);
+
+  // Phase-1 data survives in memory (erin was deleted in phase 1, so 4).
+  check('users count after bulk', (await users.countDocuments({})) === 4);
+
+  // ---- graceful restart -----------------------------------------------------
+  await stopServer('SIGTERM');
+  await startServer();
+  const client2 = new MongoClient(URL, { serverSelectionTimeoutMS: 5000 });
+  await client2.connect();
+  const db2 = client2.db('e2e6');
+  const users2 = db2.collection('users');
+
+  check('after restart: users count', (await users2.countDocuments({})) === 4);
+  if (process.env.E2E6_DEBUG) {
+    console.log('DEBUG aliceId:', String(aliceId), 'isOID', aliceId instanceof ObjectId);
+    console.log('DEBUG all users:', JSON.stringify(await users2.find({}).toArray()));
+    console.log('DEBUG bulk:', JSON.stringify(await db2.collection('bulk').find({}, { projection: { payload: 0 } }).limit(5).toArray()));
+    console.log('DEBUG sessions:', JSON.stringify(await db2.collection('sessions').find({}).toArray()));
+    console.log('DEBUG colls:', JSON.stringify(await db2.listCollections({}, { nameOnly: true }).toArray()));
+    console.log('DEBUG dbs:', JSON.stringify((await db2.admin().listDatabases()).databases.map((d) => d.name)));
+    console.log('DEBUG log file size:', fs.statSync(DBFILE).size);
+  }
+  const alice2 = await users2.findOne({ _id: aliceId });
+  check('after restart: doc content', alice2.name === 'alice' && alice2.age === 31 && alice2.seen === true, JSON.stringify(alice2));
+  check('after restart: unique index find', (await users2.find({ email: 'dave@x.io' }).toArray()).length === 1);
+  check('after restart: unique index still enforced', await (async () => {
+    try {
+      await users2.insertOne({ name: 'dup2', email: 'dave@x.io' });
+      return false;
+    } catch (e) {
+      return e.code === 11000;
+    }
+  })());
+  check('after restart: bulk count', (await db2.collection('bulk').countDocuments({})) === 1000);
+  check('after restart: TTL index listed', (await db2.collection('sessions').indexes()).some((i) => i.name === 'expireAt_1'));
+  return client2;
+}
+
+async function phase3(client) {
+  // ---- kill -9 mid-write ----------------------------------------------------
+  // Every write is logged + fsynced before it becomes visible, so whatever
+  // count we see before the kill must be there after the restart.
+  const crash = client.db('e2e6').collection('crash');
+  await crash.drop().catch(() => {});
+  let committed = 0;
+  for (let i = 1; i <= 150; i++) {
+    await crash.insertOne({ _id: i, seq: i });
+    committed = i;
+  }
+  check('crash: committed before kill', committed === 150);
+  await client.close();
+
+  await stopServer('SIGKILL');
+  await startServer();
+  const c3 = new MongoClient(URL, { serverSelectionTimeoutMS: 5000 });
+  await c3.connect();
+  const db3 = c3.db('e2e6');
+
+  const n = await db3.collection('crash').countDocuments({});
+  check('crash recovery: all committed docs survived kill -9', n === 150, n);
+  check('crash recovery: last doc intact', (await db3.collection('crash').findOne({ _id: 150 })).seq === 150);
+  check('crash recovery: pre-crash data intact', (await db3.collection('users').countDocuments({})) === 4);
+  await db3.collection('crash').insertOne({ _id: 151, seq: 151 });
+  check('crash recovery: writes continue', (await db3.collection('crash').countDocuments({})) === 151);
+  await c3.close();
+}
+
+async function main() {
+  if (!fs.existsSync(BIN)) {
+    console.error(`server binary not found at ${BIN} — run \`zig build\` first`);
+    process.exit(1);
+  }
+  await startServer(true);
+  const client = new MongoClient(URL, { serverSelectionTimeoutMS: 5000 });
+  await client.connect();
+  const db = client.db('e2e6');
+
+  console.log('phase 1: feature surface');
+  const state = await phase1(client, db);
+  console.log('phase 2: compaction + graceful restart');
+  const client2 = await phase2(client, state);
+  // The phase-1 client's connection died with the restart; close it so the
+  // process can exit (and so the exit handler can reap the server child).
+  await client.close().catch(() => {});
+  console.log('phase 3: kill -9 crash recovery');
+  await phase3(client2);
+
+  if (process.env.E2E6_KEEP !== '1') fs.rmSync(DBFILE, { force: true });
+  await stopServer('SIGTERM');
+
+  const failed = results.filter((r) => !r.ok);
+  console.log(`\n${results.length - failed.length}/${results.length} checks passed`);
+  if (failed.length) {
+    console.log('FAILED:', failed.map((f) => f.name).join(', '));
+    console.log('--- server log tail ---');
+    console.log(serverLog.split('\n').slice(-30).join('\n'));
+    process.exit(1);
+  }
+  console.log('E2E6_OK');
+}
+
+main().catch((e) => {
+  console.error('E2E6_FAIL', e);
+  console.log('--- server log tail ---');
+  console.log(serverLog.split('\n').slice(-40).join('\n'));
+  process.exit(1);
+});