tigerbeetle-node 0.11.4 → 0.11.5

package/dist/.client.node.sha256

@@ -1 +1 @@
-17ba799be39b3aa1c55b37b39f013d58b0c9d8a5e3356aa750951d4c3cc7e248  dist/client.node
+004fa5f957fa7933ae697abff26d8e6879ebef4257a380594a24c92d285b07d8  dist/client.node

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tigerbeetle-node",
-  "version": "0.11.4",
+  "version": "0.11.5",
   "description": "TigerBeetle Node.js client",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/node.zig

@@ -14,13 +14,13 @@ const CreateTransfersResult = tb.CreateTransfersResult;
 
 const Storage = @import("tigerbeetle/src/storage.zig").Storage;
 const StateMachine = @import("tigerbeetle/src/state_machine.zig").StateMachineType(Storage, .{
-    .message_body_size_max = config.message_body_size_max,
+    .message_body_size_max = constants.message_body_size_max,
 });
 const Operation = StateMachine.Operation;
 const MessageBus = @import("tigerbeetle/src/message_bus.zig").MessageBusClient;
 const MessagePool = @import("tigerbeetle/src/message_pool.zig").MessagePool;
 const IO = @import("tigerbeetle/src/io.zig").IO;
-const config = @import("tigerbeetle/src/constants.zig");
+const constants = @import("tigerbeetle/src/constants.zig");
 
 const vsr = @import("tigerbeetle/src/vsr.zig");
 const Header = vsr.Header;
@@ -46,7 +46,7 @@ export fn napi_register_module_v1(env: c.napi_env, exports: c.napi_value) c.napi
         env,
         exports,
         "tick_ms",
-        config.tick_ms,
+        constants.tick_ms,
         "failed to add tick_ms to exports",
     ) catch return null;
 
