tigerbeetle-node 0.11.4 → 0.11.6

package/src/tigerbeetle/src/c/test.zig

@@ -6,7 +6,7 @@ const testing = std.testing;
 const c = @cImport(@cInclude("tb_client.h"));
 
 const util = @import("../util.zig");
-const config = @import("../constants.zig");
+const constants = @import("../constants.zig");
 const Packet = @import("tb_client/packet.zig").Packet;
 
 const Mutex = std.Thread.Mutex;
@@ -91,10 +91,10 @@ const Completion = struct {
 // 3. the data marshaling is correct, and exactly the same data sent was received back.
 test "c_client echo" {
     // Using the create_accounts operation for this test.
-    const RequestContext = RequestContextType(config.message_body_size_max);
+    const RequestContext = RequestContextType(constants.message_body_size_max);
     const create_accounts_operation: u8 = c.TB_OPERATION_CREATE_ACCOUNTS;
     const event_size = @sizeOf(c.tb_account_t);
-    const event_request_max = @divFloor(config.message_body_size_max, event_size);
+    const event_request_max = @divFloor(constants.message_body_size_max, event_size);
 
     // Initializing an echo client for testing purposes.
     // We ensure that the retry mechanism is being tested
@@ -103,7 +103,7 @@ test "c_client echo" {
     var tb_packet_list: c.tb_packet_list_t = undefined;
     const cluster_id = 0;
     const address = "3000";
-    const packets_count: u32 = config.client_request_queue_max * 2;
+    const packets_count: u32 = constants.client_request_queue_max * 2;
     const tb_context: usize = 42;
     const result = c.tb_client_init_echo(
         &tb_client,
@@ -221,7 +221,7 @@ test "c_client tb_status" {
     // More addresses thant "replicas_max" should return "TB_STATUS_ADDRESS_LIMIT_EXCEEDED":
     try assert_status(
         1,
-        ("3000," ** config.replicas_max) ++ "3001",
+        ("3000," ** constants.replicas_max) ++ "3001",
         c.TB_STATUS_ADDRESS_LIMIT_EXCEEDED,
     );
 
@@ -234,7 +234,7 @@ test "c_client tb_status" {
 
 // Asserts the validation rules associated with the "TB_PACKET_STATUS" enum.
 test "c_client tb_packet_status" {
-    const RequestContext = RequestContextType(config.message_body_size_max);
+    const RequestContext = RequestContextType(constants.message_body_size_max);
 
     var tb_client: c.tb_client_t = undefined;
     var tb_packet_list: c.tb_packet_list_t = undefined;
@@ -299,12 +299,12 @@ test "c_client tb_packet_status" {
 
     var packet_list = @ptrCast(*Packet.List, &tb_packet_list);
 
-    // Messages larger than config.message_body_size_max should return "too_much_data":
+    // Messages larger than constants.message_body_size_max should return "too_much_data":
     try assert_result(
         tb_client,
         packet_list,
         c.TB_OPERATION_CREATE_TRANSFERS,
-        config.message_body_size_max + @sizeOf(c.tb_transfer_t),
+        constants.message_body_size_max + @sizeOf(c.tb_transfer_t),
         c.TB_PACKET_TOO_MUCH_DATA,
     );
 

package/src/tigerbeetle/src/cli.zig

@@ -7,12 +7,13 @@ const meta = std.meta;
 const net = std.net;
 const os = std.os;
 
-const config = @import("constants.zig");
+const constants = @import("constants.zig");
 const tigerbeetle = @import("tigerbeetle.zig");
 const vsr = @import("vsr.zig");
 const IO = @import("io.zig").IO;
+const data_file_size_min = @import("vsr/superblock.zig").data_file_size_min;
 
-// TODO Document --cache-accounts, --cache-transfers, --cache-transfers-posted
+// TODO Document --cache-accounts, --cache-transfers, --cache-transfers-posted, --limit-storage
 const usage = fmt.comptimePrint(
     \\Usage:
     \\
@@ -72,25 +73,28 @@ const usage = fmt.comptimePrint(
     \\  tigerbeetle version --verbose
     \\
 , .{
-    .default_address = config.address,
-    .default_port = config.port,
+    .default_address = constants.address,
+    .default_port = constants.port,
 });
 
 pub const Command = union(enum) {
-    format: struct {
-        args_allocated: std.ArrayList([:0]const u8),
-        cluster: u32,
-        replica: u8,
-        path: [:0]const u8,
-    },
-    start: struct {
+    pub const Start = struct {
         args_allocated: std.ArrayList([:0]const u8),
         addresses: []net.Address,
         cache_accounts: u32,
         cache_transfers: u32,
         cache_transfers_posted: u32,
+        storage_size_limit: u64,
+        path: [:0]const u8,
+    };
+
+    format: struct {
+        args_allocated: std.ArrayList([:0]const u8),
+        cluster: u32,
+        replica: u8,
         path: [:0]const u8,
     },
+    start: Start,
     version: struct {
         verbose: bool,
     },
@@ -117,6 +121,7 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
     var cache_accounts: ?[]const u8 = null;
     var cache_transfers: ?[]const u8 = null;
     var cache_transfers_posted: ?[]const u8 = null;
+    var storage_size_limit: ?[]const u8 = null;
     var verbose: ?bool = null;
 
     var args = try std.process.argsWithAllocator(allocator);
@@ -163,6 +168,9 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
         } else if (mem.startsWith(u8, arg, "--cache-transfers-posted")) {
             if (command != .start) fatal("--cache-transfers-posted: supported only by 'start' command", .{});
             cache_transfers_posted = parse_flag("--cache-transfers-posted", arg);
+        } else if (mem.startsWith(u8, arg, "--limit-storage")) {
+            if (command != .start) fatal("--limit-storage: supported only by 'start' command", .{});
+            storage_size_limit = parse_flag("--limit-storage", arg);
         } else if (mem.eql(u8, arg, "--verbose")) {
             if (command != .version) fatal("--verbose: supported only by 'version' command", .{});
             verbose = true;
@@ -206,18 +214,19 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
                     .cache_accounts = parse_size_to_count(
                         tigerbeetle.Account,
                         cache_accounts,
-                        config.cache_accounts_max,
+                        constants.cache_accounts_max,
                     ),
                     .cache_transfers = parse_size_to_count(
                         tigerbeetle.Transfer,
                         cache_transfers,
-                        config.cache_transfers_max,
+                        constants.cache_transfers_max,
                     ),
                     .cache_transfers_posted = parse_size_to_count(
                         u256, // TODO(#264): Use actual type here, once exposed.
                         cache_transfers_posted,
-                        config.cache_transfers_posted_max,
+                        constants.cache_transfers_posted_max,
                     ),
+                    .storage_size_limit = parse_storage_size(storage_size_limit),
                     .path = path orelse fatal("required: <path>", .{}),
                 },
             };
@@ -255,11 +264,11 @@ fn parse_cluster(raw_cluster: []const u8) u32 {
 
 /// Parse and allocate the addresses returning a slice into that array.
 fn parse_addresses(allocator: std.mem.Allocator, raw_addresses: []const u8) []net.Address {
-    return vsr.parse_addresses(allocator, raw_addresses, config.replicas_max) catch |err| switch (err) {
+    return vsr.parse_addresses(allocator, raw_addresses, constants.replicas_max) catch |err| switch (err) {
         error.AddressHasTrailingComma => fatal("--addresses: invalid trailing comma", .{}),
         error.AddressLimitExceeded => {
             fatal("--addresses: too many addresses, at most {d} are allowed", .{
-                config.replicas_max,
+                constants.replicas_max,
             });
         },
         error.AddressHasMoreThanOneColon => {
@@ -272,6 +281,21 @@ fn parse_addresses(allocator: std.mem.Allocator, raw_addresses: []const u8) []ne
     };
 }
 
+fn parse_storage_size(size_string: ?[]const u8) u64 {
+    const size_min = data_file_size_min;
+    const size_max = constants.storage_size_max;
+    const size = if (size_string) |s| parse_size(s) else size_max;
+    if (size > size_max) fatal("storage size {} exceeds maximum: {}", .{ size, size_max });
+    if (size < size_min) fatal("storage size {} is below minimum: {}", .{ size, size_min });
+    if (size % constants.sector_size != 0) {
+        fatal("size value {} must be a multiple of sector size ({})", .{
+            size,
+            constants.sector_size,
+        });
+    }
+    return size;
+}
+
 fn parse_size(string: []const u8) u64 {
     var value = mem.trim(u8, string, " ");
 
@@ -366,7 +390,7 @@ fn parse_size_to_count(comptime T: type, string_opt: ?[]const u8, comptime defau
 }
 
 fn parse_replica(raw_replica: []const u8) u8 {
-    comptime assert(config.replicas_max <= std.math.maxInt(u8));
+    comptime assert(constants.replicas_max <= std.math.maxInt(u8));
     const replica = fmt.parseUnsigned(u8, raw_replica, 10) catch |err| switch (err) {
         error.Overflow => fatal("--replica: value exceeds an 8-bit unsigned integer", .{}),
         error.InvalidCharacter => fatal("--replica: value contains an invalid character", .{}),

package/src/tigerbeetle/src/config.zig

@@ -21,7 +21,7 @@ pub const Config = struct {
 /// - Client configs need not equal replica configs.
 /// - Replica configs can change between restarts.
 ///
-/// Fields are documented within the top-level module body.
+/// Fields are documented within constants.zig.
 const ConfigProcess = struct {
     log_level: std.log.Level = .info,
     tracer_backend: TracerBackend = .none,
@@ -64,7 +64,7 @@ const ConfigProcess = struct {
 ///   over the cluster lifetime.
 /// - The storage formats generated by different ConfigClusters are incompatible.
 ///
-/// Fields are documented within the top-level module body.
+/// Fields are documented within constants.zig.
 const ConfigCluster = struct {
     cache_line_size: comptime_int = 64,
     clients_max: usize,
@@ -72,7 +72,7 @@ const ConfigCluster = struct {
     journal_slot_count: usize = 1024,
     message_size_max: usize = 1 * 1024 * 1024,
     superblock_copies: comptime_int = 4,
-    size_max: usize = 16 * 1024 * 1024 * 1024 * 1024,
+    storage_size_max: u64 = 16 * 1024 * 1024 * 1024 * 1024,
     block_size: comptime_int = 64 * 1024,
     lsm_levels: u7 = 7,
     lsm_growth_factor: u32 = 8,
@@ -80,6 +80,7 @@ const ConfigCluster = struct {
     lsm_batch_multiple: comptime_int = 4,
     lsm_snapshots_max: usize = 32,
     lsm_value_to_key_layout_ratio_min: comptime_int = 16,
+    state_machine: StateMachine = .accounting,
 
     /// The WAL requires at least two sectors of redundant headers — otherwise we could lose them all to
     /// a single torn write. A replica needs at least one valid redundant header to determine an
@@ -102,6 +103,13 @@ const ConfigCluster = struct {
     }
 };
 
+pub const ConfigBase = enum {
+    production,
+    development,
+    test_min,
+    default,
+};
+
 pub const TracerBackend = enum {
     none,
     // Writes to a file (./tracer.json) which can be uploaded to https://ui.perfetto.dev/
@@ -110,6 +118,11 @@ pub const TracerBackend = enum {
     tracy,
 };
 
+pub const StateMachine = enum {
+    accounting,
+    testing,
+};
+
 pub const configs = struct {
     /// A good default config for production.
     pub const default_production = Config{
@@ -156,6 +169,7 @@ pub const configs = struct {
             .clients_max = 4,
             .journal_slot_count = Config.Cluster.journal_slot_count_min,
             .message_size_max = Config.Cluster.message_size_max_min(2),
+            .storage_size_max = 1024 * 1024 * 1024,
 
             .block_size = sector_size,
             .lsm_growth_factor = 4,
@@ -182,6 +196,13 @@ pub const configs = struct {
             .test_min => test_min,
         };
 
+        base.cluster.state_machine = if (@hasDecl(root, "decode_events"))
+            // TODO(DJ) This is a hack to work around the absense of tigerbeetle_build_options.
+            // This should be removed once the node client is built using `zig build`.
+            .accounting
+        else
+            @intToEnum(StateMachine, @enumToInt(build_options.config_cluster_state_machine));
+
         // TODO Use additional build options to overwrite other fields.
         base.process.tracer_backend = if (@hasDecl(root, "tracer_backend"))
             // TODO(jamii)

package/src/tigerbeetle/src/constants.zig

@@ -21,6 +21,12 @@ pub const tracer_backend = config.process.tracer_backend;
 /// The maximum number of replicas allowed in a cluster.
 pub const replicas_max = 6;
 
+pub const state_machine = config.cluster.state_machine;
+pub const StateMachineType = switch (config.cluster.state_machine) {
+    .accounting => @import("state_machine.zig").StateMachineType,
+    .testing => @import("test/state_machine.zig").StateMachineType,
+};
+
 /// The maximum number of clients allowed per cluster, where each client has a unique 128-bit ID.
 /// This impacts the amount of memory allocated at initialization by the server.
 /// This determines the size of the VR client table used to cache replies to clients by client ID.
@@ -289,8 +295,7 @@ comptime {
 /// * replicated storage overhead, since all data files are mirrored,
 /// * the size of the superblock storage zone, and
 /// * the static memory allocation required for tracking LSM forest metadata in memory.
-// TODO Remove, now that we have block_count_max.
-pub const size_max = config.cluster.size_max;
+pub const storage_size_max = config.cluster.storage_size_max;
 
 /// The unit of read/write access to LSM manifest and LSM table blocks in the block storage zone.
 ///
@@ -298,8 +303,6 @@ pub const size_max = config.cluster.size_max;
 /// - A higher block size increases space amplification due to partially-filled blocks.
 pub const block_size = config.cluster.block_size;
 
-pub const block_count_max = @divExact(16 * 1024 * 1024 * 1024 * 1024, block_size);
-
 comptime {
     assert(block_size % sector_size == 0);
     assert(lsm_table_size_max % sector_size == 0);
@@ -380,7 +383,7 @@ pub const clock_epoch_max_ms = config.process.clock_epoch_max_ms;
 
 /// The amount of time to wait for enough accurate samples before synchronizing the clock.
 /// The more samples we can take per remote clock source, the more accurate our estimation becomes.
-/// This impacts cluster startup time as the leader must first wait for synchronization to complete.
+/// This impacts cluster startup time as the primary must first wait for synchronization to complete.
 pub const clock_synchronization_window_min_ms = config.process.clock_synchronization_window_min_ms;
 
 /// The amount of time without agreement before the clock window is expired and a new window opened.

package/src/tigerbeetle/src/demo.zig

@@ -1,7 +1,7 @@
 const std = @import("std");
 const assert = std.debug.assert;
 
-const config = @import("constants.zig");
+const constants = @import("constants.zig");
 
 const tb = @import("tigerbeetle.zig");
 const Account = tb.Account;
@@ -16,7 +16,7 @@ const Storage = @import("storage.zig").Storage;
 const MessagePool = @import("message_pool.zig").MessagePool;
 const MessageBus = @import("message_bus.zig").MessageBusClient;
 const StateMachine = @import("state_machine.zig").StateMachineType(Storage, .{
-    .message_body_size_max = config.message_body_size_max,
+    .message_body_size_max = constants.message_body_size_max,
 });
 
 const vsr = @import("vsr.zig");
@@ -37,7 +37,7 @@ pub fn request(
     const allocator = std.heap.page_allocator;
     const client_id = std.crypto.random.int(u128);
     const cluster_id: u32 = 0;
-    var addresses = [_]std.net.Address{try std.net.Address.parseIp4("127.0.0.1", config.port)};
+    var addresses = [_]std.net.Address{try std.net.Address.parseIp4("127.0.0.1", constants.port)};
 
     var io = try IO.init(32, 0);
     defer io.deinit();
@@ -74,7 +74,7 @@ pub fn request(
 
     while (client.request_queue.count > 0) {
         client.tick();
-        try io.run_for_ns(config.tick_ms * std.time.ns_per_ms);
+        try io.run_for_ns(constants.tick_ms * std.time.ns_per_ms);
     }
 }
 

package/src/tigerbeetle/src/io/darwin.zig

@@ -4,7 +4,7 @@ const mem = std.mem;
 const assert = std.debug.assert;
 const log = std.log.scoped(.io);
 
-const config = @import("../constants.zig");
+const constants = @import("../constants.zig");
 const FIFO = @import("../fifo.zig").FIFO;
 const Time = @import("../time.zig").Time;
 const buffer_limit = @import("../io.zig").buffer_limit;
@@ -658,8 +658,8 @@ pub const IO = struct {
         must_create: bool,
     ) !os.fd_t {
         assert(relative_path.len > 0);
-        assert(size >= config.sector_size);
-        assert(size % config.sector_size == 0);
+        assert(size >= constants.sector_size);
+        assert(size % constants.sector_size == 0);
 
         // TODO Use O_EXCL when opening as a block device to obtain a mandatory exclusive lock.
         // This is much stronger than an advisory exclusive lock, and is required on some platforms.
@@ -694,7 +694,7 @@ pub const IO = struct {
 
         // On darwin assume that Direct I/O is always supported.
         // Use F_NOCACHE to disable the page cache as O_DIRECT doesn't exist.
-        if (config.direct_io) {
+        if (constants.direct_io) {
             _ = try os.fcntl(fd, os.F.NOCACHE, 1);
         }
 

package/src/tigerbeetle/src/io/linux.zig

@@ -7,7 +7,7 @@ const io_uring_cqe = linux.io_uring_cqe;
 const io_uring_sqe = linux.io_uring_sqe;
 const log = std.log.scoped(.io);
 
-const config = @import("../constants.zig");
+const constants = @import("../constants.zig");
 const FIFO = @import("../fifo.zig").FIFO;
 const buffer_limit = @import("../io.zig").buffer_limit;
 
@@ -905,8 +905,8 @@ pub const IO = struct {
         must_create: bool,
     ) !os.fd_t {
         assert(relative_path.len > 0);
-        assert(size >= config.sector_size);
-        assert(size % config.sector_size == 0);
+        assert(size >= constants.sector_size);
+        assert(size % constants.sector_size == 0);
 
         // TODO Use O_EXCL when opening as a block device to obtain a mandatory exclusive lock.
         // This is much stronger than an advisory exclusive lock, and is required on some platforms.
@@ -918,11 +918,11 @@ pub const IO = struct {
         if (@hasDecl(os.O, "LARGEFILE")) flags |= os.O.LARGEFILE;
 
         var direct_io_supported = false;
-        if (config.direct_io) {
+        if (constants.direct_io) {
             direct_io_supported = try fs_supports_direct_io(dir_fd);
             if (direct_io_supported) {
                 flags |= os.O.DIRECT;
-            } else if (!config.direct_io_required) {
+            } else if (!constants.direct_io_required) {
                 log.warn("file system does not support Direct I/O", .{});
             } else {
                 // We require Direct I/O for safety to handle fsync failure correctly, and therefore
@@ -968,7 +968,7 @@ pub const IO = struct {
                     log.warn("file system does not support fallocate(), an ENOSPC will panic", .{});
                     log.info("allocating by writing to the last sector of the file instead...", .{});
 
-                    const sector_size = config.sector_size;
+                    const sector_size = constants.sector_size;
                     const sector: [sector_size]u8 align(sector_size) = [_]u8{0} ** sector_size;
 
                     // Handle partial writes where the physical sector is less than a logical sector:

package/src/tigerbeetle/src/io/windows.zig

@@ -2,7 +2,7 @@ const std = @import("std");
 const os = std.os;
 const assert = std.debug.assert;
 const log = std.log.scoped(.io);
-const config = @import("../constants.zig");
+const constants = @import("../constants.zig");
 
 const FIFO = @import("../fifo.zig").FIFO;
 const Time = @import("../time.zig").Time;
@@ -941,8 +941,8 @@ pub const IO = struct {
         must_create: bool,
     ) !os.fd_t {
         assert(relative_path.len > 0);
-        assert(size >= config.sector_size);
-        assert(size % config.sector_size == 0);
+        assert(size >= constants.sector_size);
+        assert(size % constants.sector_size == 0);
 
         const path_w = try os.windows.sliceToPrefixedFileW(relative_path);
 
@@ -1013,7 +1013,7 @@ pub const IO = struct {
                 log.warn("file system failed to preallocate the file memory", .{});
                 log.info("allocating by writing to the last sector of the file instead...", .{});
 
-                const sector_size = config.sector_size;
+                const sector_size = constants.sector_size;
                 const sector: [sector_size]u8 align(sector_size) = [_]u8{0} ** sector_size;
 
                 // Handle partial writes where the physical sector is less than a logical sector:

package/src/tigerbeetle/src/lsm/compaction.zig

@@ -38,11 +38,11 @@ const assert = std.debug.assert;
 const log = std.log.scoped(.compaction);
 const tracer = @import("../tracer.zig");
 
-const config = @import("../constants.zig");
+const constants = @import("../constants.zig");
 
 const GridType = @import("grid.zig").GridType;
 const ManifestType = @import("manifest.zig").ManifestType;
-const KWayMergeIterator = @import("k_way_merge.zig").KWayMergeIterator;
+const MergeIteratorType = @import("merge_iterator.zig").MergeIteratorType;
 const TableIteratorType = @import("table_iterator.zig").TableIteratorType;
 const LevelIteratorType = @import("level_iterator.zig").LevelIteratorType;
 
@@ -51,8 +51,6 @@ pub fn CompactionType(
     comptime Storage: type,
     comptime IteratorAType: anytype,
 ) type {
-    const Key = Table.Key;
-    const Value = Table.Value;
     const tombstone = Table.tombstone;
 
     return struct {
@@ -73,47 +71,12 @@ pub fn CompactionType(
         const IteratorA = IteratorAType(Table, Storage);
         const IteratorB = LevelIteratorType(Table, Storage);
 
-        const k = 2;
-        const MergeIterator = KWayMergeIterator(
-            Compaction,
-            Table.Key,
-            Table.Value,
-            Table.key_from_value,
-            Table.compare_keys,
-            k,
-            MergeStreamSelector.peek,
-            MergeStreamSelector.pop,
-            MergeStreamSelector.precedence,
+        const MergeIterator = MergeIteratorType(
+            Table,
+            IteratorA,
+            IteratorB,
         );
 
-        const MergeStreamSelector = struct {
-            fn peek(compaction: *const Compaction, stream_id: u32) error{ Empty, Drained }!Key {
-                return switch (stream_id) {
-                    0 => compaction.iterator_a.peek(),
-                    1 => compaction.iterator_b.peek(),
-                    else => unreachable,
-                };
-            }
-
-            fn pop(compaction: *Compaction, stream_id: u32) Value {
-                return switch (stream_id) {
-                    0 => compaction.iterator_a.pop(),
-                    1 => compaction.iterator_b.pop(),
-                    else => unreachable,
-                };
-            }
-
-            /// Returns true if stream A has higher precedence than stream B.
-            /// This is used to deduplicate values across streams.
-            fn precedence(compaction: *const Compaction, stream_a: u32, stream_b: u32) bool {
-                _ = compaction;
-                assert(stream_a + stream_b == 1);
-
-                // All tables in iterator_a (stream=0) have a higher precedence.
-                return stream_a == 0;
-            }
-        };
-
         pub const Callback = fn (it: *Compaction) void;
 
         const Status = enum {
@@ -226,17 +189,17 @@ pub fn CompactionType(
             assert(!compaction.merge_done and compaction.merge_iterator == null);
             assert(compaction.tracer_slot == null);
 
-            assert(op_min % @divExact(config.lsm_batch_multiple, 2) == 0);
+            assert(op_min % @divExact(constants.lsm_batch_multiple, 2) == 0);
             assert(range.table_count > 0);
             if (table_a) |t| assert(t.visible(op_min));
 
-            assert(level_b < config.lsm_levels);
+            assert(level_b < constants.lsm_levels);
             assert((level_b == 0) == (table_a == null));
 
             // Levels may choose to drop tombstones if keys aren't included in the lower levels.
             // This invariant is always true for the last level as it doesn't have any lower ones.
             const drop_tombstones = manifest.compaction_must_drop_tombstones(level_b, range);
-            assert(drop_tombstones or level_b < config.lsm_levels - 1);
+            assert(drop_tombstones or level_b < constants.lsm_levels - 1);
 
             compaction.* = .{
                 .tree_name = compaction.tree_name,
@@ -440,7 +403,10 @@ pub fn CompactionType(
             // Create the merge iterator only when we can peek() from the read iterators.
             // This happens after IO for the first reads complete.
             if (compaction.merge_iterator == null) {
-                compaction.merge_iterator = MergeIterator.init(compaction, k, .ascending);
+                compaction.merge_iterator = MergeIterator.init(
+                    &compaction.iterator_a,
+                    &compaction.iterator_b,
+                );
                 assert(!compaction.merge_iterator.?.empty());
             }
 
@@ -625,11 +591,11 @@ pub fn CompactionType(
 }
 
 fn snapshot_max_for_table_input(op_min: u64) u64 {
-    assert(op_min % @divExact(config.lsm_batch_multiple, 2) == 0);
-    return op_min + @divExact(config.lsm_batch_multiple, 2) - 1;
+    assert(op_min % @divExact(constants.lsm_batch_multiple, 2) == 0);
+    return op_min + @divExact(constants.lsm_batch_multiple, 2) - 1;
 }
 
 fn snapshot_min_for_table_output(op_min: u64) u64 {
-    assert(op_min % @divExact(config.lsm_batch_multiple, 2) == 0);
-    return op_min + @divExact(config.lsm_batch_multiple, 2);
+    assert(op_min % @divExact(constants.lsm_batch_multiple, 2) == 0);
+    return op_min + @divExact(constants.lsm_batch_multiple, 2);
 }

package/src/tigerbeetle/src/lsm/forest.zig

@@ -4,11 +4,11 @@ const assert = std.debug.assert;
 const math = std.math;
 const mem = std.mem;
 
-const config = @import("../constants.zig");
+const constants = @import("../constants.zig");
 const vsr = @import("../vsr.zig");
 
 const GridType = @import("grid.zig").GridType;
-const NodePool = @import("node_pool.zig").NodePool(config.lsm_manifest_node_size, 16);
+const NodePool = @import("node_pool.zig").NodePool(constants.lsm_manifest_node_size, 16);
 
 pub fn ForestType(comptime Storage: type, comptime groove_config: anytype) type {
     var groove_fields: []const std.builtin.TypeInfo.StructField = &.{};