tigerbeetle-node 0.11.8 → 0.11.10

package/src/tigerbeetle/src/vsr/superblock_client_table.zig

@@ -4,7 +4,7 @@ const mem = std.mem;
 
 const constants = @import("../constants.zig");
 const vsr = @import("../vsr.zig");
-const util = @import("../util.zig");
+const stdx = @import("../stdx.zig");
 
 const MessagePool = @import("../message_pool.zig").MessagePool;
 
@@ -128,7 +128,7 @@ pub const ClientTable = struct {
         size = new_size;
 
         for (entries) |entry| {
-            util.copy_disjoint(.inexact, u8, target[size..], mem.asBytes(entry.reply.header));
+            stdx.copy_disjoint(.inexact, u8, target[size..], mem.asBytes(entry.reply.header));
             size += @sizeOf(vsr.Header);
         }
 
@@ -138,7 +138,7 @@ pub const ClientTable = struct {
         size = new_size;
 
         for (entries) |entry| {
-            util.copy_disjoint(.inexact, u8, target[size..], mem.asBytes(&entry.session));
+            stdx.copy_disjoint(.inexact, u8, target[size..], mem.asBytes(&entry.session));
             size += @sizeOf(u64);
         }
 
@@ -150,7 +150,7 @@ pub const ClientTable = struct {
         for (entries) |entry| {
             const body = entry.reply.body();
             assert(body.len == (entry.reply.header.size - @sizeOf(vsr.Header)));
-            util.copy_disjoint(.inexact, u8, target[size..], body);
+            stdx.copy_disjoint(.inexact, u8, target[size..], body);
             size += body.len;
         }
 
@@ -159,7 +159,7 @@ pub const ClientTable = struct {
         std.mem.set(u8, target[size..new_size], 0);
         size = new_size;
 
-        util.copy_disjoint(.inexact, u8, target[size..], mem.asBytes(&entries_count));
+        stdx.copy_disjoint(.inexact, u8, target[size..], mem.asBytes(&entries_count));
         size += @sizeOf(u32);
 
         assert(size <= encode_size_max);
@@ -169,7 +169,7 @@ pub const ClientTable = struct {
     pub fn decode(client_table: *ClientTable, source: []align(@alignOf(vsr.Header)) const u8) void {
         // Read the entry count at the end of the buffer to determine how many there are.
         var entries_count: u32 = undefined;
-        util.copy_disjoint(.exact, u8, mem.asBytes(&entries_count), source[source.len - @sizeOf(u32) ..]);
+        stdx.copy_disjoint(.exact, u8, mem.asBytes(&entries_count), source[source.len - @sizeOf(u32) ..]);
         assert(entries_count <= client_table.sorted.len);
 
         assert(client_table.count() == 0);
@@ -214,7 +214,7 @@ pub const ClientTable = struct {
 
             // Read the message body for the entry.
             assert(bodies.len >= body_size);
-            util.copy_disjoint(.exact, u8, body, bodies[0..body_size]);
+            stdx.copy_disjoint(.exact, u8, body, bodies[0..body_size]);
             bodies = bodies[body_size..];
             assert(entry.reply.header.valid_checksum_body(body));
 

package/src/tigerbeetle/src/vsr/superblock_free_set.zig

@@ -8,7 +8,7 @@ const MaskInt = DynamicBitSetUnmanaged.MaskInt;
 const constants = @import("../constants.zig");
 
 const ewah = @import("../ewah.zig").ewah(usize);
-const div_ceil = @import("../util.zig").div_ceil;
+const div_ceil = @import("../stdx.zig").div_ceil;
 
 /// This is logically a range of addresses within the FreeSet, but its actual fields are block
 /// indexes for ease of calculation.

package/src/tigerbeetle/src/vsr/superblock_free_set_fuzz.zig

@@ -7,7 +7,7 @@ const log = std.log.scoped(.fuzz_vsr_superblock_free_set);
 
 const FreeSet = @import("./superblock_free_set.zig").FreeSet;
 const Reservation = @import("./superblock_free_set.zig").Reservation;
-const fuzz = @import("../test/fuzz.zig");
+const fuzz = @import("../testing/fuzz.zig");
 
 pub const tigerbeetle_config = @import("../config.zig").configs.test_min;
 

package/src/tigerbeetle/src/vsr/superblock_fuzz.zig

@@ -15,16 +15,17 @@ const assert = std.debug.assert;
 const log = std.log.scoped(.fuzz_vsr_superblock);
 
 const constants = @import("../constants.zig");
-const util = @import("../util.zig");
+const stdx = @import("../stdx.zig");
 const vsr = @import("../vsr.zig");
-const Storage = @import("../test/storage.zig").Storage;
+const Storage = @import("../testing/storage.zig").Storage;
+const StorageFaultAtlas = @import("../testing/storage.zig").ClusterFaultAtlas;
 const MessagePool = @import("../message_pool.zig").MessagePool;
 const superblock_zone_size = @import("superblock.zig").superblock_zone_size;
 const data_file_size_min = @import("superblock.zig").data_file_size_min;
-const VSRState = @import("superblock.zig").SuperBlockSector.VSRState;
+const VSRState = @import("superblock.zig").SuperBlockHeader.VSRState;
 const SuperBlockType = @import("superblock.zig").SuperBlockType;
 const SuperBlock = SuperBlockType(Storage);
-const fuzz = @import("../test/fuzz.zig");
+const fuzz = @import("../testing/fuzz.zig");
 
 pub const tigerbeetle_config = @import("../config.zig").configs.test_min;
 
@@ -44,7 +45,14 @@ fn run_fuzz(allocator: std.mem.Allocator, seed: u64, transitions_count_total: us
     var prng = std.rand.DefaultPrng.init(seed);
     const random = prng.random();
 
+    const storage_fault_atlas = StorageFaultAtlas.init(1, random, .{
+        .faulty_superblock = true,
+        .faulty_wal_headers = false,
+        .faulty_wal_prepares = false,
+    });
+
     const storage_options = .{
+        .replica_index = 0,
         .seed = random.int(u64),
         // SuperBlock's IO is all serial, so latencies never reorder reads/writes.
         .read_latency_min = 1,
@@ -56,7 +64,7 @@ fn run_fuzz(allocator: std.mem.Allocator, seed: u64, transitions_count_total: us
         .read_fault_probability = 25 + random.uintLessThan(u8, 76),
         .write_fault_probability = 25 + random.uintLessThan(u8, 76),
         .crash_fault_probability = 50 + random.uintLessThan(u8, 51),
-        .faulty_superblock = true,
+        .fault_atlas = &storage_fault_atlas,
     };
 
     var storage = try Storage.init(allocator, superblock_zone_size, storage_options);
@@ -143,9 +151,10 @@ const Environment = struct {
     /// Indexed by sequence.
     const SequenceStates = std.ArrayList(struct {
         vsr_state: VSRState,
+        vsr_headers: vsr.ViewChangeHeaders.BoundedArray,
         /// Track the expected `checksum(free_set)`.
         /// Note that this is a checksum of the decoded free set; it is not the same as
-        /// `SuperBlockSector.free_set_checksum`.
+        /// `SuperBlockHeader.free_set_checksum`.
         free_set: u128,
     });
 
@@ -158,7 +167,7 @@ const Environment = struct {
     latest_sequence: u64 = 0,
     latest_checksum: u128 = 0,
     latest_parent: u128 = 0,
-    latest_vsr_state: VSRState = std.mem.zeroInit(VSRState, .{}),
+    latest_vsr_state: VSRState = std.mem.zeroes(VSRState),
 
     context_format: SuperBlock.Context = undefined,
     context_open: SuperBlock.Context = undefined,
@@ -224,7 +233,7 @@ const Environment = struct {
             if (env.latest_checksum != 0) {
                 if (env.latest_sequence + 1 == env.superblock_verify.working.sequence) {
                     // After a checkpoint() or view_change(), the parent points to the previous
-                    // working sector.
+                    // working header.
                     assert(env.superblock_verify.working.parent == env.latest_checksum);
                 }
             }
@@ -260,10 +269,14 @@ const Environment = struct {
             .replica = 0,
         });
 
+        var vsr_headers = vsr.ViewChangeHeaders.BoundedArray{ .buffer = undefined };
+        vsr_headers.appendAssumeCapacity(vsr.Header.root_prepare(cluster));
+
         assert(env.sequence_states.items.len == 0);
         try env.sequence_states.append(undefined); // skip sequence=0
         try env.sequence_states.append(.{
             .vsr_state = VSRState.root(cluster),
+            .vsr_headers = vsr_headers,
             .free_set = checksum_free_set(env.superblock),
         });
     }
@@ -298,18 +311,33 @@ const Environment = struct {
             .commit_min_checksum = env.superblock.staging.vsr_state.commit_min_checksum,
             .commit_min = env.superblock.staging.vsr_state.commit_min,
             .commit_max = env.superblock.staging.vsr_state.commit_max + 3,
-            .view_normal = env.superblock.staging.vsr_state.view_normal + 4,
+            .log_view = env.superblock.staging.vsr_state.log_view + 4,
             .view = env.superblock.staging.vsr_state.view + 5,
         };
 
+        var vsr_headers = vsr.ViewChangeHeaders.BoundedArray{ .buffer = undefined };
+        var vsr_head = std.mem.zeroInit(vsr.Header, .{
+            .command = .prepare,
+            .op = env.superblock.staging.vsr_state.commit_min,
+        });
+        vsr_head.set_checksum_body(&.{});
+        vsr_head.set_checksum();
+        vsr_headers.appendAssumeCapacity(vsr_head);
+
         assert(env.sequence_states.items.len == env.superblock.staging.sequence + 1);
         try env.sequence_states.append(.{
             .vsr_state = vsr_state,
+            .vsr_headers = vsr_headers,
             .free_set = env.sequence_states.items[env.sequence_states.items.len - 1].free_set,
         });
 
         env.pending.insert(.view_change);
-        env.superblock.view_change(view_change_callback, &env.context_view_change, vsr_state);
+        env.superblock.view_change(view_change_callback, &env.context_view_change, .{
+            .commit_max = vsr_state.commit_max,
+            .log_view = vsr_state.log_view,
+            .view = vsr_state.view,
+            .headers = vsr_headers,
+        });
     }
 
     fn view_change_callback(context: *SuperBlock.Context) void {
@@ -326,18 +354,25 @@ const Environment = struct {
             .commit_min_checksum = env.superblock.staging.vsr_state.commit_min_checksum + 1,
             .commit_min = env.superblock.staging.vsr_state.commit_min + 1,
             .commit_max = env.superblock.staging.vsr_state.commit_max + 1,
-            .view_normal = env.superblock.staging.vsr_state.view_normal + 1,
-            .view = env.superblock.staging.vsr_state.view + 1,
+            .log_view = env.superblock.staging.vsr_state.log_view,
+            .view = env.superblock.staging.vsr_state.view,
         };
 
         assert(env.sequence_states.items.len == env.superblock.staging.sequence + 1);
         try env.sequence_states.append(.{
             .vsr_state = vsr_state,
+            .vsr_headers = vsr.ViewChangeHeaders.BoundedArray.fromSlice(
+                env.superblock.staging.vsr_headers().slice,
+            ) catch unreachable,
             .free_set = checksum_free_set(env.superblock),
         });
 
         env.pending.insert(.checkpoint);
-        env.superblock.checkpoint(checkpoint_callback, &env.context_checkpoint, vsr_state);
+        env.superblock.checkpoint(checkpoint_callback, &env.context_checkpoint, .{
+            .commit_min_checksum = vsr_state.commit_min_checksum,
+            .commit_min = vsr_state.commit_min,
+            .commit_max = vsr_state.commit_max,
+        });
     }
 
     fn checkpoint_callback(context: *SuperBlock.Context) void {
@@ -350,6 +385,6 @@ const Environment = struct {
 fn checksum_free_set(superblock: *const SuperBlock) u128 {
     const mask_bits = @bitSizeOf(std.DynamicBitSetUnmanaged.MaskInt);
     const count_bits = superblock.free_set.blocks.bit_length;
-    const count_words = util.div_ceil(count_bits, mask_bits);
+    const count_words = stdx.div_ceil(count_bits, mask_bits);
     return vsr.checksum(std.mem.sliceAsBytes(superblock.free_set.blocks.masks[0..count_words]));
 }

package/src/tigerbeetle/src/vsr/superblock_manifest.zig

@@ -6,7 +6,7 @@ const log = std.log.scoped(.superblock_manifest);
 const mem = std.mem;
 
 const constants = @import("../constants.zig");
-const util = @import("../util.zig");
+const stdx = @import("../stdx.zig");
 
 // TODO Compute & use the upper bound of manifest blocks (per tree) to size the trailer zone.
 
@@ -29,7 +29,7 @@ pub const Manifest = struct {
     /// A map from table address to the manifest block and entry that is the latest extent version.
     /// Used to determine whether a table should be dropped in a compaction.
     /// Shared by all trees and sized to accommodate all possible tables.
-    tables: std.AutoHashMapUnmanaged(u64, TableExtent),
+    tables: Tables,
 
     /// A set of block addresses that have free entries.
     /// Used to determine whether a block should be compacted.
@@ -37,6 +37,13 @@ pub const Manifest = struct {
     /// This enables us to track fragmentation even in unflushed blocks.
     compaction_set: std.AutoHashMapUnmanaged(u64, void),
 
+    pub const Tables = std.AutoHashMapUnmanaged(TableExtentKey, TableExtent);
+
+    pub const TableExtentKey = struct {
+        tree_hash: u128,
+        table: u64,
+    };
+
     pub const TableExtent = struct {
         block: u64, // ManifestLog block address.
         entry: u32, // Index within the ManifestLog Label/TableInfo arrays.
@@ -60,7 +67,7 @@ pub const Manifest = struct {
         const addresses = try allocator.alloc(u64, manifest_block_count_max);
         errdefer allocator.free(addresses);
 
-        var tables = std.AutoHashMapUnmanaged(u64, TableExtent){};
+        var tables = Tables{};
         try tables.ensureTotalCapacity(allocator, forest_table_count_max);
         errdefer tables.deinit(allocator);
 
@@ -100,7 +107,7 @@ pub const Manifest = struct {
         var size: u64 = 0;
 
         const trees = target[size..][0 .. manifest.count * @sizeOf(u128)];
-        util.copy_disjoint(
+        stdx.copy_disjoint(
             .exact,
             u128,
             mem.bytesAsSlice(u128, trees),
@@ -109,7 +116,7 @@ pub const Manifest = struct {
         size += trees.len;
 
         const checksums = target[size..][0 .. manifest.count * @sizeOf(u128)];
-        util.copy_disjoint(
+        stdx.copy_disjoint(
             .exact,
             u128,
             mem.bytesAsSlice(u128, checksums),
@@ -118,7 +125,7 @@ pub const Manifest = struct {
         size += checksums.len;
 
         const addresses = target[size..][0 .. manifest.count * @sizeOf(u64)];
-        util.copy_disjoint(
+        stdx.copy_disjoint(
             .exact,
             u64,
             mem.bytesAsSlice(u64, addresses),
@@ -144,7 +151,7 @@ pub const Manifest = struct {
         var size: u64 = 0;
 
         const trees = source[size..][0 .. manifest.count * @sizeOf(u128)];
-        util.copy_disjoint(
+        stdx.copy_disjoint(
             .exact,
             u128,
             manifest.trees[0..manifest.count],
@@ -153,7 +160,7 @@ pub const Manifest = struct {
         size += trees.len;
 
         const checksums = source[size..][0 .. manifest.count * @sizeOf(u128)];
-        util.copy_disjoint(
+        stdx.copy_disjoint(
             .exact,
             u128,
             manifest.checksums[0..manifest.count],
@@ -162,7 +169,7 @@ pub const Manifest = struct {
         size += checksums.len;
 
         const addresses = source[size..][0 .. manifest.count * @sizeOf(u64)];
-        util.copy_disjoint(
+        stdx.copy_disjoint(
             .exact,
             u64,
             manifest.addresses[0..manifest.count],
@@ -224,9 +231,9 @@ pub const Manifest = struct {
         manifest.verify_index_tree_checksum_address(index, tree, checksum, address);
 
         const tail = manifest.count - (index + 1);
-        util.copy_left(.inexact, u128, manifest.trees[index..], manifest.trees[index + 1 ..][0..tail]);
-        util.copy_left(.inexact, u128, manifest.checksums[index..], manifest.checksums[index + 1 ..][0..tail]);
-        util.copy_left(.inexact, u64, manifest.addresses[index..], manifest.addresses[index + 1 ..][0..tail]);
+        stdx.copy_left(.inexact, u128, manifest.trees[index..], manifest.trees[index + 1 ..][0..tail]);
+        stdx.copy_left(.inexact, u128, manifest.checksums[index..], manifest.checksums[index + 1 ..][0..tail]);
+        stdx.copy_left(.inexact, u64, manifest.addresses[index..], manifest.addresses[index + 1 ..][0..tail]);
         manifest.count -= 1;
 
         manifest.trees[manifest.count] = 0;
@@ -293,11 +300,14 @@ pub const Manifest = struct {
 
     /// Inserts the table extent if it does not yet exist, and returns true.
     /// Otherwise, returns false.
-    pub fn insert_table_extent(manifest: *Manifest, table: u64, block: u64, entry: u32) bool {
+    pub fn insert_table_extent(manifest: *Manifest, tree_hash: u128, table: u64, block: u64, entry: u32) bool {
         assert(table > 0);
         assert(block > 0);
 
-        var extent = manifest.tables.getOrPutAssumeCapacity(table);
+        var extent = manifest.tables.getOrPutAssumeCapacity(.{
+            .tree_hash = tree_hash,
+            .table = table,
+        });
         if (extent.found_existing) return false;
 
         extent.value_ptr.* = .{
@@ -311,11 +321,14 @@ pub const Manifest = struct {
     /// Inserts or updates the table extent, and returns the previous block address if any.
     /// The table extent must be updated immediately when appending, without delay.
     /// Otherwise, ManifestLog.compact() may append a stale version over the latest.
-    pub fn update_table_extent(manifest: *Manifest, table: u64, block: u64, entry: u32) ?u64 {
+    pub fn update_table_extent(manifest: *Manifest, tree_hash: u128, table: u64, block: u64, entry: u32) ?u64 {
         assert(table > 0);
         assert(block > 0);
 
-        var extent = manifest.tables.getOrPutAssumeCapacity(table);
+        var extent = manifest.tables.getOrPutAssumeCapacity(.{
+            .tree_hash = tree_hash,
+            .table = table,
+        });
         const previous_block = if (extent.found_existing) extent.value_ptr.block else null;
 
         extent.value_ptr.* = .{
@@ -328,13 +341,19 @@ pub const Manifest = struct {
 
     /// Removes the table extent if { block, entry } is the latest version, and returns true.
     /// Otherwise, returns false.
-    pub fn remove_table_extent(manifest: *Manifest, table: u64, block: u64, entry: u32) bool {
+    pub fn remove_table_extent(manifest: *Manifest, tree_hash: u128, table: u64, block: u64, entry: u32) bool {
         assert(table > 0);
         assert(block > 0);
 
-        const extent = manifest.tables.getPtr(table).?;
+        const extent = manifest.tables.getPtr(.{
+            .tree_hash = tree_hash,
+            .table = table,
+        }).?;
         if (extent.block == block and extent.entry == entry) {
-            assert(manifest.tables.remove(table));
+            assert(manifest.tables.remove(.{
+                .tree_hash = tree_hash,
+                .table = table,
+            }));
 
             return true;
         } else {

package/src/tigerbeetle/src/vsr/superblock_quorums.zig

@@ -3,7 +3,7 @@ const assert = std.debug.assert;
 const log = std.log.scoped(.superblock_quorums);
 
 const superblock = @import("./superblock.zig");
-const SuperBlockSector = superblock.SuperBlockSector;
+const SuperBlockHeader = superblock.SuperBlockHeader;
 const SuperBlockVersion = superblock.SuperBlockVersion;
 const fuzz = @import("./superblock_quorums_fuzz.zig");
 
@@ -16,10 +16,10 @@ pub fn QuorumsType(comptime options: Options) type {
         const Quorums = @This();
 
         const Quorum = struct {
-            sector: *const SuperBlockSector,
+            header: *const SuperBlockHeader,
             valid: bool = false,
             /// Track which copies are a member of the quorum.
-            /// Used to ignore duplicate copies of a sector when determining a quorum.
+            /// Used to ignore duplicate copies of a header when determining a quorum.
             copies: QuorumCount = QuorumCount.initEmpty(),
             /// An integer value indicates the copy index found in the corresponding slot.
             /// A `null` value indicates that the copy is invalid or not a member of the working
@@ -86,7 +86,7 @@ pub fn QuorumsType(comptime options: Options) type {
         ///   trailers may be damaged.
         pub fn working(
             quorums: *Quorums,
-            copies: []SuperBlockSector,
+            copies: []SuperBlockHeader,
             threshold: Threshold,
         ) Error!Quorum {
             assert(copies.len == options.superblock_copies);
@@ -102,17 +102,17 @@ pub fn QuorumsType(comptime options: Options) type {
             for (quorums.slice()) |quorum| {
                 if (quorum.copies.count() == options.superblock_copies) {
                     log.debug("quorum: checksum={x} parent={x} sequence={} count={} valid={}", .{
-                        quorum.sector.checksum,
-                        quorum.sector.parent,
-                        quorum.sector.sequence,
+                        quorum.header.checksum,
+                        quorum.header.parent,
+                        quorum.header.sequence,
                         quorum.copies.count(),
                         quorum.valid,
                     });
                 } else {
                     log.warn("quorum: checksum={x} parent={x} sequence={} count={} valid={}", .{
-                        quorum.sector.checksum,
-                        quorum.sector.parent,
-                        quorum.sector.sequence,
+                        quorum.header.checksum,
+                        quorum.header.parent,
+                        quorum.header.sequence,
                         quorum.copies.count(),
                         quorum.valid,
                     });
@@ -128,7 +128,7 @@ pub fn QuorumsType(comptime options: Options) type {
             // Verify that the remaining quorums are correctly sorted:
             for (quorums.slice()[1..]) |a| {
                 assert(sort_priority_descending({}, b, a));
-                assert(a.sector.valid_checksum());
+                assert(a.header.valid_checksum());
             }
 
             // Even the best copy with the most quorum still has inadequate quorum.
@@ -140,61 +140,61 @@ pub fn QuorumsType(comptime options: Options) type {
             // - a lost or misdirected write
             // - a latent sector error that prevented a write
             for (quorums.slice()[1..]) |a| {
-                if (a.sector.cluster != b.sector.cluster) {
+                if (a.header.cluster != b.header.cluster) {
                     log.warn("superblock copy={} has cluster={} instead of {}", .{
-                        a.sector.copy,
-                        a.sector.cluster,
-                        b.sector.cluster,
+                        a.header.copy,
+                        a.header.cluster,
+                        b.header.cluster,
                     });
                     continue;
                 }
 
-                if (a.sector.replica != b.sector.replica) {
+                if (a.header.replica != b.header.replica) {
                     log.warn("superblock copy={} has replica={} instead of {}", .{
-                        a.sector.copy,
-                        a.sector.replica,
-                        b.sector.replica,
+                        a.header.copy,
+                        a.header.replica,
+                        b.header.replica,
                     });
                     continue;
                 }
 
-                if (a.sector.sequence == b.sector.sequence) {
+                if (a.header.sequence == b.header.sequence) {
                     // Two quorums, same cluster+replica+sequence, but different checksums.
                     // This shouldn't ever happen — but if it does, we can't safely repair.
-                    assert(a.sector.checksum != b.sector.checksum);
+                    assert(a.header.checksum != b.header.checksum);
                     return error.Fork;
                 }
 
-                if (a.sector.sequence > b.sector.sequence + 1) {
+                if (a.header.sequence > b.header.sequence + 1) {
                     // We read sequences such as (2,2,2,4) — 2 isn't safe to use, but there isn't a
                     // valid quorum for 4 either.
                     return error.ParentSkipped;
                 }
 
-                if (a.sector.sequence + 1 == b.sector.sequence) {
-                    assert(a.sector.checksum != b.sector.checksum);
-                    assert(a.sector.cluster == b.sector.cluster);
-                    assert(a.sector.replica == b.sector.replica);
+                if (a.header.sequence + 1 == b.header.sequence) {
+                    assert(a.header.checksum != b.header.checksum);
+                    assert(a.header.cluster == b.header.cluster);
+                    assert(a.header.replica == b.header.replica);
 
-                    if (a.sector.checksum != b.sector.parent) {
+                    if (a.header.checksum != b.header.parent) {
                         return error.ParentNotConnected;
-                    } else if (!a.sector.vsr_state.monotonic(b.sector.vsr_state)) {
+                    } else if (!a.header.vsr_state.monotonic(b.header.vsr_state)) {
                         return error.VSRStateNotMonotonic;
                     } else {
-                        assert(b.sector.valid_checksum());
+                        assert(b.header.valid_checksum());
 
                         return b;
                     }
                 }
             }
 
-            assert(b.sector.valid_checksum());
+            assert(b.header.valid_checksum());
             return b;
         }
 
         fn count_copy(
             quorums: *Quorums,
-            copy: *const SuperBlockSector,
+            copy: *const SuperBlockHeader,
             slot: usize,
             threshold: Threshold,
         ) void {
@@ -240,12 +240,12 @@ pub fn QuorumsType(comptime options: Options) type {
             }
 
             var quorum = quorums.find_or_insert_quorum_for_copy(copy);
-            assert(quorum.sector.checksum == copy.checksum);
-            assert(quorum.sector.equal(copy));
+            assert(quorum.header.checksum == copy.checksum);
+            assert(quorum.header.equal(copy));
 
             if (copy.copy >= options.superblock_copies) {
-                // This sector is a valid member of the quorum, but with an unexpected copy number.
-                // The "SuperBlockSector.copy" field is not protected by the checksum, so if that byte
+                // This header is a valid member of the quorum, but with an unexpected copy number.
+                // The "SuperBlockHeader.copy" field is not protected by the checksum, so if that byte
                 // (and only that byte) is corrupted, the superblock is still valid — but we don't know
                 // for certain which copy this was supposed to be.
                 // We make the assumption that this was not a double-fault (corrupt + misdirect) —
@@ -262,13 +262,13 @@ pub fn QuorumsType(comptime options: Options) type {
             quorum.valid = quorum.copies.count() >= threshold.count();
         }
 
-        fn find_or_insert_quorum_for_copy(quorums: *Quorums, copy: *const SuperBlockSector) *Quorum {
+        fn find_or_insert_quorum_for_copy(quorums: *Quorums, copy: *const SuperBlockHeader) *Quorum {
             assert(copy.valid_checksum());
 
             for (quorums.array[0..quorums.count]) |*quorum| {
-                if (copy.checksum == quorum.sector.checksum) return quorum;
+                if (copy.checksum == quorum.header.checksum) return quorum;
             } else {
-                quorums.array[quorums.count] = Quorum{ .sector = copy };
+                quorums.array[quorums.count] = Quorum{ .header = copy };
                 quorums.count += 1;
 
                 return &quorums.array[quorums.count - 1];
@@ -280,26 +280,26 @@ pub fn QuorumsType(comptime options: Options) type {
         }
 
         fn sort_priority_descending(_: void, a: Quorum, b: Quorum) bool {
-            assert(a.sector.checksum != b.sector.checksum);
+            assert(a.header.checksum != b.header.checksum);
 
             if (a.valid and !b.valid) return true;
             if (b.valid and !a.valid) return false;
 
-            if (a.sector.sequence > b.sector.sequence) return true;
-            if (b.sector.sequence > a.sector.sequence) return false;
+            if (a.header.sequence > b.header.sequence) return true;
+            if (b.header.sequence > a.header.sequence) return false;
 
             if (a.copies.count() > b.copies.count()) return true;
             if (b.copies.count() > a.copies.count()) return false;
 
             // The sort order must be stable and deterministic:
-            return a.sector.checksum > b.sector.checksum;
+            return a.header.checksum > b.header.checksum;
         }
 
         /// Repair a quorum's copies in the safest known order.
         /// Repair is complete when every copy is on-disk (not necessarily in its home slot).
         ///
-        /// We must be careful when repairing superblock sectors to avoid endangering our quorum if
-        /// an additional fault occurs. We primarily guard against torn sector writes — preventing a
+        /// We must be careful when repairing superblock headers to avoid endangering our quorum if
+        /// an additional fault occurs. We primarily guard against torn header writes — preventing a
         /// misdirected write from derailing repair is far more expensive and complex — but they are
         /// likewise far less likely to occur.
         ///
@@ -342,9 +342,9 @@ pub fn QuorumsType(comptime options: Options) type {
                 }
 
                 // In descending order, our priorities for repair are:
-                // 1. The slot holds no sector, and the copy was not found anywhere.
-                // 2. The slot holds no sector, but its copy was found elsewhere.
-                // 3. The slot holds a misdirected sector, but that copy is in another slot as well.
+                // 1. The slot holds no header, and the copy was not found anywhere.
+                // 2. The slot holds no header, but its copy was found elsewhere.
+                // 3. The slot holds a misdirected header, but that copy is in another slot as well.
                 var a: ?u8 = null;
                 var b: ?u8 = null;
                 var c: ?u8 = null;
@@ -388,7 +388,7 @@ test "Quorum.repairs" {
     defer std.testing.log_level = level;
 
     try fuzz.fuzz_quorum_repairs(prng.random(), .{ .superblock_copies = 4 });
-    // TODO: Enable these once SuperBlockSector is generic over its Constants.
+    // TODO: Enable these once SuperBlockHeader is generic over its Constants.
     // try fuzz.fuzz_quorum_repairs(prng.random(), .{ .superblock_copies = 6 });
     // try fuzz.fuzz_quorum_repairs(prng.random(), .{ .superblock_copies = 8 });
 }