@fairyhunter13/opentui-core 0.1.88 → 0.1.90

package/src/zig/tests/rope_test.zig

@@ -0,0 +1,2362 @@
+const std = @import("std");
+const rope_mod = @import("../rope.zig");
+
+const SimpleItem = struct {
+    value: u32,
+
+    pub fn empty() SimpleItem {
+        return .{ .value = 0 };
+    }
+
+    pub fn is_empty(self: *const SimpleItem) bool {
+        return self.value == 0;
+    }
+};
+
+const ItemWithMetrics = struct {
+    value: u32,
+    size: u32,
+
+    pub const Metrics = struct {
+        total_size: u32 = 0,
+
+        pub fn add(self: *Metrics, other: Metrics) void {
+            self.total_size += other.total_size;
+        }
+    };
+
+    pub fn measure(self: *const ItemWithMetrics) Metrics {
+        return .{ .total_size = self.size };
+    }
+
+    pub fn empty() ItemWithMetrics {
+        return .{ .value = 0, .size = 0 };
+    }
+
+    pub fn is_empty(self: *const ItemWithMetrics) bool {
+        return self.value == 0 and self.size == 0;
+    }
+};
+
+//===== Basic Rope Tests =====
+
+test "Rope - can initialize with arena allocator" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.init(arena.allocator());
+    try std.testing.expectEqual(@as(u32, 0), rope.count()); // Sentinel filtered
+}
+
+test "Rope - from_item creates single item rope" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 42 });
+
+    try std.testing.expectEqual(@as(u32, 1), rope.count());
+    const item = rope.get(0);
+    try std.testing.expect(item != null);
+    try std.testing.expectEqual(@as(u32, 42), item.?.value);
+}
+
+test "Rope - from_slice creates rope from multiple items" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+        .{ .value = 3 },
+    };
+
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+    try std.testing.expectEqual(@as(u32, 3), rope.count());
+
+    try std.testing.expectEqual(@as(u32, 1), rope.get(0).?.value);
+    try std.testing.expectEqual(@as(u32, 2), rope.get(1).?.value);
+    try std.testing.expectEqual(@as(u32, 3), rope.get(2).?.value);
+}
+
+test "Rope - get with out of bounds returns null" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    try std.testing.expect(rope.get(100) == null);
+}
+
+//===== Insert Tests =====
+
+test "Rope - insert at beginning" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    try rope.insert(0, .{ .value = 0 });
+
+    try std.testing.expectEqual(@as(u32, 2), rope.count());
+    try std.testing.expectEqual(@as(u32, 0), rope.get(0).?.value);
+    try std.testing.expectEqual(@as(u32, 1), rope.get(1).?.value);
+}
+
+test "Rope - insert at end" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    try rope.insert(1, .{ .value = 2 });
+
+    try std.testing.expectEqual(@as(u32, 2), rope.count());
+    try std.testing.expectEqual(@as(u32, 1), rope.get(0).?.value);
+    try std.testing.expectEqual(@as(u32, 2), rope.get(1).?.value);
+}
+
+test "Rope - multiple inserts" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.init(arena.allocator());
+
+    try rope.insert(0, .{ .value = 1 });
+    try rope.insert(1, .{ .value = 2 });
+    try rope.insert(2, .{ .value = 3 });
+
+    try std.testing.expectEqual(@as(u32, 3), rope.count()); // Sentinel filtered
+}
+
+//===== Delete Tests =====
+
+test "Rope - delete at beginning" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+        .{ .value = 3 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    try rope.delete(0);
+
+    try std.testing.expectEqual(@as(u32, 2), rope.count());
+    try std.testing.expectEqual(@as(u32, 2), rope.get(0).?.value);
+}
+
+test "Rope - delete in middle" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+        .{ .value = 3 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    try rope.delete(1);
+
+    try std.testing.expectEqual(@as(u32, 2), rope.count());
+    try std.testing.expectEqual(@as(u32, 1), rope.get(0).?.value);
+    try std.testing.expectEqual(@as(u32, 3), rope.get(1).?.value);
+}
+
+//===== Walk Tests =====
+
+test "Rope - walk all items" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 10 },
+        .{ .value = 20 },
+        .{ .value = 30 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    const Context = struct {
+        sum: u32 = 0,
+
+        fn walker(ctx: *anyopaque, data: *const SimpleItem, index: u32) RopeType.Node.WalkerResult {
+            _ = index;
+            const self = @as(*@This(), @ptrCast(@alignCast(ctx)));
+            self.sum += data.value;
+            return .{};
+        }
+    };
+
+    var ctx = Context{};
+    try rope.walk(&ctx, Context.walker);
+
+    try std.testing.expectEqual(@as(u32, 60), ctx.sum);
+}
+
+test "Rope - walk with early exit" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+        .{ .value = 3 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    const Context = struct {
+        count: u32 = 0,
+
+        fn walker(ctx: *anyopaque, data: *const SimpleItem, index: u32) RopeType.Node.WalkerResult {
+            _ = index;
+            const self = @as(*@This(), @ptrCast(@alignCast(ctx)));
+            self.count += 1;
+            if (data.value == 2) {
+                return .{ .keep_walking = false };
+            }
+            return .{};
+        }
+    };
+
+    var ctx = Context{};
+    try rope.walk(&ctx, Context.walker);
+
+    try std.testing.expectEqual(@as(u32, 2), ctx.count);
+}
+
+//===== Metrics Tests =====
+
+test "Rope - custom metrics are tracked" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(ItemWithMetrics);
+    const items = [_]ItemWithMetrics{
+        .{ .value = 1, .size = 10 },
+        .{ .value = 2, .size = 20 },
+        .{ .value = 3, .size = 30 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    const metrics = rope.root.metrics();
+    try std.testing.expectEqual(@as(u32, 3), metrics.count);
+    try std.testing.expectEqual(@as(u32, 60), metrics.custom.total_size);
+}
+
+test "Rope - rebalance maintains data" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var items: [20]SimpleItem = undefined;
+    for (&items, 0..) |*item, i| {
+        item.* = .{ .value = @intCast(i) };
+    }
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    try rope.rebalance(arena.allocator());
+
+    // Data should be preserved
+    try std.testing.expectEqual(@as(u32, 20), rope.count());
+    try std.testing.expectEqual(@as(u32, 0), rope.get(0).?.value);
+    try std.testing.expectEqual(@as(u32, 10), rope.get(10).?.value);
+    try std.testing.expectEqual(@as(u32, 19), rope.get(19).?.value);
+}
+
+//===== Stress Tests =====
+
+test "Rope - large number of items" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var items: [100]SimpleItem = undefined;
+    for (&items, 0..) |*item, i| {
+        item.* = .{ .value = @intCast(i) };
+    }
+
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    try std.testing.expectEqual(@as(u32, 100), rope.count());
+    try std.testing.expectEqual(@as(u32, 0), rope.get(0).?.value);
+    try std.testing.expectEqual(@as(u32, 50), rope.get(50).?.value);
+    try std.testing.expectEqual(@as(u32, 99), rope.get(99).?.value);
+}
+
+test "Rope - many insert operations" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.init(arena.allocator());
+
+    for (0..50) |i| {
+        try rope.insert(@intCast(i), .{ .value = @intCast(i) });
+    }
+
+    try std.testing.expectEqual(@as(u32, 50), rope.count()); // Sentinel filtered
+}
+
+//===== Nested Rope Tests (Lines→Chunks Pattern) =====
+
+// Chunk type similar to what would be used in text buffer
+const Chunk = struct {
+    data: []const u8,
+    width: u32,
+
+    pub const Metrics = struct {
+        total_width: u32 = 0,
+        total_bytes: u32 = 0,
+
+        pub fn add(self: *Metrics, other: Metrics) void {
+            self.total_width += other.total_width;
+            self.total_bytes += other.total_bytes;
+        }
+    };
+
+    pub fn measure(self: *const Chunk) Metrics {
+        return .{
+            .total_width = self.width,
+            .total_bytes = @intCast(self.data.len),
+        };
+    }
+
+    pub fn empty() Chunk {
+        return .{ .data = "", .width = 0 };
+    }
+
+    pub fn is_empty(self: *const Chunk) bool {
+        return self.data.len == 0;
+    }
+};
+
+// Static empty chunk rope node for Line.empty()
+const empty_chunk_leaf_node = rope_mod.Rope(Chunk).Node{
+    .leaf = .{
+        .data = Chunk.empty(),
+    },
+};
+
+// Line type containing a rope of chunks
+const Line = struct {
+    chunks: rope_mod.Rope(Chunk),
+    line_id: u32,
+
+    pub const Metrics = struct {
+        total_width: u32 = 0,
+        total_lines: u32 = 1,
+
+        pub fn add(self: *Metrics, other: Metrics) void {
+            self.total_width += other.total_width;
+            self.total_lines += other.total_lines;
+        }
+    };
+
+    pub fn measure(self: *const Line) Metrics {
+        const chunk_metrics = self.chunks.root.metrics();
+        return .{
+            .total_width = chunk_metrics.custom.total_width,
+            .total_lines = 1,
+        };
+    }
+
+    pub fn empty() Line {
+        // Use static empty chunk rope - safe because it's immutable
+        const ChunkRope = rope_mod.Rope(Chunk);
+        return .{
+            .chunks = .{
+                .root = &empty_chunk_leaf_node,
+                .allocator = undefined, // Never used for empty
+                .empty_leaf = &empty_chunk_leaf_node,
+                .marker_cache = ChunkRope.MarkerCache.init(undefined),
+            },
+            .line_id = 0,
+        };
+    }
+
+    pub fn is_empty(self: *const Line) bool {
+        return self.line_id == 0 and self.chunks.count() == 1;
+    }
+};
+
+test "Rope - replace item at index" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+        .{ .value = 3 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    try rope.replace(1, .{ .value = 20 });
+
+    try std.testing.expectEqual(@as(u32, 3), rope.count());
+    try std.testing.expectEqual(@as(u32, 1), rope.get(0).?.value);
+    try std.testing.expectEqual(@as(u32, 20), rope.get(1).?.value);
+    try std.testing.expectEqual(@as(u32, 3), rope.get(2).?.value);
+}
+
+test "Rope - append item" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    try rope.append(.{ .value = 2 });
+    try rope.append(.{ .value = 3 });
+
+    try std.testing.expectEqual(@as(u32, 3), rope.count());
+    try std.testing.expectEqual(@as(u32, 1), rope.get(0).?.value);
+    try std.testing.expectEqual(@as(u32, 2), rope.get(1).?.value);
+    try std.testing.expectEqual(@as(u32, 3), rope.get(2).?.value);
+}
+
+test "Rope - prepend item" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 3 });
+
+    try rope.prepend(.{ .value = 2 });
+    try rope.prepend(.{ .value = 1 });
+
+    try std.testing.expectEqual(@as(u32, 3), rope.count());
+    try std.testing.expectEqual(@as(u32, 1), rope.get(0).?.value);
+    try std.testing.expectEqual(@as(u32, 2), rope.get(1).?.value);
+    try std.testing.expectEqual(@as(u32, 3), rope.get(2).?.value);
+}
+
+test "Rope - concatenate two ropes" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+
+    const items1 = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+    };
+    var rope1 = try RopeType.from_slice(arena.allocator(), &items1);
+
+    const items2 = [_]SimpleItem{
+        .{ .value = 3 },
+        .{ .value = 4 },
+    };
+    const rope2 = try RopeType.from_slice(arena.allocator(), &items2);
+
+    try rope1.concat(&rope2);
+
+    try std.testing.expectEqual(@as(u32, 4), rope1.count());
+    try std.testing.expectEqual(@as(u32, 1), rope1.get(0).?.value);
+    try std.testing.expectEqual(@as(u32, 2), rope1.get(1).?.value);
+    try std.testing.expectEqual(@as(u32, 3), rope1.get(2).?.value);
+    try std.testing.expectEqual(@as(u32, 4), rope1.get(3).?.value);
+}
+
+//===== Undo/Redo Tests =====
+
+test "Rope - basic undo operation" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    try rope.store_undo("initial");
+
+    try rope.insert(1, .{ .value = 2 });
+    try std.testing.expectEqual(@as(u32, 2), rope.count());
+
+    const meta = try rope.undo("before undo");
+    try std.testing.expectEqualStrings("initial", meta);
+    try std.testing.expectEqual(@as(u32, 1), rope.count());
+}
+
+test "Rope - basic redo operation" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    try rope.store_undo("initial");
+    try rope.insert(1, .{ .value = 2 });
+
+    _ = try rope.undo("before undo");
+    try std.testing.expectEqual(@as(u32, 1), rope.count());
+
+    const meta = try rope.redo();
+    try std.testing.expectEqualStrings("before undo", meta);
+    try std.testing.expectEqual(@as(u32, 2), rope.count());
+}
+
+test "Rope - multiple undo/redo operations" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    try rope.store_undo("state1");
+    try rope.append(.{ .value = 2 });
+
+    try rope.store_undo("state2");
+    try rope.append(.{ .value = 3 });
+
+    try rope.store_undo("state3");
+    try rope.append(.{ .value = 4 });
+
+    try std.testing.expectEqual(@as(u32, 4), rope.count());
+
+    _ = try rope.undo("current");
+    try std.testing.expectEqual(@as(u32, 3), rope.count());
+
+    _ = try rope.undo("current");
+    try std.testing.expectEqual(@as(u32, 2), rope.count());
+
+    _ = try rope.redo();
+    try std.testing.expectEqual(@as(u32, 3), rope.count());
+}
+
+test "Rope - undo/redo with delete operations" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+        .{ .value = 3 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    try rope.store_undo("before delete");
+    try rope.delete(1);
+
+    try std.testing.expectEqual(@as(u32, 2), rope.count());
+    try std.testing.expectEqual(@as(u32, 1), rope.get(0).?.value);
+    try std.testing.expectEqual(@as(u32, 3), rope.get(1).?.value);
+
+    _ = try rope.undo("after delete");
+    try std.testing.expectEqual(@as(u32, 3), rope.count());
+    try std.testing.expectEqual(@as(u32, 2), rope.get(1).?.value);
+}
+
+test "Rope - undo/redo with replace operations" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 10 });
+
+    try rope.store_undo("original");
+    try rope.replace(0, .{ .value = 20 });
+    try std.testing.expectEqual(@as(u32, 20), rope.get(0).?.value);
+
+    _ = try rope.undo("after replace");
+    try std.testing.expectEqual(@as(u32, 10), rope.get(0).?.value);
+
+    _ = try rope.redo();
+    try std.testing.expectEqual(@as(u32, 20), rope.get(0).?.value);
+}
+
+test "Rope - can_undo and can_redo" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    try std.testing.expect(!rope.can_undo());
+    try std.testing.expect(!rope.can_redo());
+
+    try rope.store_undo("state1");
+    try std.testing.expect(rope.can_undo());
+    try std.testing.expect(!rope.can_redo());
+
+    _ = try rope.undo("current");
+    try std.testing.expect(!rope.can_undo()); // No more undo (only one state)
+    try std.testing.expect(rope.can_redo());
+}
+
+test "Rope - clear history" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    try rope.store_undo("state1");
+    try rope.append(.{ .value = 2 });
+    try rope.store_undo("state2");
+
+    try std.testing.expect(rope.can_undo());
+
+    rope.clear_history();
+    try std.testing.expect(!rope.can_undo());
+    try std.testing.expect(!rope.can_redo());
+}
+
+test "Rope - undo fails when no history" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    // No history stored, undo should fail
+    const result = rope.undo("current");
+    try std.testing.expectError(error.Stop, result);
+}
+
+test "Rope - redo fails when no redo history" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    // No redo history, redo should fail
+    const result = rope.redo();
+    try std.testing.expectError(error.Stop, result);
+}
+
+test "Rope - complex undo/redo workflow" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.init(arena.allocator());
+
+    // Build up a sequence of operations
+    try rope.store_undo("empty");
+    try rope.insert(0, .{ .value = 1 });
+
+    try rope.store_undo("one item");
+    try rope.append(.{ .value = 2 });
+
+    try rope.store_undo("two items");
+    try rope.append(.{ .value = 3 });
+
+    try rope.store_undo("three items");
+    try rope.delete(1); // Remove middle
+
+    // State: [1, 3]
+    try std.testing.expectEqual(@as(u32, 2), rope.count()); // Sentinel filtered
+
+    // Undo delete
+    _ = try rope.undo("current");
+    try std.testing.expectEqual(@as(u32, 3), rope.count());
+
+    // Undo append
+    _ = try rope.undo("current");
+    try std.testing.expectEqual(@as(u32, 2), rope.count());
+
+    // Redo append
+    _ = try rope.redo();
+    try std.testing.expectEqual(@as(u32, 3), rope.count());
+}
+
+test "Rope - undo/redo with metadata tracking" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    try rope.store_undo("insert operation");
+    try rope.append(.{ .value = 2 });
+
+    try rope.store_undo("delete operation");
+    try rope.delete(0);
+
+    // Undo and check metadata
+    const meta1 = try rope.undo("current state");
+    try std.testing.expectEqualStrings("delete operation", meta1);
+
+    const meta2 = try rope.undo("current state");
+    try std.testing.expectEqualStrings("insert operation", meta2);
+}
+
+test "Rope - undo invalidates redo after new operation" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    try rope.store_undo("state1");
+    try rope.append(.{ .value = 2 });
+
+    try rope.store_undo("state2");
+    try rope.append(.{ .value = 3 });
+
+    // Undo once
+    _ = try rope.undo("current");
+    try std.testing.expect(rope.can_redo());
+
+    // Make a new change - this stores the old redo as a branch and clears redo
+    try rope.store_undo("new branch");
+    try rope.append(.{ .value = 99 });
+
+    // Redo should NOT work anymore (it was saved as a branch)
+    try std.testing.expect(!rope.can_redo());
+
+    // But we can still undo
+    try std.testing.expect(rope.can_undo());
+}
+
+test "Rope - undo/redo with nested ropes" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    const chunks1 = [_]Chunk{.{ .data = "Line 1", .width = 6 }};
+    const line1 = Line{
+        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks1),
+        .line_id = 1,
+    };
+
+    const RopeType = rope_mod.Rope(Line);
+    var rope = try RopeType.from_item(allocator, line1);
+
+    try rope.store_undo("before append");
+
+    const chunks2 = [_]Chunk{.{ .data = "Line 2", .width = 6 }};
+    const line2 = Line{
+        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks2),
+        .line_id = 2,
+    };
+    try rope.append(line2);
+
+    try std.testing.expectEqual(@as(u32, 2), rope.count());
+
+    // Undo
+    _ = try rope.undo("after append");
+    try std.testing.expectEqual(@as(u32, 1), rope.count());
+
+    // Redo
+    _ = try rope.redo();
+    try std.testing.expectEqual(@as(u32, 2), rope.count());
+}
+
+test "Rope - stress test undo/redo with many operations" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.init(arena.allocator());
+
+    // Perform 20 operations
+    for (0..20) |i| {
+        try rope.store_undo("operation");
+        try rope.append(.{ .value = @intCast(i) });
+    }
+
+    try std.testing.expectEqual(@as(u32, 20), rope.count()); // Sentinel filtered
+
+    // Undo 10 operations
+    for (0..10) |_| {
+        _ = try rope.undo("current");
+    }
+    try std.testing.expectEqual(@as(u32, 10), rope.count());
+
+    // Redo 5 operations
+    for (0..5) |_| {
+        _ = try rope.redo();
+    }
+    try std.testing.expectEqual(@as(u32, 15), rope.count());
+}
+
+//===== Bulk/Range Operations Tests =====
+
+test "Rope - split at beginning" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+        .{ .value = 3 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    const right = try rope.split(0);
+
+    try std.testing.expectEqual(@as(u32, 0), rope.count()); // Sentinel filtered
+    try std.testing.expectEqual(@as(u32, 3), right.count());
+    try std.testing.expectEqual(@as(u32, 1), right.get(0).?.value);
+}
+
+test "Rope - split at middle" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+        .{ .value = 3 },
+        .{ .value = 4 },
+        .{ .value = 5 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    const right = try rope.split(2);
+
+    try std.testing.expectEqual(@as(u32, 2), rope.count());
+    try std.testing.expectEqual(@as(u32, 1), rope.get(0).?.value);
+    try std.testing.expectEqual(@as(u32, 2), rope.get(1).?.value);
+
+    try std.testing.expectEqual(@as(u32, 3), right.count());
+    try std.testing.expectEqual(@as(u32, 3), right.get(0).?.value);
+    try std.testing.expectEqual(@as(u32, 4), right.get(1).?.value);
+    try std.testing.expectEqual(@as(u32, 5), right.get(2).?.value);
+}
+
+test "Rope - split at end" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+        .{ .value = 3 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    const right = try rope.split(3);
+
+    try std.testing.expectEqual(@as(u32, 3), rope.count());
+    try std.testing.expectEqual(@as(u32, 0), right.count()); // Sentinel filtered
+}
+
+test "Rope - slice full range" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+        .{ .value = 3 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    const sliced = try rope.slice(0, 3, arena.allocator());
+    defer arena.allocator().free(sliced);
+
+    try std.testing.expectEqual(@as(usize, 3), sliced.len);
+    try std.testing.expectEqual(@as(u32, 1), sliced[0].value);
+    try std.testing.expectEqual(@as(u32, 2), sliced[1].value);
+    try std.testing.expectEqual(@as(u32, 3), sliced[2].value);
+}
+
+test "Rope - slice partial range" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 10 },
+        .{ .value = 20 },
+        .{ .value = 30 },
+        .{ .value = 40 },
+        .{ .value = 50 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    const sliced = try rope.slice(1, 4, arena.allocator());
+    defer arena.allocator().free(sliced);
+
+    try std.testing.expectEqual(@as(usize, 3), sliced.len);
+    try std.testing.expectEqual(@as(u32, 20), sliced[0].value);
+    try std.testing.expectEqual(@as(u32, 30), sliced[1].value);
+    try std.testing.expectEqual(@as(u32, 40), sliced[2].value);
+}
+
+test "Rope - slice empty range" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    const sliced = try rope.slice(1, 1, arena.allocator());
+    defer arena.allocator().free(sliced);
+
+    try std.testing.expectEqual(@as(usize, 0), sliced.len);
+}
+
+test "Rope - delete_range at beginning" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+        .{ .value = 3 },
+        .{ .value = 4 },
+        .{ .value = 5 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    try rope.delete_range(0, 2);
+
+    try std.testing.expectEqual(@as(u32, 3), rope.count());
+    try std.testing.expectEqual(@as(u32, 3), rope.get(0).?.value);
+    try std.testing.expectEqual(@as(u32, 4), rope.get(1).?.value);
+    try std.testing.expectEqual(@as(u32, 5), rope.get(2).?.value);
+}
+
+test "Rope - delete_range in middle" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+        .{ .value = 3 },
+        .{ .value = 4 },
+        .{ .value = 5 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    try rope.delete_range(1, 4);
+
+    try std.testing.expectEqual(@as(u32, 2), rope.count());
+    try std.testing.expectEqual(@as(u32, 1), rope.get(0).?.value);
+    try std.testing.expectEqual(@as(u32, 5), rope.get(1).?.value);
+}
+
+test "Rope - delete_range at end" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+        .{ .value = 3 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    try rope.delete_range(1, 3);
+
+    try std.testing.expectEqual(@as(u32, 1), rope.count());
+    try std.testing.expectEqual(@as(u32, 1), rope.get(0).?.value);
+}
+
+test "Rope - delete_range empty (same indices)" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    try rope.delete_range(1, 1);
+
+    try std.testing.expectEqual(@as(u32, 2), rope.count());
+}
+
+test "Rope - insert_slice at beginning" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 3 });
+
+    const to_insert = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+    };
+    try rope.insert_slice(0, &to_insert);
+
+    try std.testing.expectEqual(@as(u32, 3), rope.count());
+    try std.testing.expectEqual(@as(u32, 1), rope.get(0).?.value);
+    try std.testing.expectEqual(@as(u32, 2), rope.get(1).?.value);
+    try std.testing.expectEqual(@as(u32, 3), rope.get(2).?.value);
+}
+
+test "Rope - insert_slice in middle" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 4 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    const to_insert = [_]SimpleItem{
+        .{ .value = 2 },
+        .{ .value = 3 },
+    };
+    try rope.insert_slice(1, &to_insert);
+
+    try std.testing.expectEqual(@as(u32, 4), rope.count());
+    try std.testing.expectEqual(@as(u32, 1), rope.get(0).?.value);
+    try std.testing.expectEqual(@as(u32, 2), rope.get(1).?.value);
+    try std.testing.expectEqual(@as(u32, 3), rope.get(2).?.value);
+    try std.testing.expectEqual(@as(u32, 4), rope.get(3).?.value);
+}
+
+test "Rope - insert_slice at end" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    const to_insert = [_]SimpleItem{
+        .{ .value = 3 },
+        .{ .value = 4 },
+    };
+    try rope.insert_slice(2, &to_insert);
+
+    try std.testing.expectEqual(@as(u32, 4), rope.count());
+    try std.testing.expectEqual(@as(u32, 3), rope.get(2).?.value);
+    try std.testing.expectEqual(@as(u32, 4), rope.get(3).?.value);
+}
+
+test "Rope - insert_slice empty array" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    const to_insert: []const SimpleItem = &[_]SimpleItem{};
+    try rope.insert_slice(0, to_insert);
+
+    try std.testing.expectEqual(@as(u32, 1), rope.count());
+}
+
+test "Rope - to_array with simple items" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 10 },
+        .{ .value = 20 },
+        .{ .value = 30 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    const array = try rope.to_array(arena.allocator());
+    defer arena.allocator().free(array);
+
+    try std.testing.expectEqual(@as(usize, 3), array.len);
+    try std.testing.expectEqual(@as(u32, 10), array[0].value);
+    try std.testing.expectEqual(@as(u32, 20), array[1].value);
+    try std.testing.expectEqual(@as(u32, 30), array[2].value);
+}
+
+test "Rope - to_array empty rope" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.init(arena.allocator());
+
+    const array = try rope.to_array(arena.allocator());
+    defer arena.allocator().free(array);
+
+    try std.testing.expectEqual(@as(usize, 0), array.len); // Sentinel filtered
+}
+
+test "Rope - combined bulk operations" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+        .{ .value = 3 },
+        .{ .value = 4 },
+        .{ .value = 5 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    try rope.delete_range(2, 4);
+    try std.testing.expectEqual(@as(u32, 3), rope.count());
+
+    const to_insert = [_]SimpleItem{
+        .{ .value = 30 },
+        .{ .value = 40 },
+    };
+    try rope.insert_slice(1, &to_insert);
+    try std.testing.expectEqual(@as(u32, 5), rope.count());
+
+    const array = try rope.to_array(arena.allocator());
+    defer arena.allocator().free(array);
+
+    try std.testing.expectEqual(@as(u32, 1), array[0].value);
+    try std.testing.expectEqual(@as(u32, 30), array[1].value);
+    try std.testing.expectEqual(@as(u32, 40), array[2].value);
+    try std.testing.expectEqual(@as(u32, 2), array[3].value);
+    try std.testing.expectEqual(@as(u32, 5), array[4].value);
+}
+
+test "Rope - undo/redo with bulk operations" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+        .{ .value = 3 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    // Store state
+    try rope.store_undo("before bulk");
+
+    // Bulk insert
+    const to_insert = [_]SimpleItem{
+        .{ .value = 10 },
+        .{ .value = 20 },
+    };
+    try rope.insert_slice(1, &to_insert);
+    try std.testing.expectEqual(@as(u32, 5), rope.count());
+
+    // Undo
+    _ = try rope.undo("after bulk");
+    try std.testing.expectEqual(@as(u32, 3), rope.count());
+
+    // Redo
+    _ = try rope.redo();
+    try std.testing.expectEqual(@as(u32, 5), rope.count());
+}
+
+//===== Edge Case Tests =====
+
+test "Rope - slice with start > end returns empty" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+        .{ .value = 3 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    const sliced = try rope.slice(2, 1, arena.allocator());
+    defer arena.allocator().free(sliced);
+
+    try std.testing.expectEqual(@as(usize, 0), sliced.len);
+}
+
+test "Rope - slice beyond bounds" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    // Should only get items that exist
+    const sliced = try rope.slice(0, 100, arena.allocator());
+    defer arena.allocator().free(sliced);
+
+    try std.testing.expectEqual(@as(usize, 2), sliced.len);
+}
+
+test "Rope - delete_range with start > end does nothing" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    try rope.delete_range(2, 1);
+
+    try std.testing.expectEqual(@as(u32, 2), rope.count());
+}
+
+test "Rope - insert_slice beyond count appends" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    const to_insert = [_]SimpleItem{
+        .{ .value = 2 },
+        .{ .value = 3 },
+    };
+    try rope.insert_slice(100, &to_insert);
+
+    try std.testing.expectEqual(@as(u32, 3), rope.count());
+    try std.testing.expectEqual(@as(u32, 2), rope.get(1).?.value);
+    try std.testing.expectEqual(@as(u32, 3), rope.get(2).?.value);
+}
+
+test "Rope - replace at out of bounds does nothing" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    try rope.replace(100, .{ .value = 999 });
+
+    try std.testing.expectEqual(@as(u32, 1), rope.count());
+    try std.testing.expectEqual(@as(u32, 1), rope.get(0).?.value);
+}
+
+test "Rope - delete at out of bounds" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    // This should handle gracefully (delete beyond bounds)
+    try rope.delete(100);
+
+    // Count unchanged
+    try std.testing.expectEqual(@as(u32, 1), rope.count());
+}
+
+test "Rope - split at zero creates empty left" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    const right = try rope.split(0);
+
+    try std.testing.expectEqual(@as(u32, 0), rope.count()); // Sentinel filtered
+    try std.testing.expectEqual(@as(u32, 2), right.count());
+}
+
+test "Rope - split beyond count" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    const right = try rope.split(100);
+
+    try std.testing.expectEqual(@as(u32, 2), rope.count());
+    try std.testing.expectEqual(@as(u32, 0), right.count()); // Sentinel filtered
+}
+
+test "Rope - multiple undo without operations" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    try rope.store_undo("state1");
+    try rope.store_undo("state2");
+
+    // Two undos back to back
+    _ = try rope.undo("current");
+    _ = try rope.undo("current");
+
+    // Should fail on third
+    const result = rope.undo("current");
+    try std.testing.expectError(error.Stop, result);
+}
+
+test "Rope - stress test with 1000 items" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var items: [1000]SimpleItem = undefined;
+    for (&items, 0..) |*item, i| {
+        item.* = .{ .value = @intCast(i) };
+    }
+
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    try std.testing.expectEqual(@as(u32, 1000), rope.count());
+    try std.testing.expectEqual(@as(u32, 0), rope.get(0).?.value);
+    try std.testing.expectEqual(@as(u32, 500), rope.get(500).?.value);
+    try std.testing.expectEqual(@as(u32, 999), rope.get(999).?.value);
+
+    const depth = rope.root.depth();
+    try std.testing.expect(depth < 20); // log2(1000) ≈ 10, allow some slack
+}
+
+test "Rope - delete_range entire rope" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+        .{ .value = 3 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    try rope.delete_range(0, 3);
+
+    // Should be empty (sentinel filtered)
+    try std.testing.expectEqual(@as(u32, 0), rope.count());
+}
+
+test "Rope - to_array single item" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 42 });
+
+    const array = try rope.to_array(arena.allocator());
+    defer arena.allocator().free(array);
+
+    try std.testing.expectEqual(@as(usize, 1), array.len);
+    try std.testing.expectEqual(@as(u32, 42), array[0].value);
+}
+
+test "Rope - concat with empty rope" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope1 = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+    const rope2 = try RopeType.init(arena.allocator());
+
+    try rope1.concat(&rope2);
+
+    try std.testing.expectEqual(@as(u32, 1), rope1.count()); // original only (empty filtered)
+}
+
+test "Rope - redo after modifying tree fails" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    try rope.store_undo("state1");
+    try rope.append(.{ .value = 2 });
+
+    _ = try rope.undo("current");
+
+    // Manually modify the rope (breaking the redo contract)
+    try rope.append(.{ .value = 3 });
+
+    // Redo should fail because tree was modified
+    const result = rope.redo();
+    try std.testing.expectError(error.Stop, result);
+}
+
+test "Rope - rebalance extremely unbalanced tree" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.init(arena.allocator());
+
+    for (0..50) |i| {
+        try rope.append(.{ .value = @intCast(i) });
+    }
+
+    const depth_before = rope.root.depth();
+
+    // Rebalance
+    try rope.rebalance(arena.allocator());
+
+    const depth_after = rope.root.depth();
+
+    // Should be more balanced now
+    try std.testing.expect(depth_after <= depth_before);
+    try std.testing.expect(depth_after < 15); // log2(50) ≈ 6
+
+    // Data should be preserved
+    try std.testing.expectEqual(@as(u32, 50), rope.count());
+    try std.testing.expectEqual(@as(u32, 0), rope.get(0).?.value); // Fixed index
+}
+
+//===== Weight-aware Tests =====
+
+// Type with custom weight for testing weight-based operations
+const WeightedItem = struct {
+    value: u32,
+    weight: u32,
+
+    pub const Metrics = struct {
+        total_weight: u32 = 0,
+
+        pub fn add(self: *Metrics, other: Metrics) void {
+            self.total_weight += other.total_weight;
+        }
+
+        pub fn weight(self: *const Metrics) u32 {
+            return self.total_weight;
+        }
+    };
+
+    pub fn measure(self: *const WeightedItem) Metrics {
+        return .{ .total_weight = self.weight };
+    }
+
+    pub fn empty() WeightedItem {
+        return .{ .value = 0, .weight = 0 };
+    }
+
+    pub fn is_empty(self: *const WeightedItem) bool {
+        return self.value == 0 and self.weight == 0;
+    }
+};
+
+// Leaf split function for testing (callback format)
+const WeightedRope = rope_mod.Rope(WeightedItem);
+
+fn splitWeightedItemCallback(
+    ctx: ?*anyopaque,
+    allocator: std.mem.Allocator,
+    leaf: *const WeightedItem,
+    weight_in_leaf: u32,
+) error{ OutOfBounds, OutOfMemory }!WeightedRope.Node.LeafSplitResult {
+    _ = ctx;
+    _ = allocator;
+    if (weight_in_leaf == 0) {
+        return .{
+            .left = WeightedItem.empty(),
+            .right = leaf.*,
+        };
+    } else if (weight_in_leaf >= leaf.weight) {
+        return .{
+            .left = leaf.*,
+            .right = WeightedItem.empty(),
+        };
+    }
+
+    // Split proportionally
+    return .{
+        .left = .{ .value = leaf.value, .weight = weight_in_leaf },
+        .right = .{ .value = leaf.value + 1000, .weight = leaf.weight - weight_in_leaf },
+    };
+}
+
+// Helper to create the callback struct
+fn makeWeightedSplitter() WeightedRope.Node.LeafSplitFn {
+    return .{
+        .ctx = null,
+        .splitFn = splitWeightedItemCallback,
+    };
+}
+
+test "Rope - totalWeight returns correct weight" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const items = [_]WeightedItem{
+        .{ .value = 1, .weight = 10 },
+        .{ .value = 2, .weight = 20 },
+        .{ .value = 3, .weight = 30 },
+    };
+
+    var rope = try WeightedRope.from_slice(arena.allocator(), &items);
+    try std.testing.expectEqual(@as(u32, 60), rope.totalWeight());
+}
+
+test "Rope - split_at_weight at boundary" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const items = [_]WeightedItem{
+        .{ .value = 1, .weight = 10 },
+        .{ .value = 2, .weight = 20 },
+        .{ .value = 3, .weight = 30 },
+    };
+
+    const rope = try WeightedRope.from_slice(arena.allocator(), &items);
+
+    // Split at weight 30 (boundary between second and third item)
+    const splitter = makeWeightedSplitter();
+    const result = try WeightedRope.Node.split_at_weight(rope.root, 30, arena.allocator(), rope.empty_leaf, &splitter);
+
+    // Left should have weight 30 (first two items)
+    try std.testing.expectEqual(@as(u32, 30), result.left.metrics().weight());
+
+    // Right should have weight 30 (third item)
+    try std.testing.expectEqual(@as(u32, 30), result.right.metrics().weight());
+}
+
+test "Rope - split_at_weight inside leaf" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const rope = try WeightedRope.from_item(arena.allocator(), .{ .value = 1, .weight = 100 });
+
+    // Split at weight 40 (inside the single leaf)
+    const splitter = makeWeightedSplitter();
+    const result = try WeightedRope.Node.split_at_weight(rope.root, 40, arena.allocator(), rope.empty_leaf, &splitter);
+
+    // Left should have weight 40
+    try std.testing.expectEqual(@as(u32, 40), result.left.metrics().weight());
+
+    // Right should have weight 60
+    try std.testing.expectEqual(@as(u32, 60), result.right.metrics().weight());
+}
+
+test "Rope - splitByWeight" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const items = [_]WeightedItem{
+        .{ .value = 1, .weight = 10 },
+        .{ .value = 2, .weight = 20 },
+        .{ .value = 3, .weight = 30 },
+    };
+
+    var rope = try WeightedRope.from_slice(arena.allocator(), &items);
+    try std.testing.expectEqual(@as(u32, 60), rope.totalWeight());
+
+    // Split at weight 30
+    const splitter = makeWeightedSplitter();
+    const right_half = try rope.splitByWeight(30, &splitter);
+
+    // Left half should have weight 30
+    try std.testing.expectEqual(@as(u32, 30), rope.totalWeight());
+
+    // Right half should have weight 30
+    try std.testing.expectEqual(@as(u32, 30), right_half.totalWeight());
+}
+
+test "Rope - deleteRangeByWeight" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const items = [_]WeightedItem{
+        .{ .value = 1, .weight = 10 },
+        .{ .value = 2, .weight = 20 },
+        .{ .value = 3, .weight = 30 },
+        .{ .value = 4, .weight = 40 },
+    };
+
+    var rope = try WeightedRope.from_slice(arena.allocator(), &items);
+    try std.testing.expectEqual(@as(u32, 100), rope.totalWeight());
+
+    // Delete weight range [10, 30) - removes the second item (weight 20)
+    const splitter = makeWeightedSplitter();
+    try rope.deleteRangeByWeight(10, 30, &splitter);
+
+    // Should have removed weight 20
+    try std.testing.expectEqual(@as(u32, 80), rope.totalWeight());
+}
+
+test "Rope - insertSliceByWeight" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const items = [_]WeightedItem{
+        .{ .value = 1, .weight = 10 },
+        .{ .value = 3, .weight = 30 },
+    };
+
+    var rope = try WeightedRope.from_slice(arena.allocator(), &items);
+    try std.testing.expectEqual(@as(u32, 40), rope.totalWeight());
+
+    // Insert at weight 10 (after first item)
+    const insert_items = [_]WeightedItem{
+        .{ .value = 2, .weight = 20 },
+    };
+    const splitter = makeWeightedSplitter();
+    try rope.insertSliceByWeight(10, &insert_items, &splitter);
+
+    // Should have added weight 20
+    try std.testing.expectEqual(@as(u32, 60), rope.totalWeight());
+}
+
+test "Rope - findByWeight" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const items = [_]WeightedItem{
+        .{ .value = 1, .weight = 10 },
+        .{ .value = 2, .weight = 20 },
+        .{ .value = 3, .weight = 30 },
+    };
+
+    var rope = try WeightedRope.from_slice(arena.allocator(), &items);
+
+    // Find leaf containing weight 0 (first item)
+    const result0 = rope.findByWeight(0);
+    try std.testing.expect(result0 != null);
+    try std.testing.expectEqual(@as(u32, 1), result0.?.leaf.value);
+    try std.testing.expectEqual(@as(u32, 0), result0.?.start_weight);
+
+    // Find leaf containing weight 15 (second item)
+    const result15 = rope.findByWeight(15);
+    try std.testing.expect(result15 != null);
+    try std.testing.expectEqual(@as(u32, 2), result15.?.leaf.value);
+    try std.testing.expectEqual(@as(u32, 10), result15.?.start_weight);
+
+    // Find leaf containing weight 35 (third item)
+    const result35 = rope.findByWeight(35);
+    try std.testing.expect(result35 != null);
+    try std.testing.expectEqual(@as(u32, 3), result35.?.leaf.value);
+    try std.testing.expectEqual(@as(u32, 30), result35.?.start_weight);
+
+    // Out of bounds
+    const result100 = rope.findByWeight(100);
+    try std.testing.expect(result100 == null);
+}
+
+//===== Integrated Marker Tracking Tests (Union Types) =====
+
+// Simple union type for testing automatic marker tracking
+const TokenType = union(enum) {
+    word: u32,
+    space: u32,
+    newline: void, // Marker type
+
+    // Define which tags are markers (only track these!)
+    pub const MarkerTypes = &[_]std.meta.Tag(TokenType){.newline};
+
+    pub const Metrics = struct {
+        width: u32 = 0,
+
+        pub fn add(self: *Metrics, other: Metrics) void {
+            self.width += other.width;
+        }
+
+        pub fn weight(self: *const Metrics) u32 {
+            return self.width;
+        }
+    };
+
+    pub fn measure(self: *const TokenType) Metrics {
+        return switch (self.*) {
+            .word => |w| .{ .width = w },
+            .space => |s| .{ .width = s },
+            .newline => .{ .width = 0 },
+        };
+    }
+
+    pub fn empty() TokenType {
+        return .{ .space = 0 };
+    }
+
+    pub fn is_empty(self: *const TokenType) bool {
+        return switch (self.*) {
+            .space => |s| s == 0,
+            else => false,
+        };
+    }
+};
+
+test "Rope - automatic marker tracking with union type" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(TokenType);
+
+    // Create rope with marker tracking enabled
+    const tokens = [_]TokenType{
+        .{ .word = 5 }, // "Hello"
+        .{ .space = 1 }, // " "
+        .{ .word = 5 }, // "World"
+        .{ .newline = {} }, // Line break marker
+        .{ .word = 6 }, // "Second"
+        .{ .space = 1 }, // " "
+        .{ .word = 4 }, // "Line"
+        .{ .newline = {} }, // Line break marker
+        .{ .word = 5 }, // "Third"
+    };
+
+    var rope = try RopeType.from_slice(arena.allocator(), &tokens);
+
+    // O(1) lookup: find newline markers (only .newline is tracked, not .word or .space)
+    try std.testing.expectEqual(@as(u32, 2), rope.markerCount(.newline));
+
+    // Get first newline (end of line 0)
+    const nl0 = rope.getMarker(.newline, 0);
+    try std.testing.expect(nl0 != null);
+    try std.testing.expectEqual(@as(u32, 3), nl0.?.leaf_index); // After word, space, word
+    try std.testing.expectEqual(@as(u32, 11), nl0.?.global_weight); // 5 + 1 + 5
+
+    // Get second newline (end of line 1)
+    const nl1 = rope.getMarker(.newline, 1);
+    try std.testing.expect(nl1 != null);
+    try std.testing.expectEqual(@as(u32, 7), nl1.?.leaf_index);
+    try std.testing.expectEqual(@as(u32, 22), nl1.?.global_weight); // 11 + 6 + 1 + 4
+
+    // Word and space are NOT markers - should return 0
+    try std.testing.expectEqual(@as(u32, 0), rope.markerCount(.word));
+    try std.testing.expectEqual(@as(u32, 0), rope.markerCount(.space));
+}
+
+test "Rope - marker tracking with empty rope" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(TokenType);
+    var rope = try RopeType.init(arena.allocator());
+
+    try std.testing.expectEqual(@as(u32, 0), rope.markerCount(.newline));
+    try std.testing.expectEqual(@as(u32, 0), rope.markerCount(.word)); // Not a marker type
+    try std.testing.expect(rope.getMarker(.newline, 0) == null);
+}
+
+test "Rope - marker tracking requires rebuild" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(TokenType);
+    const tokens = [_]TokenType{
+        .{ .word = 5 },
+        .{ .newline = {} },
+    };
+
+    var rope = try RopeType.from_slice(arena.allocator(), &tokens);
+
+    // Markers are automatically tracked in the tree
+    try std.testing.expectEqual(@as(u32, 1), rope.markerCount(.newline));
+    try std.testing.expect(rope.getMarker(.newline, 0) != null);
+}
+
+test "Rope - marker tracking with many markers" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(TokenType);
+
+    // Create 100 lines
+    var tokens_array: [199]TokenType = undefined; // 100 words + 99 newlines
+    for (0..100) |i| {
+        if (i > 0) {
+            tokens_array[i * 2 - 1] = .{ .newline = {} };
+        }
+        tokens_array[i * 2] = .{ .word = 5 };
+    }
+
+    var rope = try RopeType.from_slice(arena.allocator(), &tokens_array);
+
+    // Should have 99 newlines (only newlines are tracked as markers)
+    try std.testing.expectEqual(@as(u32, 99), rope.markerCount(.newline));
+
+    // Test O(1) random access to specific lines
+    const nl50 = rope.getMarker(.newline, 50).?;
+    try std.testing.expectEqual(@as(u32, 101), nl50.leaf_index); // word, nl, word, nl, ... (50th newline is at index 101)
+    try std.testing.expectEqual(@as(u32, 255), nl50.global_weight); // 51 words * 5 width
+
+    const nl98 = rope.getMarker(.newline, 98).?;
+    try std.testing.expectEqual(@as(u32, 197), nl98.leaf_index);
+}
+//===== Debug toText Tests =====
+
+test "Rope - toText shows basic structure" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+        .{ .value = 3 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    const debug_text = try rope.toText(arena.allocator());
+
+    try std.testing.expect(std.mem.indexOf(u8, debug_text, "[root") != null);
+    try std.testing.expect(std.mem.indexOf(u8, debug_text, "branch") != null or std.mem.indexOf(u8, debug_text, "leaf") != null);
+}
+
+test "Rope - toText shows empty rope" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.init(arena.allocator());
+
+    const debug_text = try rope.toText(arena.allocator());
+
+    try std.testing.expect(std.mem.indexOf(u8, debug_text, "[root") != null);
+    try std.testing.expect(std.mem.indexOf(u8, debug_text, "[empty]") != null);
+}
+
+test "Rope - toText with union type shows tags" {
+    const TestSegment = union(enum) {
+        text: struct { width: u32 },
+        brk: void,
+        linestart: void,
+
+        pub const MarkerTypes = &[_]std.meta.Tag(@This()){ .brk, .linestart };
+
+        pub const Metrics = struct {
+            width: u32 = 0,
+
+            pub fn add(self: *Metrics, other: Metrics) void {
+                self.width += other.width;
+            }
+
+            pub fn weight(self: *const Metrics) u32 {
+                return self.width;
+            }
+        };
+
+        pub fn measure(self: *const @This()) Metrics {
+            return switch (self.*) {
+                .text => |t| Metrics{ .width = t.width },
+                .brk => Metrics{ .width = 1 },
+                .linestart => Metrics{ .width = 0 },
+            };
+        }
+
+        pub fn empty() @This() {
+            return .{ .text = .{ .width = 0 } };
+        }
+
+        pub fn is_empty(self: *const @This()) bool {
+            return switch (self.*) {
+                .text => |t| t.width == 0,
+                else => false,
+            };
+        }
+    };
+
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const TestRope = rope_mod.Rope(TestSegment);
+    var rope = try TestRope.from_slice(arena.allocator(), &[_]TestSegment{
+        .linestart,
+        .{ .text = .{ .width = 5 } },
+        .brk,
+        .linestart,
+        .{ .text = .{ .width = 10 } },
+    });
+
+    const debug_text = try rope.toText(arena.allocator());
+
+    try std.testing.expect(std.mem.indexOf(u8, debug_text, "text") != null);
+    try std.testing.expect(std.mem.indexOf(u8, debug_text, "brk") != null);
+    try std.testing.expect(std.mem.indexOf(u8, debug_text, "linestart") != null);
+    try std.testing.expect(std.mem.indexOf(u8, debug_text, "w5") != null);
+    try std.testing.expect(std.mem.indexOf(u8, debug_text, "w10") != null);
+}
+
+test "Rope - toText with nested structure" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+
+    // Create a larger rope that will have branches
+    var items: [10]SimpleItem = undefined;
+    for (&items, 0..) |*item, i| {
+        item.* = .{ .value = @intCast(i) };
+    }
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    const debug_text = try rope.toText(arena.allocator());
+
+    try std.testing.expect(std.mem.indexOf(u8, debug_text, "[root") != null);
+    try std.testing.expect(std.mem.indexOf(u8, debug_text, "[branch") != null);
+}
+
+test "Rope - toText after insertions shows updated structure" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    const before = try rope.toText(arena.allocator());
+    try std.testing.expect(std.mem.indexOf(u8, before, "[root") != null);
+
+    try rope.append(.{ .value = 2 });
+    try rope.append(.{ .value = 3 });
+
+    const after = try rope.toText(arena.allocator());
+    try std.testing.expect(std.mem.indexOf(u8, after, "[root") != null);
+    try std.testing.expect(after.len >= before.len);
+}
+
+test "Rope - toText with custom metrics shows width info" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(ItemWithMetrics);
+    const items = [_]ItemWithMetrics{
+        .{ .value = 1, .size = 100 },
+        .{ .value = 2, .size = 200 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    const debug_text = try rope.toText(arena.allocator());
+
+    try std.testing.expect(std.mem.indexOf(u8, debug_text, "[root") != null);
+    try std.testing.expect(std.mem.indexOf(u8, debug_text, "w") != null);
+}
+
+test "Rope - toText shows single leaf" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 42 });
+
+    const debug_text = try rope.toText(arena.allocator());
+
+    try std.testing.expect(std.mem.indexOf(u8, debug_text, "[root") != null);
+    try std.testing.expect(std.mem.indexOf(u8, debug_text, "[leaf") != null);
+    try std.testing.expect(std.mem.indexOf(u8, debug_text, "]") != null);
+}
+
+test "Rope - marker cache MUST update after delete operations" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(TokenType);
+
+    // Create: word(5) newline word(5) newline word(5)
+    // 3 lines total, 2 newlines
+    const tokens = [_]TokenType{
+        .{ .word = 5 },
+        .{ .newline = {} },
+        .{ .word = 5 },
+        .{ .newline = {} },
+        .{ .word = 5 },
+    };
+
+    var rope = try RopeType.from_slice(arena.allocator(), &tokens);
+
+    try std.testing.expectEqual(@as(u32, 2), rope.markerCount(.newline));
+
+    try rope.delete(4);
+
+    try std.testing.expectEqual(@as(u32, 2), rope.markerCount(.newline));
+
+    // The critical test: marker positions MUST be correct after delete!
+    const nl1_after = rope.getMarker(.newline, 1);
+    try std.testing.expect(nl1_after != null);
+
+    // After deleting the last word at index 4, the second newline should be at index 3
+    // (was at index 3 before, stays at 3 after deleting index 4)
+    try std.testing.expectEqual(@as(u32, 3), nl1_after.?.leaf_index);
+}
+
+test "Rope - marker cache MUST update after undo" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(TokenType);
+
+    // Create: word(10) newline word(5)
+    const tokens = [_]TokenType{
+        .{ .word = 10 },
+        .{ .newline = {} },
+        .{ .word = 5 },
+    };
+
+    var rope = try RopeType.from_slice(arena.allocator(), &tokens);
+
+    // Initial state: 1 newline at weight 10
+    const nl_before = rope.getMarker(.newline, 0);
+    try std.testing.expect(nl_before != null);
+    try std.testing.expectEqual(@as(u32, 10), nl_before.?.global_weight);
+
+    // Store undo point
+    try rope.store_undo("before delete");
+
+    // Delete part of first word: delete range [0, 1) removes first word
+    try rope.delete_range(0, 1);
+
+    // After delete: newline should be at weight 0 (no word before it)
+    const nl_after_delete = rope.getMarker(.newline, 0);
+    try std.testing.expect(nl_after_delete != null);
+    try std.testing.expectEqual(@as(u32, 0), nl_after_delete.?.global_weight);
+
+    // Undo the delete
+    _ = try rope.undo("after delete");
+
+    // CRITICAL: After undo, marker cache MUST be recalculated!
+    // Newline should be back at weight 10
+    const nl_after_undo = rope.getMarker(.newline, 0);
+    try std.testing.expect(nl_after_undo != null);
+    try std.testing.expectEqual(@as(u32, 10), nl_after_undo.?.global_weight);
+}
+
+test "Rope - marker cache MUST update after redo" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(TokenType);
+
+    const tokens = [_]TokenType{
+        .{ .word = 10 },
+        .{ .newline = {} },
+        .{ .word = 5 },
+    };
+
+    var rope = try RopeType.from_slice(arena.allocator(), &tokens);
+
+    try rope.store_undo("initial");
+    try rope.delete_range(0, 1);
+
+    const nl_after_delete = rope.getMarker(.newline, 0);
+    try std.testing.expectEqual(@as(u32, 0), nl_after_delete.?.global_weight);
+
+    // Undo
+    _ = try rope.undo("after delete");
+    const nl_after_undo = rope.getMarker(.newline, 0);
+    try std.testing.expectEqual(@as(u32, 10), nl_after_undo.?.global_weight);
+
+    // Redo
+    _ = try rope.redo();
+
+    // CRITICAL: After redo, marker cache MUST be recalculated!
+    const nl_after_redo = rope.getMarker(.newline, 0);
+    try std.testing.expect(nl_after_redo != null);
+    try std.testing.expectEqual(@as(u32, 0), nl_after_redo.?.global_weight);
+}
+
+test "Rope - marker cache survives multiple undo/redo cycles" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(TokenType);
+
+    var rope = try RopeType.from_slice(arena.allocator(), &[_]TokenType{
+        .{ .word = 5 },
+        .{ .newline = {} },
+        .{ .word = 5 },
+    });
+
+    try rope.store_undo("state1");
+    try rope.append(.{ .newline = {} });
+    try rope.append(.{ .word = 5 });
+
+    // Should have 2 newlines now
+    try std.testing.expectEqual(@as(u32, 2), rope.markerCount(.newline));
+    const nl1_orig = rope.getMarker(.newline, 1);
+    try std.testing.expectEqual(@as(u32, 10), nl1_orig.?.global_weight);
+
+    try rope.store_undo("state2");
+    try rope.delete(0); // Delete first word
+
+    // Markers should update: first newline now at weight 0
+    const nl0_after_delete = rope.getMarker(.newline, 0);
+    try std.testing.expectEqual(@as(u32, 0), nl0_after_delete.?.global_weight);
+
+    // Undo twice
+    _ = try rope.undo("current");
+    _ = try rope.undo("current");
+
+    // Back to original: 1 newline at weight 5
+    try std.testing.expectEqual(@as(u32, 1), rope.markerCount(.newline));
+    const nl_final = rope.getMarker(.newline, 0);
+    try std.testing.expectEqual(@as(u32, 5), nl_final.?.global_weight);
+
+    // Redo twice
+    _ = try rope.redo();
+    _ = try rope.redo();
+
+    // Should match the post-delete state
+    const nl0_redo = rope.getMarker(.newline, 0);
+    try std.testing.expectEqual(@as(u32, 0), nl0_redo.?.global_weight);
+}
+
+//===== Configurable Undo Depth Tests =====
+
+test "Rope - weight-based balancing with custom weight function" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    // Create items with different sizes
+    const items = [_]WeightedItem{
+        .{ .value = 1, .weight = 100 }, // Large item
+        .{ .value = 2, .weight = 10 }, // Small item
+        .{ .value = 3, .weight = 200 }, // Very large item
+        .{ .value = 4, .weight = 50 }, // Medium item
+    };
+
+    var rope = try WeightedRope.from_slice(arena.allocator(), &items);
+
+    // Check that metrics are tracked
+    const metrics = rope.root.metrics();
+    try std.testing.expectEqual(@as(u32, 4), metrics.count);
+    try std.testing.expectEqual(@as(u32, 360), metrics.custom.total_weight);
+    try std.testing.expectEqual(@as(u32, 360), metrics.weight()); // Should use weight()
+}
+
+test "Rope - unlimited undo depth by default" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.init(arena.allocator());
+
+    // Store many undo states
+    for (0..100) |i| {
+        try rope.store_undo("state");
+        try rope.append(.{ .value = @intCast(i) });
+    }
+
+    // Should have all 100 states
+    try std.testing.expectEqual(@as(usize, 100), rope.undo_depth);
+    try std.testing.expect(rope.can_undo());
+}
+
+test "Rope - max_undo_depth limits history" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.initWithConfig(arena.allocator(), .{ .max_undo_depth = 10 });
+
+    // Store 20 undo states
+    for (0..20) |i| {
+        try rope.store_undo("state");
+        try rope.append(.{ .value = @intCast(i) });
+    }
+
+    // Should only keep 10 states
+    try std.testing.expectEqual(@as(usize, 10), rope.undo_depth);
+    try std.testing.expect(rope.can_undo());
+
+    // Can undo at most 10 times (may be less due to how history works)
+    var undo_count: usize = 0;
+    while (rope.can_undo()) : (undo_count += 1) {
+        _ = rope.undo("current") catch break;
+    }
+    // Should have undone at least some operations, but not more than 10
+    try std.testing.expect(undo_count > 0);
+    try std.testing.expect(undo_count <= 10);
+}
+
+test "Rope - trimUndoHistory works correctly" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.initWithConfig(arena.allocator(), .{ .max_undo_depth = 5 });
+
+    for (0..10) |i| {
+        try rope.store_undo("state");
+        try rope.append(.{ .value = @intCast(i) });
+
+        try std.testing.expect(rope.undo_depth <= 5);
+    }
+
+    try std.testing.expectEqual(@as(usize, 5), rope.undo_depth);
+}
+
+test "Rope - weight-based join_balanced respects weight ratio" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const left_items = [_]WeightedItem{
+        .{ .value = 1, .weight = 1000 },
+        .{ .value = 2, .weight = 1000 },
+        .{ .value = 3, .weight = 1000 },
+    };
+    var rope_left = try WeightedRope.from_slice(arena.allocator(), &left_items);
+
+    const right_items = [_]WeightedItem{
+        .{ .value = 4, .weight = 100 },
+    };
+    const rope_right = try WeightedRope.from_slice(arena.allocator(), &right_items);
+
+    try rope_left.concat(&rope_right);
+
+    try std.testing.expectEqual(@as(u32, 4), rope_left.count());
+
+    try std.testing.expect(rope_left.root.is_balanced());
+}
+
+test "Rope - integration weight-based balancing with history limits" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    var rope = try WeightedRope.initWithConfig(arena.allocator(), .{ .max_undo_depth = 5 });
+
+    var expected_count: u32 = 0;
+    for (0..10) |i| {
+        try rope.store_undo("insert");
+        try rope.append(.{
+            .value = @intCast(i),
+            .weight = @intCast((i + 1) * 10),
+        });
+        expected_count += 1;
+    }
+
+    try std.testing.expectEqual(expected_count, rope.count());
+
+    try rope.insert(5, .{ .value = 999, .weight = 50 });
+    expected_count += 1;
+
+    try std.testing.expectEqual(expected_count, rope.count());
+
+    try std.testing.expect(rope.undo_depth <= 5);
+
+    try std.testing.expect(rope.root.is_balanced());
+}
+
+test "Rope - clear removes all items" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    const items = [_]SimpleItem{
+        .{ .value = 1 },
+        .{ .value = 2 },
+        .{ .value = 3 },
+    };
+    var rope = try RopeType.from_slice(arena.allocator(), &items);
+
+    try std.testing.expectEqual(@as(u32, 3), rope.count());
+
+    rope.clear();
+
+    try std.testing.expectEqual(@as(u32, 0), rope.count());
+}
+
+test "Rope - clear on empty rope" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.init(arena.allocator());
+
+    try std.testing.expectEqual(@as(u32, 0), rope.count());
+
+    rope.clear();
+
+    try std.testing.expectEqual(@as(u32, 0), rope.count());
+}
+
+test "Rope - clear then insert works" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.from_item(arena.allocator(), .{ .value = 1 });
+
+    rope.clear();
+    try std.testing.expectEqual(@as(u32, 0), rope.count());
+
+    try rope.append(.{ .value = 42 });
+    try std.testing.expectEqual(@as(u32, 1), rope.count());
+    try std.testing.expectEqual(@as(u32, 42), rope.get(0).?.value);
+}
+
+test "Rope - clear with markers resets marker cache" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(TokenType);
+    const tokens = [_]TokenType{
+        .{ .word = 5 },
+        .{ .newline = {} },
+        .{ .word = 5 },
+        .{ .newline = {} },
+    };
+
+    var rope = try RopeType.from_slice(arena.allocator(), &tokens);
+    try std.testing.expectEqual(@as(u32, 2), rope.markerCount(.newline));
+
+    rope.clear();
+
+    try std.testing.expectEqual(@as(u32, 0), rope.count());
+    try std.testing.expectEqual(@as(u32, 0), rope.markerCount(.newline));
+}
+
+test "Rope - integration all features working together" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const RopeType = rope_mod.Rope(SimpleItem);
+    var rope = try RopeType.initWithConfig(arena.allocator(), .{ .max_undo_depth = 3 });
+
+    try std.testing.expectEqual(@as(u32, 0), rope.count());
+
+    try rope.store_undo("empty");
+    try rope.append(.{ .value = 1 });
+
+    try rope.store_undo("one");
+    try rope.append(.{ .value = 2 });
+
+    try rope.store_undo("two");
+    try rope.append(.{ .value = 3 });
+
+    try rope.store_undo("three");
+    try rope.append(.{ .value = 4 });
+
+    try std.testing.expectEqual(@as(u32, 4), rope.count());
+
+    try std.testing.expectEqual(@as(usize, 3), rope.undo_depth);
+
+    const val = rope.get(2);
+    try std.testing.expectEqual(@as(u32, 3), val.?.value);
+
+    _ = try rope.undo("current");
+    try std.testing.expectEqual(@as(u32, 3), rope.count());
+
+    const Context = struct {
+        count: u32 = 0,
+        fn walker(ctx: *anyopaque, data: *const SimpleItem, index: u32) RopeType.Node.WalkerResult {
+            _ = data;
+            _ = index;
+            const self = @as(*@This(), @ptrCast(@alignCast(ctx)));
+            self.count += 1;
+            return .{};
+        }
+    };
+    var ctx = Context{};
+    try rope.walk(&ctx, Context.walker);
+    try std.testing.expectEqual(@as(u32, 3), ctx.count);
+}