refactor(ssz): drop BaseTreeView, use tuple for ContainerTreeView (#139)

## Motivation

The previous `BaseTreeView` design had several structural problems:
- Child TreeViews were returned as shallow copies (`{.base_view=...}`),
risking double-free or dangling pointers
- Extra per-type fields (e.g. `length`, cached child arrays) could not
be stored in child views without hacks
- All TreeView types were tightly coupled, making `ContainerNodeStruct`
(and similar) hard to implement
- Parent `commit()` could not propagate through modified child TreeViews
because children were copies, not references

Part of #78.

## Changes

**Drop `BaseTreeView`** — each TreeView is now a self-contained struct.
Reusable logic (e.g. `getChildNode`, `setChildNode`, `getLength`,
`setLength`) is shared via standalone utilities, not inheritance.

**`ContainerTreeView` now uses a comptime tuple** instead of a runtime
Map. Each field slot holds either a reference to a child TreeView or a
native basic-type value. This gives type-level access to the child type
at a given index, enabling future `ContainerNodeStructTreeView`.

**`ArrayBasicTreeView` / `ArrayCompositeTreeView`** now track:
- A `Map` of dirty nodes (committed to cache only on `commit()`)
- A `length` field updated lazily
- For composite: a `Map` of child TreeView references (so parent
`commit()` propagates correctly)

---------

Co-authored-by: Tuyen Nguyen <twoeths@users.noreply.github.com>
Co-authored-by: Cayman <caymannava@gmail.com>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: 3 people

bindings/napi/BeaconStateView.zig

@@ -778,7 +778,7 @@ pub fn BeaconStateView_createMultiProof(env: napi.Env, cb: napi.CallbackInfo(1))
     // Get the root node from the state
     try cached_state.state.commit();
     const root_node = switch (cached_state.state.*) {
-        inline else => |*state| state.base_view.data.root,
+        inline else => |state| state.root,
     };
 
     // Create proof input for compact multi-proof
@@ -880,7 +880,7 @@ pub fn BeaconStateView_serialize(env: napi.Env, cb: napi.CallbackInfo(0)) !napi.
 pub fn BeaconStateView_serializedSize(env: napi.Env, cb: napi.CallbackInfo(0)) !napi.Value {
     const cached_state = try env.unwrap(CachedBeaconState, cb.this());
     const size = switch (cached_state.state.*) {
-        inline else => |*state| try state.serializedSize(),
+        inline else => |state| try state.serializedSize(),
     };
     return try env.createInt64(@intCast(size));
 }
@@ -902,7 +902,7 @@ pub fn BeaconStateView_serializeToBytes(env: napi.Env, cb: napi.CallbackInfo(2))
 
     const output_slice = output_info.data[offset..];
     const bytes_written = switch (cached_state.state.*) {
-        inline else => |*state| try state.serializeIntoBytes(output_slice),
+        inline else => |state| try state.serializeIntoBytes(output_slice),
     };
 
     return try env.createInt64(@intCast(bytes_written));

src/fork_types/any_beacon_state.zig

@@ -41,13 +41,12 @@ pub const Hasher = hasher.Hasher;
 pub const HasherData = hasher.HasherData;
 
 const tree_view = @import("tree_view/root.zig");
-pub const TreeViewData = tree_view.TreeViewData;
-pub const BaseTreeView = tree_view.BaseTreeView;
 pub const ContainerTreeView = tree_view.ContainerTreeView;
 pub const ArrayBasicTreeView = tree_view.ArrayBasicTreeView;
 pub const ArrayCompositeTreeView = tree_view.ArrayCompositeTreeView;
 pub const ListBasicTreeView = tree_view.ListBasicTreeView;
 pub const ListCompositeTreeView = tree_view.ListCompositeTreeView;
+pub const CloneOpts = @import("tree_view/utils/clone_opts.zig").CloneOpts;
 
 test {
     testing.refAllDecls(@This());

src/fork_types/beacon_state.zig

@@ -9,8 +9,9 @@ const type_root = @import("../type/root.zig");
 const itemsPerChunk = type_root.itemsPerChunk;
 const chunkDepth = type_root.chunkDepth;
 
-const BaseTreeView = @import("root.zig").BaseTreeView;
 const BasicPackedChunks = @import("chunks.zig").BasicPackedChunks;
+const assertTreeViewType = @import("utils/assert.zig").assertTreeViewType;
+const CloneOpts = @import("utils/clone_opts.zig").CloneOpts;
 
 /// A specialized tree view for SSZ vector types with basic element types.
 /// Elements are packed into chunks (multiple elements per leaf node).
@@ -24,8 +25,9 @@ pub fn ArrayBasicTreeView(comptime ST: type) type {
         }
     }
 
-    return struct {
-        base_view: BaseTreeView,
+    const TreeView = struct {
+        allocator: Allocator,
+        chunks: Chunks,
 
         pub const SszType = ST;
         pub const Element = ST.Element.Type;
@@ -38,69 +40,96 @@ pub fn ArrayBasicTreeView(comptime ST: type) type {
         const items_per_chunk: usize = itemsPerChunk(ST.Element);
         const Chunks = BasicPackedChunks(ST, chunk_depth, items_per_chunk);
 
-        pub fn init(allocator: Allocator, pool: *Node.Pool, root: Node.Id) !Self {
-            return Self{
-                .base_view = try BaseTreeView.init(allocator, pool, root),
-            };
+        pub fn init(allocator: Allocator, pool: *Node.Pool, root: Node.Id) !*Self {
+            const ptr = try allocator.create(Self);
+            errdefer allocator.destroy(ptr);
+
+            try Chunks.init(&ptr.chunks, allocator, pool, root);
+            ptr.allocator = allocator;
+            return ptr;
         }
 
-        pub fn clone(self: *Self, opts: BaseTreeView.CloneOpts) !Self {
-            return Self{ .base_view = try self.base_view.clone(opts) };
+        pub fn clone(self: *Self, opts: CloneOpts) !*Self {
+            const ptr = try self.allocator.create(Self);
+            errdefer self.allocator.destroy(ptr);
+
+            try Chunks.clone(&self.chunks, opts, &ptr.chunks);
+            ptr.allocator = self.allocator;
+            return ptr;
         }
 
         pub fn deinit(self: *Self) void {
-            self.base_view.deinit();
+            self.chunks.deinit();
+            self.allocator.destroy(self);
         }
 
         pub fn commit(self: *Self) !void {
-            try self.base_view.commit();
+            try self.chunks.commit();
         }
 
         pub fn clearCache(self: *Self) void {
-            self.base_view.clearCache();
+            self.chunks.clearCache();
+        }
+
+        pub fn hashTreeRootInto(self: *Self, out: *[32]u8) !void {
+            try self.commit();
+            out.* = self.chunks.state.root.getRoot(self.chunks.state.pool).*;
         }
 
-        /// Return the root hash of the tree.
-        /// The returned array is owned by the internal pool and must not be modified.
         pub fn hashTreeRoot(self: *Self) !*const [32]u8 {
-            return try self.base_view.hashTreeRoot();
+            try self.commit();
+            return self.chunks.state.root.getRoot(self.chunks.state.pool);
+        }
+
+        pub fn fromValue(allocator: Allocator, pool: *Node.Pool, value: *const ST.Type) !*Self {
+            const root = try ST.tree.fromValue(pool, value);
+            errdefer pool.unref(root);
+            return try Self.init(allocator, pool, root);
+        }
+
+        pub fn toValue(self: *Self, _: Allocator, out: *ST.Type) !void {
+            try self.commit();
+            try ST.tree.toValue(self.chunks.state.root, self.chunks.state.pool, out);
+        }
+
+        pub fn getRoot(self: *const Self) Node.Id {
+            return self.chunks.state.root;
         }
 
         pub fn get(self: *Self, index: usize) !Element {
             if (index >= length) return error.IndexOutOfBounds;
-            return try Chunks.get(&self.base_view, index);
+            return self.chunks.get(index);
         }
 
         pub fn set(self: *Self, index: usize, value: Element) !void {
             if (index >= length) return error.IndexOutOfBounds;
-            try Chunks.set(&self.base_view, index, value);
+            try self.chunks.set(index, value);
         }
 
+        /// Caller is responsible for freeing the returned slice using the same allocator.
         pub fn getAll(self: *Self, allocator: Allocator) ![]Element {
-            return try Chunks.getAll(&self.base_view, allocator, length);
+            return try self.chunks.getAll(allocator, length);
         }
 
         pub fn getAllInto(self: *Self, values: []Element) ![]Element {
-            return try Chunks.getAllInto(&self.base_view, length, values);
+            return try self.chunks.getAllInto(length, values);
         }
 
         /// Serialize the tree view into a provided buffer.
         /// Returns the number of bytes written.
         pub fn serializeIntoBytes(self: *Self, out: []u8) !usize {
             try self.commit();
-            return try ST.tree.serializeIntoBytes(self.base_view.data.root, self.base_view.pool, out);
+            return try ST.tree.serializeIntoBytes(self.chunks.state.root, self.chunks.state.pool, out);
         }
 
         /// Get the serialized size of this tree view.
         pub fn serializedSize(_: *Self) usize {
             return ST.fixed_size;
         }
-
-        pub fn toValue(self: *Self, _: Allocator, out: *ST.Type) !void {
-            try self.commit();
-            try ST.tree.toValue(self.base_view.data.root, self.base_view.pool, out);
-        }
     };
+
+    assertTreeViewType(TreeView);
+    return TreeView;
 }
 
 const UintType = @import("../type/uint.zig").UintType;
@@ -135,12 +164,13 @@ test "TreeView vector element roundtrip" {
     var expected_root: [32]u8 = undefined;
     try VectorType.hashTreeRoot(&expected, &expected_root);
 
-    const actual_root = try view.hashTreeRoot();
+    var actual_root: [32]u8 = undefined;
+    try view.hashTreeRootInto(&actual_root);
 
-    try std.testing.expectEqualSlices(u8, &expected_root, actual_root);
+    try std.testing.expectEqualSlices(u8, &expected_root, &actual_root);
 
     var roundtrip: VectorType.Type = undefined;
-    try VectorType.tree.toValue(view.base_view.data.root, &pool, &roundtrip);
+    try VectorType.tree.toValue(view.getRoot(), &pool, &roundtrip);
     try std.testing.expectEqualSlices(u64, &expected, &roundtrip);
 }
 
@@ -208,7 +238,6 @@ test "TreeView vector getAllAlloc repeat reflects updates" {
 
     try view.set(3, 99);
 
-    try view.commit();
     const second = try view.getAll(allocator);
     defer allocator.free(second);
     values[3] = 99;
@@ -301,13 +330,13 @@ test "TreeView vector clone(true) does not transfer cache" {
     defer v.deinit();
 
     _ = try v.get(0);
-    try std.testing.expect(v.base_view.data.children_nodes.count() > 0);
+    try std.testing.expect(v.chunks.state.children_nodes.count() > 0);
 
     var cloned_no_cache = try v.clone(.{ .transfer_cache = false });
     defer cloned_no_cache.deinit();
 
-    try std.testing.expect(v.base_view.data.children_nodes.count() > 0);
-    try std.testing.expectEqual(@as(usize, 0), cloned_no_cache.base_view.data.children_nodes.count());
+    try std.testing.expect(v.chunks.state.children_nodes.count() > 0);
+    try std.testing.expectEqual(@as(usize, 0), cloned_no_cache.chunks.state.children_nodes.count());
 }
 
 test "TreeView vector clone(false) transfers cache and clears source" {
@@ -325,13 +354,13 @@ test "TreeView vector clone(false) transfers cache and clears source" {
     defer v.deinit();
 
     _ = try v.get(0);
-    try std.testing.expect(v.base_view.data.children_nodes.count() > 0);
+    try std.testing.expect(v.chunks.state.children_nodes.count() > 0);
 
     var cloned = try v.clone(.{});
     defer cloned.deinit();
 
-    try std.testing.expectEqual(@as(usize, 0), v.base_view.data.children_nodes.count());
-    try std.testing.expect(cloned.base_view.data.children_nodes.count() > 0);
+    try std.testing.expectEqual(@as(usize, 0), v.chunks.state.children_nodes.count());
+    try std.testing.expect(cloned.chunks.state.children_nodes.count() > 0);
 }
 
 // Tests ported from TypeScript ssz packages/ssz/test/unit/byType/vector/tree.test.ts
@@ -382,8 +411,9 @@ test "ArrayBasicTreeView - serialize (uint64 vector)" {
         const view_size = view.serializedSize();
         try std.testing.expectEqual(tc.expected_serialized.len, view_size);
 
-        const hash_root = try view.hashTreeRoot();
-        try std.testing.expectEqualSlices(u8, &tc.expected_root, hash_root);
+        var hash_root: [32]u8 = undefined;
+        try view.hashTreeRootInto(&hash_root);
+        try std.testing.expectEqualSlices(u8, &tc.expected_root, &hash_root);
     }
 }