tigerbeetle-node 0.11.4 → 0.11.5

package/src/tigerbeetle/src/vsr/superblock.zig

@@ -16,7 +16,7 @@ const mem = std.mem;
 const meta = std.meta;
 const os = std.os;
 
-const config = @import("../constants.zig");
+const constants = @import("../constants.zig");
 const div_ceil = @import("../util.zig").div_ceil;
 const vsr = @import("../vsr.zig");
 const log = std.log.scoped(.superblock);
@@ -27,7 +27,7 @@ pub const SuperBlockManifest = @import("superblock_manifest.zig").Manifest;
 pub const SuperBlockFreeSet = @import("superblock_free_set.zig").FreeSet;
 pub const SuperBlockClientTable = @import("superblock_client_table.zig").ClientTable;
 pub const Quorums = @import("superblock_quorums.zig").QuorumsType(.{
-    .superblock_copies = config.superblock_copies,
+    .superblock_copies = constants.superblock_copies,
 });
 
 pub const SuperBlockVersion: u16 = 0;
@@ -81,7 +81,7 @@ pub const SuperBlockSector = extern struct {
 
     /// A listing of persistent read snapshots that have been issued to clients.
     /// A snapshot.created timestamp of 0 indicates that the snapshot is null.
-    snapshots: [config.lsm_snapshots_max]Snapshot,
+    snapshots: [constants.lsm_snapshots_max]Snapshot,
 
     /// The size of the manifest block references stored in the superblock trailer.
     /// The block addresses and checksums in this section of the trailer are laid out as follows:
@@ -170,7 +170,7 @@ pub const SuperBlockSector = extern struct {
         /// to ensure determinstic storage.
         pub fn op_compacted(state: VSRState, op: u64) bool {
             // If commit_min is 0, we have never checkpointed, so no compactions are checkpointed.
-            return state.commit_min > 0 and op <= state.commit_min + config.lsm_batch_multiple;
+            return state.commit_min > 0 and op <= state.commit_min + constants.lsm_batch_multiple;
         }
     };
 
@@ -204,7 +204,7 @@ pub const SuperBlockSector = extern struct {
     };
 
     comptime {
-        assert(@sizeOf(SuperBlockSector) == config.sector_size);
+        assert(@sizeOf(SuperBlockSector) == constants.sector_size);
         // Assert that there is no implicit padding in the struct.
         assert(@bitSizeOf(SuperBlockSector) == @sizeOf(SuperBlockSector) * 8);
     }
@@ -225,7 +225,7 @@ pub const SuperBlockSector = extern struct {
     }
 
     pub fn set_checksum(superblock: *SuperBlockSector) void {
-        assert(superblock.copy < config.superblock_copies);
+        assert(superblock.copy < constants.superblock_copies);
         assert(superblock.version == SuperBlockVersion);
         assert(superblock.flags == 0);
 
@@ -271,19 +271,19 @@ pub const SuperBlockSector = extern struct {
 };
 
 comptime {
-    switch (config.superblock_copies) {
+    switch (constants.superblock_copies) {
         4, 6, 8 => {},
         else => @compileError("superblock_copies must be either { 4, 6, 8 } for flexible quorums."),
     }
 }
 
 /// The size of the entire superblock storage zone.
-pub const superblock_zone_size = superblock_copy_size * config.superblock_copies;
+pub const superblock_zone_size = superblock_copy_size * constants.superblock_copies;
 
 /// The size of an individual superblock including trailer.
 pub const superblock_copy_size = @sizeOf(SuperBlockSector) + superblock_trailer_size_max;
 comptime {
-    assert(superblock_copy_size % config.sector_size == 0);
+    assert(superblock_copy_size % constants.sector_size == 0);
 }
 
 /// The maximum possible size of the superblock trailer, following the superblock sector.
@@ -293,14 +293,14 @@ pub const superblock_trailer_size_max = blk: {
     // 2. the maximum possible size of the EWAH-compressed bit set addressable by the free set.
 
     assert(superblock_trailer_manifest_size_max > 0);
-    assert(superblock_trailer_manifest_size_max % config.sector_size == 0);
+    assert(superblock_trailer_manifest_size_max % constants.sector_size == 0);
     assert(superblock_trailer_manifest_size_max % SuperBlockManifest.BlockReferenceSize == 0);
 
     assert(superblock_trailer_free_set_size_max > 0);
-    assert(superblock_trailer_free_set_size_max % config.sector_size == 0);
+    assert(superblock_trailer_free_set_size_max % constants.sector_size == 0);
 
     assert(superblock_trailer_client_table_size_max > 0);
-    assert(superblock_trailer_client_table_size_max % config.sector_size == 0);
+    assert(superblock_trailer_client_table_size_max % constants.sector_size == 0);
 
     // We order the smaller manifest section ahead of the block free set for better access locality.
     // For example, it's cheaper to skip over 1 MiB when reading from disk than to skip over 32 MiB.
@@ -317,15 +317,15 @@ pub const superblock_trailer_manifest_size_max = blk: {
     // Use a multiple of sector * reference so that the size is exactly divisible without padding:
     // For example, this 2.5 MiB manifest trailer == 65536 references == 65536 * 511 or 34m tables.
     // TODO Size this relative to the expected number of tables & fragmentation.
-    break :blk 16 * config.sector_size * SuperBlockManifest.BlockReferenceSize;
+    break :blk 16 * constants.sector_size * SuperBlockManifest.BlockReferenceSize;
 };
 
 pub const superblock_trailer_free_set_size_max = blk: {
-    const encode_size_max = SuperBlockFreeSet.encode_size_max(config.block_count_max);
+    const encode_size_max = SuperBlockFreeSet.encode_size_max(constants.block_count_max);
     assert(encode_size_max > 0);
 
     // Round up to the nearest sector:
-    break :blk div_ceil(encode_size_max, config.sector_size) * config.sector_size;
+    break :blk div_ceil(encode_size_max, constants.sector_size) * constants.sector_size;
 };
 
 pub const superblock_trailer_client_table_size_max = blk: {
@@ -333,11 +333,11 @@ pub const superblock_trailer_client_table_size_max = blk: {
     assert(encode_size_max > 0);
 
     // Round up to the nearest sector:
-    break :blk div_ceil(encode_size_max, config.sector_size) * config.sector_size;
+    break :blk div_ceil(encode_size_max, constants.sector_size) * constants.sector_size;
 };
 
 pub const data_file_size_min = blk: {
-    break :blk superblock_zone_size + config.journal_size_max;
+    break :blk superblock_zone_size + constants.journal_size_max;
 };
 
 /// This table shows the sequence number progression of the SuperBlock's sectors.
@@ -405,15 +405,15 @@ pub fn SuperBlockType(comptime Storage: type) type {
         storage_size: u64 = superblock_zone_size,
 
         /// The superblock that was recovered at startup after a crash or that was last written.
-        working: *align(config.sector_size) SuperBlockSector,
+        working: *align(constants.sector_size) SuperBlockSector,
 
         /// The superblock that will replace the current working superblock once written.
         /// We cannot mutate any working state directly until it is safely on stable storage.
         /// Otherwise, we may accidentally externalize guarantees that are not yet durable.
-        staging: *align(config.sector_size) SuperBlockSector,
+        staging: *align(constants.sector_size) SuperBlockSector,
 
         /// The copies that we read into at startup or when verifying the written superblock.
-        reading: []align(config.sector_size) SuperBlockSector,
+        reading: []align(constants.sector_size) SuperBlockSector,
 
         /// It might seem that, at startup, we simply install the copy with the highest sequence.
         ///
@@ -435,9 +435,9 @@ pub fn SuperBlockType(comptime Storage: type) type {
         free_set: FreeSet,
         client_table: ClientTable,
 
-        manifest_buffer: []align(config.sector_size) u8,
-        free_set_buffer: []align(config.sector_size) u8,
-        client_table_buffer: []align(config.sector_size) u8,
+        manifest_buffer: []align(constants.sector_size) u8,
+        free_set_buffer: []align(constants.sector_size) u8,
+        client_table_buffer: []align(constants.sector_size) u8,
 
         /// Whether the superblock has been opened. An open superblock may not be formatted.
         opened: bool = false,
@@ -457,15 +457,15 @@ pub fn SuperBlockType(comptime Storage: type) type {
             storage: *Storage,
             message_pool: *MessagePool,
         ) !SuperBlock {
-            const a = try allocator.allocAdvanced(SuperBlockSector, config.sector_size, 1, .exact);
+            const a = try allocator.allocAdvanced(SuperBlockSector, constants.sector_size, 1, .exact);
             errdefer allocator.free(a);
 
-            const b = try allocator.allocAdvanced(SuperBlockSector, config.sector_size, 1, .exact);
+            const b = try allocator.allocAdvanced(SuperBlockSector, constants.sector_size, 1, .exact);
             errdefer allocator.free(b);
 
             const reading = try allocator.allocAdvanced(
-                [config.superblock_copies]SuperBlockSector,
-                config.sector_size,
+                [constants.superblock_copies]SuperBlockSector,
+                constants.sector_size,
                 1,
                 .exact,
             );
@@ -481,7 +481,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
             );
             errdefer manifest.deinit(allocator);
 
-            var free_set = try FreeSet.init(allocator, config.block_count_max);
+            var free_set = try FreeSet.init(allocator, constants.block_count_max);
             errdefer free_set.deinit(allocator);
 
             var client_table = try ClientTable.init(allocator, message_pool);
@@ -489,7 +489,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
 
             const manifest_buffer = try allocator.allocAdvanced(
                 u8,
-                config.sector_size,
+                constants.sector_size,
                 superblock_trailer_manifest_size_max,
                 .exact,
             );
@@ -497,7 +497,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
 
             const free_set_buffer = try allocator.allocAdvanced(
                 u8,
-                config.sector_size,
+                constants.sector_size,
                 superblock_trailer_free_set_size_max,
                 .exact,
             );
@@ -505,7 +505,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
 
             const client_table_buffer = try allocator.allocAdvanced(
                 u8,
-                config.sector_size,
+                constants.sector_size,
                 superblock_trailer_client_table_size_max,
                 .exact,
             );
@@ -555,9 +555,9 @@ pub fn SuperBlockType(comptime Storage: type) type {
         ) void {
             assert(!superblock.opened);
 
-            assert(options.replica < config.replicas_max);
+            assert(options.replica < constants.replicas_max);
             assert(options.size_max >= data_file_size_min);
-            assert(options.size_max % config.sector_size == 0);
+            assert(options.size_max % constants.sector_size == 0);
 
             // This working copy provides the parent checksum, and will not be written to disk.
             // We therefore use zero values to make this parent checksum as stable as possible.
@@ -757,7 +757,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
 
         fn write_staging_encode_free_set(superblock: *SuperBlock) void {
             const staging: *SuperBlockSector = superblock.staging;
-            const encode_size_max = FreeSet.encode_size_max(config.block_count_max);
+            const encode_size_max = FreeSet.encode_size_max(constants.block_count_max);
             const target = superblock.free_set_buffer[0..encode_size_max];
 
             superblock.free_set.include_staging();
@@ -768,7 +768,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
             staging.size = data_file_size_min;
 
             if (superblock.free_set.highest_address_acquired()) |address| {
-                staging.size += address * config.block_size;
+                staging.size += address * constants.block_size;
             }
             assert(staging.size >= data_file_size_min);
             assert(staging.size <= staging.size_max);
@@ -933,7 +933,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
             assert(superblock.staging.size >= data_file_size_min);
             assert(superblock.staging.size <= superblock.staging.size_max);
 
-            assert(context.copy.? < config.superblock_copies);
+            assert(context.copy.? < constants.superblock_copies);
             superblock.staging.copy = context.copy.?;
 
             // Updating the copy number should not affect the checksum, which was previously set:
@@ -970,7 +970,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
 
             assert(superblock.queue_head == context);
 
-            assert(copy < config.superblock_copies);
+            assert(copy < constants.superblock_copies);
             assert(copy == superblock.staging.copy);
 
             if (context.caller == .open) {
@@ -979,7 +979,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
                 return;
             }
 
-            if (copy + 1 == config.superblock_copies) {
+            if (copy + 1 == constants.superblock_copies) {
                 context.copy = null;
                 superblock.read_working(context, .verify);
             } else {
@@ -1015,7 +1015,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
 
         fn read_sector(superblock: *SuperBlock, context: *Context) void {
             assert(superblock.queue_head == context);
-            assert(context.copy.? < config.superblock_copies);
+            assert(context.copy.? < constants.superblock_copies);
             assert(context.read_threshold != null);
 
             const buffer = mem.asBytes(&superblock.reading[context.copy.?]);
@@ -1046,8 +1046,8 @@ pub fn SuperBlockType(comptime Storage: type) type {
 
             assert(superblock.queue_head == context);
 
-            assert(context.copy.? < config.superblock_copies);
-            if (context.copy.? + 1 != config.superblock_copies) {
+            assert(context.copy.? < constants.superblock_copies);
+            if (context.copy.? + 1 != constants.superblock_copies) {
                 context.copy = context.copy.? + 1;
                 superblock.read_sector(context);
                 return;
@@ -1134,7 +1134,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
         fn read_manifest(superblock: *SuperBlock, context: *Context) void {
             assert(context.caller == .open);
             assert(superblock.queue_head == context);
-            assert(context.copy.? < config.superblock_copies);
+            assert(context.copy.? < constants.superblock_copies);
 
             const size = vsr.sector_ceil(superblock.working.manifest_size);
             assert(size <= superblock_trailer_manifest_size_max);
@@ -1189,7 +1189,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
                 // We do not repair padding.
                 context.copy = 0;
                 superblock.read_free_set(context);
-            } else if (copy + 1 == config.superblock_copies) {
+            } else if (copy + 1 == constants.superblock_copies) {
                 @panic("superblock manifest lost");
             } else {
                 log.debug("open: read_manifest: corrupt copy={}", .{copy});
@@ -1201,7 +1201,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
         fn read_free_set(superblock: *SuperBlock, context: *Context) void {
             assert(context.caller == .open);
             assert(superblock.queue_head == context);
-            assert(context.copy.? < config.superblock_copies);
+            assert(context.copy.? < constants.superblock_copies);
 
             const size = vsr.sector_ceil(superblock.working.free_set_size);
             assert(size <= superblock_trailer_free_set_size_max);
@@ -1248,14 +1248,14 @@ pub fn SuperBlockType(comptime Storage: type) type {
 
                 log.debug("open: read_free_set: acquired blocks: {}/{}", .{
                     superblock.free_set.count_acquired(),
-                    config.block_count_max,
+                    constants.block_count_max,
                 });
 
                 superblock.verify_manifest_blocks_are_acquired_in_free_set();
 
                 // TODO Repair any impaired copies before we continue.
                 superblock.read_client_table(context);
-            } else if (copy + 1 == config.superblock_copies) {
+            } else if (copy + 1 == constants.superblock_copies) {
                 @panic("superblock free set lost");
             } else {
                 log.debug("open: read_free_set: corrupt copy={}", .{copy});
@@ -1274,7 +1274,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
         fn read_client_table(superblock: *SuperBlock, context: *Context) void {
             assert(context.caller == .open);
             assert(superblock.queue_head == context);
-            assert(context.copy.? < config.superblock_copies);
+            assert(context.copy.? < constants.superblock_copies);
 
             const size = vsr.sector_ceil(superblock.working.client_table_size);
             assert(size <= superblock_trailer_client_table_size_max);
@@ -1321,12 +1321,12 @@ pub fn SuperBlockType(comptime Storage: type) type {
 
                 log.debug("open: read_client_table: client requests: {}/{}", .{
                     superblock.client_table.count(),
-                    config.clients_max,
+                    constants.clients_max,
                 });
 
                 context.copy = null;
                 superblock.repair(context);
-            } else if (copy + 1 == config.superblock_copies) {
+            } else if (copy + 1 == constants.superblock_copies) {
                 @panic("superblock client table lost");
             } else {
                 log.debug("open: read_client_table: corrupt copy={}", .{copy});
@@ -1430,7 +1430,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
             // The rule is that the write quorum plus the read quorum must be exactly copies + 1.
 
             return switch (caller) {
-                .format, .checkpoint, .view_change => switch (config.superblock_copies) {
+                .format, .checkpoint, .view_change => switch (constants.superblock_copies) {
                     4 => 3,
                     6 => 4,
                     8 => 5,
@@ -1438,7 +1438,7 @@ pub fn SuperBlockType(comptime Storage: type) type {
                 },
                 // The open quorum must allow for at least two copy faults, because our view change
                 // updates an existing set of copies in place, temporarily impairing one copy.
-                .open => switch (config.superblock_copies) {
+                .open => switch (constants.superblock_copies) {
                     4 => 2,
                     6 => 3,
                     8 => 4,
@@ -1451,22 +1451,22 @@ pub fn SuperBlockType(comptime Storage: type) type {
 
 pub const Layout = struct {
     pub fn offset_sector(copy: u8) u64 {
-        assert(copy < config.superblock_copies);
+        assert(copy < constants.superblock_copies);
         return superblock_copy_size * @as(u64, copy);
     }
 
     pub fn offset_manifest(copy: u8) u64 {
-        assert(copy < config.superblock_copies);
+        assert(copy < constants.superblock_copies);
         return offset_sector(copy) + @sizeOf(SuperBlockSector);
     }
 
     pub fn offset_free_set(copy: u8) u64 {
-        assert(copy < config.superblock_copies);
+        assert(copy < constants.superblock_copies);
         return offset_manifest(copy) + superblock_trailer_manifest_size_max;
     }
 
     pub fn offset_client_table(copy: u8) u64 {
-        assert(copy < config.superblock_copies);
+        assert(copy < constants.superblock_copies);
         return offset_free_set(copy) + superblock_trailer_free_set_size_max;
     }
 };

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

@@ -2,7 +2,7 @@ const std = @import("std");
 const assert = std.debug.assert;
 const mem = std.mem;
 
-const config = @import("../constants.zig");
+const constants = @import("../constants.zig");
 const vsr = @import("../vsr.zig");
 const util = @import("../util.zig");
 
@@ -43,10 +43,10 @@ pub const ClientTable = struct {
         var entries: Entries = .{};
         errdefer entries.deinit(allocator);
 
-        try entries.ensureTotalCapacity(allocator, @intCast(u32, config.clients_max));
-        assert(entries.capacity() >= config.clients_max);
+        try entries.ensureTotalCapacity(allocator, @intCast(u32, constants.clients_max));
+        assert(entries.capacity() >= constants.clients_max);
 
-        const sorted = try allocator.alloc(*const Entry, config.clients_max);
+        const sorted = try allocator.alloc(*const Entry, constants.clients_max);
         errdefer allocator.free(sorted);
 
         return ClientTable{
@@ -84,15 +84,15 @@ pub const ClientTable = struct {
         // First goes the vsr headers for the entries.
         // This takes advantage of the buffer alignment to avoid adding padding for the headers.
         size_max = std.mem.alignForward(size_max, @alignOf(vsr.Header));
-        size_max += @sizeOf(vsr.Header) * config.clients_max;
+        size_max += @sizeOf(vsr.Header) * constants.clients_max;
 
         // Then follows the session values for the entries.
         size_max = std.mem.alignForward(size_max, @alignOf(u64));
-        size_max += @sizeOf(u64) * config.clients_max;
+        size_max += @sizeOf(u64) * constants.clients_max;
 
         // Followed by the message bodies for the entries.
         size_max = std.mem.alignForward(size_max, @alignOf(u8));
-        size_max += config.message_size_max * config.clients_max;
+        size_max += constants.message_size_max * constants.clients_max;
 
         // Finally the entry count at the end
         size_max = std.mem.alignForward(size_max, @alignOf(u32));
@@ -239,13 +239,13 @@ pub const ClientTable = struct {
         const client = entry.reply.header.client;
         client_table.entries.putAssumeCapacityNoClobber(client, entry.*);
 
-        if (config.verify) assert(client_table.entries.contains(client));
+        if (constants.verify) assert(client_table.entries.contains(client));
     }
 
     pub fn remove(client_table: *ClientTable, client: u128) void {
         assert(client_table.entries.remove(client));
 
-        if (config.verify) assert(!client_table.entries.contains(client));
+        if (constants.verify) assert(!client_table.entries.contains(client));
     }
 
     pub const Iterator = Entries.ValueIterator;

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

@@ -5,7 +5,7 @@ const mem = std.mem;
 const DynamicBitSetUnmanaged = std.bit_set.DynamicBitSetUnmanaged;
 const MaskInt = DynamicBitSetUnmanaged.MaskInt;
 
-const config = @import("../constants.zig");
+const constants = @import("../constants.zig");
 
 const ewah = @import("../ewah.zig").ewah(usize);
 const div_ceil = @import("../util.zig").div_ceil;
@@ -74,7 +74,7 @@ pub const FreeSet = struct {
     //
     // e.g. 10TiB disk ÷ 64KiB/block ÷ 512*8 blocks/shard ÷ 8 shards/byte = 5120B index
     const shard_cache_lines = 8;
-    pub const shard_size = shard_cache_lines * config.cache_line_size * @bitSizeOf(u8);
+    pub const shard_size = shard_cache_lines * constants.cache_line_size * @bitSizeOf(u8);
     comptime {
         assert(shard_size == 4096);
         assert(@bitSizeOf(MaskInt) == 64);
@@ -404,8 +404,8 @@ fn bit_set_masks(bit_set: DynamicBitSetUnmanaged) []usize {
 }
 
 test "FreeSet block shard count" {
-    if (config.block_size != 64 * 1024) return;
-    const blocks_in_tb = @divExact(1 << 40, config.block_size);
+    if (constants.block_size != 64 * 1024) return;
+    const blocks_in_tb = @divExact(1 << 40, constants.block_size);
     try test_block_shards_count(5120 * 8, 10 * blocks_in_tb);
     try test_block_shards_count(5120 * 8 - 1, 10 * blocks_in_tb - FreeSet.shard_size);
     try test_block_shards_count(1, FreeSet.shard_size); // Must be at least one index bit.

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

@@ -14,7 +14,7 @@ const std = @import("std");
 const assert = std.debug.assert;
 const log = std.log.scoped(.fuzz_vsr_superblock);
 
-const config = @import("../constants.zig");
+const constants = @import("../constants.zig");
 const util = @import("../util.zig");
 const vsr = @import("../vsr.zig");
 const Storage = @import("../test/storage.zig").Storage;
@@ -254,7 +254,7 @@ const Environment = struct {
             .replica = 0,
             // Include extra space (beyond what Storage actually needs) because SuperBlock will
             // update the sector's size according to the highest FreeSet block allocated.
-            .size_max = data_file_size_min + 1000 * config.block_size,
+            .size_max = data_file_size_min + 1000 * constants.block_size,
         });
 
         assert(env.sequence_states.items.len == 0);

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

@@ -5,7 +5,7 @@ const assert = std.debug.assert;
 const log = std.log.scoped(.superblock_manifest);
 const mem = std.mem;
 
-const config = @import("../constants.zig");
+const constants = @import("../constants.zig");
 const util = @import("../util.zig");
 
 // TODO Compute & use the upper bound of manifest blocks (per tree) to size the trailer zone.
@@ -92,7 +92,7 @@ pub const Manifest = struct {
     }
 
     pub fn encode(manifest: *const Manifest, target: []align(@alignOf(u128)) u8) u64 {
-        if (config.verify) manifest.verify();
+        if (constants.verify) manifest.verify();
 
         assert(target.len > 0);
         assert(target.len % @sizeOf(u128) == 0);
@@ -177,7 +177,7 @@ pub const Manifest = struct {
         mem.set(u128, manifest.checksums[manifest.count..], 0);
         mem.set(u64, manifest.addresses[manifest.count..], 0);
 
-        if (config.verify) manifest.verify();
+        if (constants.verify) manifest.verify();
     }
 
     /// Addresses must be unique across all appends, or remove() must be called first.
@@ -208,7 +208,7 @@ pub const Manifest = struct {
             manifest.count_max,
         });
 
-        if (config.verify) {
+        if (constants.verify) {
             const index = manifest.index_for_address(address).?;
             assert(index == manifest.count - 1);
             manifest.verify_index_tree_checksum_address(index, tree, checksum, address);
@@ -243,7 +243,7 @@ pub const Manifest = struct {
             manifest.count_max,
         });
 
-        if (config.verify) {
+        if (constants.verify) {
             assert(manifest.index_for_address(address) == null);
             manifest.verify();
         }

package/src/tigerbeetle/src/vsr.zig

@@ -4,7 +4,7 @@ const Allocator = std.mem.Allocator;
 const assert = std.debug.assert;
 const log = std.log.scoped(.vsr);
 
-const config = @import("constants.zig");
+const constants = @import("constants.zig");
 
 /// The version of our Viewstamped Replication protocol in use, including customizations.
 /// For backwards compatibility through breaking changes (e.g. upgrading checksums/ciphers).
@@ -29,8 +29,8 @@ pub const Zone = enum {
     grid,
 
     const size_superblock = @import("vsr/superblock.zig").superblock_zone_size;
-    const size_wal_headers = config.journal_size_headers;
-    const size_wal_prepares = config.journal_size_prepares;
+    const size_wal_headers = constants.journal_size_headers;
+    const size_wal_prepares = constants.journal_size_prepares;
 
     comptime {
         for (.{
@@ -38,7 +38,7 @@ pub const Zone = enum {
             size_wal_headers,
             size_wal_prepares,
         }) |zone_size| {
-            assert(zone_size % config.sector_size == 0);
+            assert(zone_size % constants.sector_size == 0);
         }
     }
 
@@ -630,7 +630,7 @@ pub const Header = extern struct {
     }
 
     pub fn reserved(cluster: u32, slot: u64) Header {
-        assert(slot < config.journal_slot_count);
+        assert(slot < constants.journal_slot_count);
 
         var header = Header{
             .command = .reserved,
@@ -662,8 +662,8 @@ pub const Timeout = struct {
     id: u128,
     after: u64,
     attempts: u8 = 0,
-    rtt: u64 = config.rtt_ticks,
-    rtt_multiple: u8 = config.rtt_multiple,
+    rtt: u64 = constants.rtt_ticks,
+    rtt_multiple: u8 = constants.rtt_multiple,
     ticks: u64 = 0,
     ticking: bool = false,
 
@@ -714,8 +714,8 @@ pub const Timeout = struct {
 
         const after = (self.rtt * self.rtt_multiple) + exponential_backoff_with_jitter(
             random,
-            config.backoff_min_ticks,
-            config.backoff_max_ticks,
+            constants.backoff_min_ticks,
+            constants.backoff_max_ticks,
             self.attempts,
         );
 
@@ -727,8 +727,8 @@ pub const Timeout = struct {
             self.after,
             after,
             self.rtt,
-            config.backoff_min_ticks,
-            config.backoff_max_ticks,
+            constants.backoff_min_ticks,
+            constants.backoff_max_ticks,
             self.attempts,
         });
 
@@ -871,12 +871,12 @@ pub fn parse_address(raw: []const u8) !std.net.Address {
 
         // Let's try parsing as a port first:
         if (std.fmt.parseUnsigned(u16, raw, 10)) |port| {
-            return std.net.Address.parseIp4(config.address, port) catch unreachable;
+            return std.net.Address.parseIp4(constants.address, port) catch unreachable;
         } else |err| switch (err) {
             error.Overflow => return error.PortOverflow,
             error.InvalidCharacter => {
                 // Something was not a digit, let's try parsing as an IPv4 instead:
-                return std.net.Address.parseIp4(raw, config.port) catch {
+                return std.net.Address.parseIp4(raw, constants.port) catch {
                     return error.AddressInvalid;
                 };
             },
@@ -912,8 +912,8 @@ test "parse_addresses" {
             .raw = "1.2.3.4:5,4321,2.3.4.5",
             .addresses = &[3]std.net.Address{
                 std.net.Address.initIp4([_]u8{ 1, 2, 3, 4 }, 5),
-                try std.net.Address.parseIp4(config.address, 4321),
-                std.net.Address.initIp4([_]u8{ 2, 3, 4, 5 }, config.port),
+                try std.net.Address.parseIp4(constants.address, 4321),
+                std.net.Address.initIp4([_]u8{ 2, 3, 4, 5 }, constants.port),
             },
         },
         .{
@@ -921,7 +921,7 @@ test "parse_addresses" {
             .raw = "1.2.3.4:5,4321",
             .addresses = &[2]std.net.Address{
                 std.net.Address.initIp4([_]u8{ 1, 2, 3, 4 }, 5),
-                try std.net.Address.parseIp4(config.address, 4321),
+                try std.net.Address.parseIp4(constants.address, 4321),
             },
         },
     };
@@ -963,13 +963,13 @@ test "parse_addresses" {
 }
 
 pub fn sector_floor(offset: u64) u64 {
-    const sectors = math.divFloor(u64, offset, config.sector_size) catch unreachable;
-    return sectors * config.sector_size;
+    const sectors = math.divFloor(u64, offset, constants.sector_size) catch unreachable;
+    return sectors * constants.sector_size;
 }
 
 pub fn sector_ceil(offset: u64) u64 {
-    const sectors = math.divCeil(u64, offset, config.sector_size) catch unreachable;
-    return sectors * config.sector_size;
+    const sectors = math.divCeil(u64, offset, constants.sector_size) catch unreachable;
+    return sectors * constants.sector_size;
 }
 
 pub fn checksum(source: []const u8) u128 {