@@ -145,7 +145,7 @@ const Context = struct {
         context.message_pool = try MessagePool.init(allocator, .client);
         errdefer context.message_pool.deinit(allocator);
 
-        context.addresses = try vsr.parse_addresses(allocator, addresses_raw, config.replicas_max);
+        context.addresses = try vsr.parse_addresses(allocator, addresses_raw, constants.replicas_max);
         errdefer allocator.free(context.addresses);
         assert(context.addresses.len > 0);
 
@@ -242,7 +242,7 @@ fn decode_events_from_array(
     if (array_length < 1) return translate.throw(env, "Batch must contain at least one event.");
 
     const body_length = @sizeOf(T) * array_length;
-    if (@sizeOf(Header) + body_length > config.message_size_max) {
+    if (@sizeOf(Header) + body_length > constants.message_size_max) {
         return translate.throw(env, "Batch is larger than the maximum message size.");
     }
 

package/src/tigerbeetle/src/benchmark.zig

@@ -1,7 +1,7 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const assert = std.debug.assert;
-const config = @import("constants.zig");
+const constants = @import("constants.zig");
 
 const log = std.log;
 pub const log_level: std.log.Level = .err;
@@ -14,7 +14,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 RingBuffer = @import("ring_buffer.zig").RingBuffer;
 
@@ -26,7 +26,7 @@ const tb = @import("tigerbeetle.zig");
 const batches_count = 100;
 
 const transfers_per_batch: u32 = @divExact(
-    config.message_size_max - @sizeOf(vsr.Header),
+    constants.message_size_max - @sizeOf(vsr.Header),
     @sizeOf(tb.Transfer),
 );
 comptime {
@@ -78,7 +78,7 @@ pub fn main() !void {
 
     const client_id = std.crypto.random.int(u128);
     const cluster_id: u32 = 0;
-    var address = [_]std.net.Address{try std.net.Address.parseIp4("127.0.0.1", config.port)};
+    var address = [_]std.net.Address{try std.net.Address.parseIp4("127.0.0.1", constants.port)};
 
     var io = try IO.init(32, 0);
     defer io.deinit();

package/src/tigerbeetle/src/c/tb_client/context.zig

@@ -2,7 +2,7 @@ const std = @import("std");
 const os = std.os;
 const assert = std.debug.assert;
 
-const config = @import("../../constants.zig");
+const constants = @import("../../constants.zig");
 const log = std.log.scoped(.tb_client_context);
 
 const util = @import("../../util.zig");
@@ -122,7 +122,7 @@ pub fn ContextType(
             context.addresses = vsr.parse_addresses(
                 context.allocator,
                 addresses,
-                config.replicas_max,
+                constants.replicas_max,
             ) catch |err| return switch (err) {
                 error.AddressLimitExceeded => error.AddressLimitExceeded,
                 else => error.AddressInvalid,
@@ -165,7 +165,7 @@ pub fn ContextType(
             );
             errdefer context.client.deinit(context.allocator);
 
-            context.messages_available = config.client_request_queue_max;
+            context.messages_available = constants.client_request_queue_max;
             context.on_completion_ctx = on_completion_ctx;
             context.on_completion_fn = on_completion_fn;
             context.implementation = .{
@@ -199,7 +199,7 @@ pub fn ContextType(
         pub fn run(self: *Context) void {
             while (!self.thread.signal.is_shutdown()) {
                 self.tick();
-                self.io.run_for_ns(config.tick_ms * std.time.ns_per_ms) catch |err| {
+                self.io.run_for_ns(constants.tick_ms * std.time.ns_per_ms) catch |err| {
                     log.err("{}: IO.run() failed: {s}", .{
                         self.client_id,
                         @errorName(err),
@@ -226,7 +226,7 @@ pub fn ContextType(
             }
 
             // Make sure the packet.data wouldn't overflow a message:
-            const writable = message.buffer[@sizeOf(Header)..][0..config.message_body_size_max];
+            const writable = message.buffer[@sizeOf(Header)..][0..constants.message_body_size_max];
             if (readable.len > writable.len) {
                 return self.on_complete(packet, error.TooMuchData);
             }
@@ -267,7 +267,7 @@ pub fn ContextType(
             result: PacketError![]const u8,
         ) void {
             self.messages_available += 1;
-            assert(self.messages_available <= config.client_request_queue_max);
+            assert(self.messages_available <= constants.client_request_queue_max);
 
             // Signal to resume sending requests that was waiting for available messages.
             if (self.messages_available == 1) self.thread.signal.notify();

package/src/tigerbeetle/src/c/tb_client/echo_client.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 Header = vsr.Header;
 
@@ -24,7 +24,7 @@ pub fn EchoClient(comptime StateMachine_: type, comptime MessageBus: type) type
             };
         };
 
-        request_queue: RingBuffer(Self.Request, config.client_request_queue_max, .array) = .{},
+        request_queue: RingBuffer(Self.Request, constants.client_request_queue_max, .array) = .{},
         message_pool: *MessagePool,
 
         pub fn init(

package/src/tigerbeetle/src/c/tb_client/thread.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
 const assert = std.debug.assert;
 
-const config = @import("../../constants.zig");
 const log = std.log.scoped(.tb_client_thread);
 
 const Packet = @import("packet.zig").Packet;

package/src/tigerbeetle/src/c/tb_client.zig

@@ -26,11 +26,11 @@ pub const tb_completion_t = fn (
     result_len: u32,
 ) callconv(.C) void;
 
-const config = @import("../constants.zig");
+const constants = @import("../constants.zig");
 const Storage = @import("../storage.zig").Storage;
 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 ContextType = @import("tb_client/context.zig").ContextType;

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,7 +7,7 @@ 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;
@@ -72,8 +72,8 @@ 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) {
@@ -206,17 +206,17 @@ 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,
                     ),
                     .path = path orelse fatal("required: <path>", .{}),
                 },
@@ -255,11 +255,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 => {
@@ -366,7 +366,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/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,7 +38,7 @@ 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;
@@ -226,17 +226,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,
@@ -625,11 +625,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 = &.{};

package/src/tigerbeetle/src/lsm/forest_fuzz.zig

@@ -3,7 +3,7 @@ const testing = std.testing;
 const allocator = testing.allocator;
 const assert = std.debug.assert;
 
-const config = @import("../constants.zig");
+const constants = @import("../constants.zig");
 const fuzz = @import("../test/fuzz.zig");
 const vsr = @import("../vsr.zig");
 
@@ -15,7 +15,7 @@ const Transfer = @import("../tigerbeetle.zig").Transfer;
 const Account = @import("../tigerbeetle.zig").Account;
 const Storage = @import("../test/storage.zig").Storage;
 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 GridType = @import("grid.zig").GridType;
@@ -63,8 +63,8 @@ const Environment = struct {
 
     const compacts_per_checkpoint = std.math.divCeil(
         usize,
-        config.journal_slot_count,
-        config.lsm_batch_multiple,
+        constants.journal_slot_count,
+        constants.lsm_batch_multiple,
     ) catch unreachable;
 
     const State = enum {
@@ -193,7 +193,7 @@ const Environment = struct {
     }
 
     pub fn checkpoint(env: *Environment, op: u64) void {
-        env.checkpoint_op = op - config.lsm_batch_multiple;
+        env.checkpoint_op = op - constants.lsm_batch_multiple;
         env.change_state(.forest_open, .forest_checkpointing);
         env.forest.checkpoint(forest_checkpoint_callback);
         env.tick_until_state_change(.forest_checkpointing, .superblock_checkpointing);
@@ -320,9 +320,9 @@ pub fn generate_fuzz_ops(random: std.rand.Random, fuzz_op_count: usize) ![]const
         // Maybe compact more often than forced to by `puts_since_compact`.
         .compact = if (random.boolean()) 0 else 1,
         // Always do puts, and always more puts than removes.
-        .put_account = config.lsm_batch_multiple * 2,
+        .put_account = constants.lsm_batch_multiple * 2,
         // Maybe do some gets.
-        .get_account = if (random.boolean()) 0 else config.lsm_batch_multiple,
+        .get_account = if (random.boolean()) 0 else constants.lsm_batch_multiple,
     };
     log.info("fuzz_op_distribution = {d:.2}", .{fuzz_op_distribution});
 
@@ -347,8 +347,8 @@ pub fn generate_fuzz_ops(random: std.rand.Random, fuzz_op_count: usize) ![]const
                 op += 1;
                 const checkpoint =
                     // Can only checkpoint on the last beat of the bar.
-                    compact_op % config.lsm_batch_multiple == config.lsm_batch_multiple - 1 and
-                    compact_op > config.lsm_batch_multiple and
+                    compact_op % constants.lsm_batch_multiple == constants.lsm_batch_multiple - 1 and
+                    compact_op > constants.lsm_batch_multiple and
                     // Checkpoint at roughly the same rate as log wraparound.
                     random.uintLessThan(usize, Environment.compacts_per_checkpoint) == 0;
                 break :compact FuzzOp{

package/src/tigerbeetle/src/lsm/grid.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 free_set = @import("../vsr/superblock_free_set.zig");
 
@@ -41,7 +41,7 @@ pub const BlockType = enum(u8) {
 ///
 /// Recently/frequently-used blocks are transparently cached in memory.
 pub fn GridType(comptime Storage: type) type {
-    const block_size = config.block_size;
+    const block_size = constants.block_size;
     const SuperBlock = SuperBlockType(Storage);
 
     const cache_interface = struct {
@@ -72,7 +72,7 @@ pub fn GridType(comptime Storage: type) type {
         cache_interface.equal_addresses,
         .{
             .ways = set_associative_cache_ways,
-            .value_alignment = config.sector_size,
+            .value_alignment = constants.sector_size,
         },
     );
 
@@ -90,8 +90,8 @@ pub fn GridType(comptime Storage: type) type {
         // TODO put more thought into how low/high this limit should be.
         pub const write_iops_max = 16;
 
-        pub const BlockPtr = *align(config.sector_size) [block_size]u8;
-        pub const BlockPtrConst = *align(config.sector_size) const [block_size]u8;
+        pub const BlockPtr = *align(constants.sector_size) [block_size]u8;
+        pub const BlockPtrConst = *align(constants.sector_size) const [block_size]u8;
         pub const Reservation = free_set.Reservation;
 
         pub const Write = struct {

package/src/tigerbeetle/src/lsm/groove.zig

@@ -4,13 +4,13 @@ const assert = std.debug.assert;
 const math = std.math;
 const mem = std.mem;
 
-const config = @import("../constants.zig");
+const constants = @import("../constants.zig");
 
 const TableType = @import("table.zig").TableType;
 const TreeType = @import("tree.zig").TreeType;
 const GridType = @import("grid.zig").GridType;
 const CompositeKey = @import("composite_key.zig").CompositeKey;
-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);
 
 const snapshot_latest = @import("tree.zig").snapshot_latest;
 const compaction_snapshot_for_op = @import("tree.zig").compaction_snapshot_for_op;
@@ -655,7 +655,7 @@ pub fn GrooveType(
                     assert(!id_tree_value.tombstone());
                     lookup_id_callback(&worker.lookup_id, id_tree_value);
 
-                    if (config.verify) {
+                    if (constants.verify) {
                         // If the id is cached, then we must be prefetching it because the object
                         // was not also cached.
                         assert(worker.context.groove.objects.lookup_from_memory(
@@ -682,7 +682,7 @@ pub fn GrooveType(
                 const worker = @fieldParentPtr(PrefetchWorker, "lookup_id", completion);
 
                 if (result) |id_tree_value| {
-                    if (config.verify) {
+                    if (constants.verify) {
                         // This was checked in prefetch_enqueue().
                         assert(
                             worker.context.groove.ids.lookup_from_memory(