tigerbeetle-node 0.14.157 → 0.14.159

package/src/node.zig

@@ -1,9 +1,13 @@
 const std = @import("std");
 const assert = std.debug.assert;
+const allocator = std.heap.c_allocator;
 
 const c = @import("c.zig");
 const translate = @import("translate.zig");
-const tb = @import("../../../tigerbeetle.zig");
+const tb = struct {
+    pub usingnamespace @import("../../../tigerbeetle.zig");
+    pub usingnamespace @import("../../c/tb_client.zig");
+};
 
 const Account = tb.Account;
 const AccountFlags = tb.AccountFlags;
@@ -15,783 +19,472 @@ const CreateTransfersResult = tb.CreateTransfersResult;
 const Storage = @import("../../../storage.zig").Storage;
 const StateMachine = @import("../../../state_machine.zig").StateMachineType(Storage, constants.state_machine_config);
 const Operation = StateMachine.Operation;
-const MessageBus = @import("../../../message_bus.zig").MessageBusClient;
-const MessagePool = @import("../../../message_pool.zig").MessagePool;
-const IO = @import("../../../io.zig").IO;
 const constants = @import("../../../constants.zig");
-
 const vsr = @import("../../../vsr.zig");
-const Header = vsr.Header;
-const Client = vsr.Client(StateMachine, MessageBus);
 
 pub const std_options = struct {
     // Since this is running in application space, log only critical messages to reduce noise.
     pub const log_level: std.log.Level = .err;
 };
 
+// Cached value for JS (null).
+var napi_null: c.napi_value = undefined;
+
 /// N-API will call this constructor automatically to register the module.
 export fn napi_register_module_v1(env: c.napi_env, exports: c.napi_value) c.napi_value {
+    napi_null = translate.capture_null(env) catch return null;
+
     translate.register_function(env, exports, "init", init) catch return null;
     translate.register_function(env, exports, "deinit", deinit) catch return null;
-    translate.register_function(env, exports, "request", request) catch return null;
-    translate.register_function(env, exports, "raw_request", raw_request) catch return null;
-    translate.register_function(env, exports, "tick", tick) catch return null;
+    translate.register_function(env, exports, "submit", submit) catch return null;
+    return exports;
+}
 
-    translate.u32_into_object(
+// Add-on code
+
+fn init(env: c.napi_env, info: c.napi_callback_info) callconv(.C) c.napi_value {
+    const args = translate.extract_args(env, info, .{
+        .count = 1,
+        .function = "init",
+    }) catch return null;
+
+    const cluster = translate.u32_from_object(env, args[0], "cluster_id") catch return null;
+    const concurrency = translate.u32_from_object(env, args[0], "concurrency") catch return null;
+    const addresses = translate.slice_from_object(
         env,
-        exports,
-        "tick_ms",
-        constants.tick_ms,
-        "failed to add tick_ms to exports",
+        args[0],
+        "replica_addresses",
     ) catch return null;
 
-    const allocator = std.heap.c_allocator;
-    var global = Globals.init(allocator, env) catch {
-        std.log.err("Failed to initialise environment.\n", .{});
-        return null;
-    };
-    errdefer global.deinit();
-
-    // Tie the global state to this Node.js environment. This allows us to be thread safe.
-    // See https://nodejs.org/api/n-api.html#n_api_environment_life_cycle_apis.
-    // A cleanup function is registered as well that Node will call when the environment
-    // is torn down. Be careful not to call this function again as it will overwrite the global
-    // state.
-    translate.set_instance_data(
-        env,
-        @ptrCast(@alignCast(global)),
-        Globals.destroy,
-    ) catch {
-        global.deinit();
-        return null;
-    };
+    return create(env, cluster, concurrency, addresses) catch null;
+}
 
-    return exports;
+fn deinit(env: c.napi_env, info: c.napi_callback_info) callconv(.C) c.napi_value {
+    const args = translate.extract_args(env, info, .{
+        .count = 1,
+        .function = "deinit",
+    }) catch return null;
+
+    destroy(env, args[0]) catch {};
+    return null;
 }
 
-const Globals = struct {
-    allocator: std.mem.Allocator,
-    io: IO,
-    napi_undefined: c.napi_value,
-
-    pub fn init(allocator: std.mem.Allocator, env: c.napi_env) !*Globals {
-        const self = try allocator.create(Globals);
-        errdefer allocator.destroy(self);
-
-        self.allocator = allocator;
-
-        // Be careful to size the SQ ring to only a few SQE entries and to share a single IO
-        // instance across multiple clients to stay under kernel limits:
-        //
-        // The memory required by io_uring is accounted under the rlimit memlocked option, which can
-        // be quite low on some setups (64K). The default is usually enough for most use cases, but
-        // bigger rings or things like registered buffers deplete it quickly. Root isn't under this
-        // restriction, but regular users are.
-        //
-        // Check `/etc/security/limits.conf` for user settings, or `/etc/systemd/user.conf` and
-        // `/etc/systemd/system.conf` for systemd setups.
-        self.io = IO.init(32, 0) catch {
-            return translate.throw(env, "Failed to initialize io_uring");
-        };
-        errdefer self.io.deinit();
-
-        if (c.napi_get_undefined(env, &self.napi_undefined) != c.napi_ok) {
-            return translate.throw(env, "Failed to capture the value of \"undefined\".");
-        }
+fn submit(env: c.napi_env, info: c.napi_callback_info) callconv(.C) c.napi_value {
+    const args = translate.extract_args(env, info, .{
+        .count = 4,
+        .function = "submit",
+    }) catch return null;
 
-        return self;
+    const operation_int = translate.u32_from_value(env, args[1], "operation") catch return null;
+    if (!@as(vsr.Operation, @enumFromInt(operation_int)).valid(StateMachine)) {
+        translate.throw(env, "Unknown operation.") catch return null;
     }
 
-    pub fn deinit(self: *Globals) void {
-        self.io.deinit();
-        self.allocator.destroy(self);
+    var is_array: bool = undefined;
+    if (c.napi_is_array(env, args[2], &is_array) != c.napi_ok) {
+        translate.throw(env, "Failed to check array argument type.") catch return null;
+    }
+    if (!is_array) {
+        translate.throw(env, "Array argument must be an [object Array].") catch return null;
     }
 
-    pub fn destroy(env: c.napi_env, data: ?*anyopaque, hint: ?*anyopaque) callconv(.C) void {
-        _ = env;
-        _ = hint;
-
-        const self = globalsCast(data.?);
-        self.deinit();
+    var callback_type: c.napi_valuetype = undefined;
+    if (c.napi_typeof(env, args[3], &callback_type) != c.napi_ok) {
+        translate.throw(env, "Failed to check callback argument type.") catch return null;
+    }
+    if (callback_type != c.napi_function) {
+        translate.throw(env, "Callback argument must be a Function.") catch return null;
     }
-};
 
-fn globalsCast(globals_raw: *anyopaque) *Globals {
-    return @ptrCast(@alignCast(globals_raw));
+    request(
+        env,
+        args[0], // tb_client
+        @enumFromInt(@as(u8, @intCast(operation_int))),
+        args[2], // request array
+        args[3], // callback
+    ) catch {};
+    return null;
 }
 
-const Context = struct {
-    io: *IO,
-    addresses: []std.net.Address,
-    client: Client,
-    message_pool: MessagePool,
-
-    fn create(
-        env: c.napi_env,
-        allocator: std.mem.Allocator,
-        io: *IO,
-        cluster: u32,
-        addresses_raw: []const u8,
-    ) !c.napi_value {
-        const context = try allocator.create(Context);
-        errdefer allocator.destroy(context);
-
-        context.io = io;
-        context.message_pool = try MessagePool.init(allocator, .client);
-        errdefer context.message_pool.deinit(allocator);
-
-        context.addresses = try vsr.parse_addresses(allocator, addresses_raw, constants.replicas_max);
-        errdefer allocator.free(context.addresses);
-        assert(context.addresses.len > 0);
-
-        const client_id = std.crypto.random.int(u128);
-        context.client = try Client.init(
-            allocator,
-            client_id,
-            cluster,
-            @as(u8, @intCast(context.addresses.len)),
-            &context.message_pool,
-            .{
-                .configuration = context.addresses,
-                .io = context.io,
-            },
-        );
-        errdefer context.client.deinit(allocator);
+// tb_client Logic
 
-        return try translate.create_external(env, context);
+fn create(env: c.napi_env, cluster_id: u32, concurrency: u32, addresses: []const u8) !c.napi_value {
+    var tsfn_name: c.napi_value = undefined;
+    if (c.napi_create_string_utf8(env, "tb_client", c.NAPI_AUTO_LENGTH, &tsfn_name) != c.napi_ok) {
+        return translate.throw(env, "Failed to create resource name for thread-safe function.");
     }
-};
 
-fn contextCast(context_raw: *anyopaque) !*Context {
-    return @ptrCast(@alignCast(context_raw));
-}
-
-fn validate_timestamp(env: c.napi_env, object: c.napi_value) !u64 {
-    const timestamp = try translate.u64_from_object(env, object, "timestamp");
-    if (timestamp != 0) {
-        return translate.throw(
-            env,
-            "Timestamp should be set as 0 as this will be set correctly by the Server.",
-        );
+    var completion_tsfn: c.napi_threadsafe_function = undefined;
+    if (c.napi_create_threadsafe_function(
+        env,
+        null, // No javascript function to call directly from here.
+        null, // No async resource.
+        tsfn_name,
+        0, // Max queue size of 0 means no limit.
+        1, // Number of acquires/threads that will be calling this TSFN.
+        null, // No finalization data.
+        null, // No finalization callback.
+        null, // No custom context.
+        on_completion_js, // Function to call on JS thread when TSFN is called.
+        &completion_tsfn, // TSFN out handle.
+    ) != c.napi_ok) {
+        return translate.throw(env, "Failed to create thread-safe function.");
     }
+    errdefer if (c.napi_release_threadsafe_function(
+        completion_tsfn,
+        c.napi_tsfn_abort,
+    ) != c.napi_ok) {
+        std.log.warn("Failed to release allocated thread-safe function on error.", .{});
+    };
 
-    return timestamp;
-}
+    if (c.napi_acquire_threadsafe_function(completion_tsfn) != c.napi_ok) {
+        return translate.throw(env, "Failed to acquire reference to thread-safe function.");
+    }
 
-fn decode_from_object(comptime T: type, env: c.napi_env, object: c.napi_value) !T {
-    return switch (T) {
-        Transfer => Transfer{
-            .id = try translate.u128_from_object(env, object, "id"),
-            .debit_account_id = try translate.u128_from_object(env, object, "debit_account_id"),
-            .credit_account_id = try translate.u128_from_object(env, object, "credit_account_id"),
-            .amount = try translate.u128_from_object(env, object, "amount"),
-            .pending_id = try translate.u128_from_object(env, object, "pending_id"),
-            .user_data_128 = try translate.u128_from_object(env, object, "user_data_128"),
-            .user_data_64 = try translate.u64_from_object(env, object, "user_data_64"),
-            .user_data_32 = try translate.u32_from_object(env, object, "user_data_32"),
-            .timeout = try translate.u32_from_object(env, object, "timeout"),
-            .ledger = try translate.u32_from_object(env, object, "ledger"),
-            .code = try translate.u16_from_object(env, object, "code"),
-            .flags = @as(TransferFlags, @bitCast(try translate.u16_from_object(env, object, "flags"))),
-            .timestamp = try validate_timestamp(env, object),
-        },
-        Account => Account{
-            .id = try translate.u128_from_object(env, object, "id"),
-            .debits_pending = try translate.u128_from_object(env, object, "debits_pending"),
-            .debits_posted = try translate.u128_from_object(env, object, "debits_posted"),
-            .credits_pending = try translate.u128_from_object(env, object, "credits_pending"),
-            .credits_posted = try translate.u128_from_object(env, object, "credits_posted"),
-            .user_data_128 = try translate.u128_from_object(env, object, "user_data_128"),
-            .user_data_64 = try translate.u64_from_object(env, object, "user_data_64"),
-            .user_data_32 = try translate.u32_from_object(env, object, "user_data_32"),
-            .reserved = try translate.u32_from_object(env, object, "reserved"),
-            .ledger = try translate.u32_from_object(env, object, "ledger"),
-            .code = try translate.u16_from_object(env, object, "code"),
-            .flags = @bitCast(try translate.u16_from_object(env, object, "flags")),
-            .timestamp = try validate_timestamp(env, object),
-        },
-        u128 => try translate.u128_from_value(env, object, "lookup"),
-        else => unreachable,
+    const client = tb.init(
+        allocator,
+        cluster_id,
+        addresses,
+        concurrency,
+        @intFromPtr(completion_tsfn),
+        on_completion,
+    ) catch |err| switch (err) {
+        error.OutOfMemory => return translate.throw(env, "Failed to allocate memory for Client."),
+        error.Unexpected => return translate.throw(env, "Unexpected error occured on Client."),
+        error.AddressInvalid => return translate.throw(env, "Invalid replica address."),
+        error.AddressLimitExceeded => return translate.throw(env, "Too many replica addresses."),
+        error.ConcurrencyMaxInvalid => return translate.throw(env, "Concurrency is too high."),
+        error.SystemResources => return translate.throw(env, "Failed to reserve system resources."),
+        error.NetworkSubsystemFailed => return translate.throw(env, "Network stack failure."),
     };
-}
+    errdefer tb.deinit(client);
 
-pub fn decode_events(
-    env: c.napi_env,
-    array: c.napi_value,
-    operation: Operation,
-    output: []u8,
-) !usize {
-    return switch (operation) {
-        .create_accounts => try decode_events_from_array(env, array, Account, output),
-        .create_transfers => try decode_events_from_array(env, array, Transfer, output),
-        .lookup_accounts => try decode_events_from_array(env, array, u128, output),
-        .lookup_transfers => try decode_events_from_array(env, array, u128, output),
-    };
+    return try translate.create_external(env, client);
 }
 
-fn decode_events_from_array(
-    env: c.napi_env,
-    array: c.napi_value,
-    comptime T: type,
-    output: []u8,
-) !usize {
-    const array_length = try translate.array_length(env, 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 > constants.message_size_max) {
-        return translate.throw(env, "Batch is larger than the maximum message size.");
-    }
+fn destroy(env: c.napi_env, context: c.napi_value) !void {
+    const client_ptr = try translate.value_external(
+        env,
+        context,
+        "Failed to get client context pointer.",
+    );
+    const client: tb.tb_client_t = @ptrCast(@alignCast(client_ptr.?));
+    defer tb.deinit(client);
 
-    // We take a slice on `output` to ensure that its length is a multiple of @sizeOf(T) to prevent
-    // a safety-checked runtime panic from `bytesAsSlice` for non-multiple sizes.
-    var results = std.mem.bytesAsSlice(T, output[0..body_length]);
+    const completion_ctx = tb.completion_context(client);
+    const completion_tsfn: c.napi_threadsafe_function = @ptrFromInt(completion_ctx);
 
-    var i: u32 = 0;
-    while (i < array_length) : (i += 1) {
-        const entry = try translate.array_element(env, array, i);
-        results[i] = try decode_from_object(T, env, entry);
+    if (c.napi_release_threadsafe_function(completion_tsfn, c.napi_tsfn_abort) != c.napi_ok) {
+        return translate.throw(env, "Failed to release allocated thread-safe function on error.");
     }
-
-    return body_length;
 }
 
-fn encode_napi_results_array(
-    comptime Result: type,
+fn request(
     env: c.napi_env,
-    data: []const u8,
-) !c.napi_value {
-    const results = std.mem.bytesAsSlice(Result, data);
-    const napi_array = try translate.create_array(
+    context: c.napi_value,
+    operation: Operation,
+    array: c.napi_value,
+    callback: c.napi_value,
+) !void {
+    const client_ptr = try translate.value_external(
         env,
-        @as(u32, @intCast(results.len)),
-        "Failed to allocate array for results.",
+        context,
+        "Failed to get client context pointer.",
     );
+    const client: tb.tb_client_t = @ptrCast(@alignCast(client_ptr.?));
+
+    const packet = blk: {
+        var packet_ptr: ?*tb.tb_packet_t = undefined;
+        switch (tb.acquire_packet(client, &packet_ptr)) {
+            .ok => break :blk packet_ptr.?,
+            .shutdown => return translate.throw(env, "Client was shutdown."),
+            .concurrency_max_exceeded => return translate.throw(env, "Too many concurrent requests."),
+        }
+    };
+    errdefer tb.release_packet(client, packet);
 
-    switch (Result) {
-        CreateAccountsResult, CreateTransfersResult => {
-            var i: u32 = 0;
-            while (i < results.len) : (i += 1) {
-                const result = results[i];
-                const napi_object = try translate.create_object(
-                    env,
-                    "Failed to create result object",
-                );
-
-                try translate.u32_into_object(
-                    env,
-                    napi_object,
-                    "index",
-                    result.index,
-                    "Failed to set property \"index\" of result.",
-                );
-
-                try translate.u32_into_object(
-                    env,
-                    napi_object,
-                    "result",
-                    @intFromEnum(result.result),
-                    "Failed to set property \"result\" of result.",
-                );
-
-                try translate.set_array_element(
-                    env,
-                    napi_array,
-                    i,
-                    napi_object,
-                    "Failed to set element in results array.",
-                );
-            }
-        },
-        Account => {
-            var i: u32 = 0;
-            while (i < results.len) : (i += 1) {
-                const result = results[i];
-                const napi_object = try translate.create_object(
-                    env,
-                    "Failed to create account lookup result object.",
-                );
-
-                try translate.u128_into_object(
-                    env,
-                    napi_object,
-                    "id",
-                    result.id,
-                    "Failed to set property \"id\" of account lookup result.",
-                );
-
-                try translate.u128_into_object(
-                    env,
-                    napi_object,
-                    "debits_pending",
-                    result.debits_pending,
-                    "Failed to set property \"debits_pending\" of account lookup result.",
-                );
-
-                try translate.u128_into_object(
-                    env,
-                    napi_object,
-                    "debits_posted",
-                    result.debits_posted,
-                    "Failed to set property \"debits_posted\" of account lookup result.",
-                );
-
-                try translate.u128_into_object(
-                    env,
-                    napi_object,
-                    "credits_pending",
-                    result.credits_pending,
-                    "Failed to set property \"credits_pending\" of account lookup result.",
-                );
-
-                try translate.u128_into_object(
-                    env,
-                    napi_object,
-                    "credits_posted",
-                    result.credits_posted,
-                    "Failed to set property \"credits_posted\" of account lookup result.",
-                );
-
-                try translate.u128_into_object(
-                    env,
-                    napi_object,
-                    "user_data_128",
-                    result.user_data_128,
-                    "Failed to set property \"user_data_128\" of account lookup result.",
-                );
-
-                try translate.u64_into_object(
-                    env,
-                    napi_object,
-                    "user_data_64",
-                    result.user_data_64,
-                    "Failed to set property \"user_data_64\" of account lookup result.",
-                );
-
-                try translate.u32_into_object(
-                    env,
-                    napi_object,
-                    "user_data_32",
-                    result.user_data_32,
-                    "Failed to set property \"user_data_32\" of account lookup result.",
-                );
-
-                try translate.u32_into_object(
-                    env,
-                    napi_object,
-                    "reserved",
-                    result.reserved,
-                    "Failed to set property \"reserved\" of account lookup result.",
-                );
-
-                try translate.u32_into_object(
-                    env,
-                    napi_object,
-                    "ledger",
-                    @as(u32, @intCast(result.ledger)),
-                    "Failed to set property \"ledger\" of account lookup result.",
-                );
-
-                try translate.u16_into_object(
-                    env,
-                    napi_object,
-                    "code",
-                    @as(u16, @intCast(result.code)),
-                    "Failed to set property \"code\" of account lookup result.",
-                );
-
-                try translate.u16_into_object(
-                    env,
-                    napi_object,
-                    "flags",
-                    @as(u16, @bitCast(result.flags)),
-                    "Failed to set property \"flags\" of account lookup result.",
-                );
-
-                try translate.u64_into_object(
-                    env,
-                    napi_object,
-                    "timestamp",
-                    result.timestamp,
-                    "Failed to set property \"timestamp\" of account lookup result.",
-                );
-
-                try translate.set_array_element(
-                    env,
-                    napi_array,
-                    i,
-                    napi_object,
-                    "Failed to set element in results array.",
-                );
-            }
-        },
-        Transfer => {
-            var i: u32 = 0;
-            while (i < results.len) : (i += 1) {
-                const result = results[i];
-                const napi_object = try translate.create_object(
-                    env,
-                    "Failed to create transfer lookup result object.",
-                );
-
-                try translate.u128_into_object(
-                    env,
-                    napi_object,
-                    "id",
-                    result.id,
-                    "Failed to set property \"id\" of transfer lookup result.",
-                );
-
-                try translate.u128_into_object(
-                    env,
-                    napi_object,
-                    "debit_account_id",
-                    result.debit_account_id,
-                    "Failed to set property \"debit_account_id\" of transfer lookup result.",
-                );
-
-                try translate.u128_into_object(
-                    env,
-                    napi_object,
-                    "credit_account_id",
-                    result.credit_account_id,
-                    "Failed to set property \"credit_account_id\" of transfer lookup result.",
-                );
-
-                try translate.u128_into_object(
-                    env,
-                    napi_object,
-                    "amount",
-                    result.amount,
-                    "Failed to set property \"amount\" of transfer lookup result.",
-                );
-
-                try translate.u128_into_object(
-                    env,
-                    napi_object,
-                    "pending_id",
-                    result.pending_id,
-                    "Failed to set property \"pending_id\" of transfer lookup result.",
-                );
-
-                try translate.u128_into_object(
-                    env,
-                    napi_object,
-                    "user_data_128",
-                    result.user_data_128,
-                    "Failed to set property \"user_data_128\" of transfer lookup result.",
-                );
-
-                try translate.u64_into_object(
-                    env,
-                    napi_object,
-                    "user_data_64",
-                    result.user_data_64,
-                    "Failed to set property \"user_data_64\" of transfer lookup result.",
-                );
-
-                try translate.u32_into_object(
-                    env,
-                    napi_object,
-                    "user_data_32",
-                    result.user_data_32,
-                    "Failed to set property \"user_data_32\" of transfer lookup result.",
-                );
-
-                try translate.u32_into_object(
-                    env,
-                    napi_object,
-                    "timeout",
-                    result.timeout,
-                    "Failed to set property \"timeout\" of transfer lookup result.",
-                );
-
-                try translate.u32_into_object(
-                    env,
-                    napi_object,
-                    "ledger",
-                    @as(u32, @intCast(result.ledger)),
-                    "Failed to set property \"ledger\" of transfer lookup result.",
-                );
-
-                try translate.u16_into_object(
-                    env,
-                    napi_object,
-                    "code",
-                    @as(u16, @intCast(result.code)),
-                    "Failed to set property \"code\" of transfer lookup result.",
-                );
-
-                try translate.u16_into_object(
-                    env,
-                    napi_object,
-                    "flags",
-                    @as(u16, @bitCast(result.flags)),
-                    "Failed to set property \"flags\" of transfer lookup result.",
-                );
-
-                try translate.u64_into_object(
-                    env,
-                    napi_object,
-                    "timestamp",
-                    result.timestamp,
-                    "Failed to set property \"timestamp\" of transfer lookup result.",
-                );
-
-                try translate.set_array_element(
-                    env,
-                    napi_array,
-                    i,
-                    napi_object,
-                    "Failed to set element in results array.",
-                );
-            }
-        },
-        else => unreachable,
+    // Create a reference to the callback so it stay alive until the packet completes.
+    var callback_ref: c.napi_ref = undefined;
+    if (c.napi_create_reference(env, callback, 1, &callback_ref) != c.napi_ok) {
+        return translate.throw(env, "Failed to create reference to callback.");
     }
+    errdefer translate.delete_reference(env, callback_ref) catch {
+        std.log.warn("Failed to delete reference to callback on error.", .{});
+    };
 
-    return napi_array;
-}
-
-/// Add-on code
-fn init(env: c.napi_env, info: c.napi_callback_info) callconv(.C) c.napi_value {
-    var argc: usize = 1;
-    var argv: [1]c.napi_value = undefined;
-    if (c.napi_get_cb_info(env, info, &argc, &argv, null, null) != c.napi_ok) {
-        translate.throw(env, "Failed to get args.") catch return null;
+    const array_length = try translate.array_length(env, array);
+    if (array_length < 1) {
+        return translate.throw(env, "Batch must contain at least one event.");
     }
-    if (argc != 1) translate.throw(
-        env,
-        "Function init() must receive 1 argument exactly.",
-    ) catch return null;
-
-    const cluster = translate.u32_from_object(env, argv[0], "cluster_id") catch return null;
-    const addresses = translate.slice_from_object(
-        env,
-        argv[0],
-        "replica_addresses",
-    ) catch return null;
 
-    const allocator = std.heap.c_allocator;
+    const packet_data = switch (operation) {
+        inline else => |op| blk: {
+            const buffer = try BufferType(op).alloc(env, array_length);
+            errdefer buffer.free();
 
-    const globals_raw = translate.globals(env) catch return null;
-    const globals = globalsCast(globals_raw.?);
+            const events = buffer.events();
+            try decode_array(StateMachine.Event(op), env, array, events);
+            break :blk std.mem.sliceAsBytes(events);
+        },
+    };
 
-    const context = Context.create(env, allocator, &globals.io, cluster, addresses) catch {
-        // TODO: switch on err and provide more detailed messages
-        translate.throw(env, "Failed to initialize Client.") catch return null;
+    packet.* = .{
+        .next = null,
+        .user_data = callback_ref,
+        .operation = @intFromEnum(operation),
+        .status = .ok,
+        .data_size = @intCast(packet_data.len),
+        .data = packet_data.ptr,
     };
 
-    return context;
+    tb.submit(client, packet);
 }
 
-/// This function decodes and validates an array of Node objects, one-by-one, directly into an
-/// available message before requesting the client to send it.
-fn request(env: c.napi_env, info: c.napi_callback_info) callconv(.C) c.napi_value {
-    var argc: usize = 4;
-    var argv: [4]c.napi_value = undefined;
-    if (c.napi_get_cb_info(env, info, &argc, &argv, null, null) != c.napi_ok) {
-        translate.throw(env, "Failed to get args.") catch return null;
-    }
-
-    if (argc != 4) translate.throw(
-        env,
-        "Function request() requires 4 arguments exactly.",
-    ) catch return null;
-
-    const context_raw = translate.value_external(
-        env,
-        argv[0],
-        "Failed to get Client Context pointer.",
-    ) catch return null;
-    const context = contextCast(context_raw.?) catch return null;
-    const operation_int = translate.u32_from_value(env, argv[1], "operation") catch return null;
-
-    if (!@as(vsr.Operation, @enumFromInt(operation_int)).valid(StateMachine)) {
-        translate.throw(env, "Unknown operation.") catch return null;
-    }
+// Packet only has one size field which normally tracks `BufferType(op).events().len`.
+// However, completion of the packet can write results.len < `BufferType(op).results().len`.
+// Therefore, we stuff both `BufferType(op).count` and results.len into the packet's size field.
+// Storing both allows reconstruction of `BufferType(op)` while knowing how many results completed.
+const BufferSize = packed struct(u32) {
+    event_count: u16,
+    result_count: u16,
+};
 
-    if (context.client.messages_available == 0) {
-        translate.throw(
-            env,
-            "Too many outstanding requests - message pool exhausted.",
-        ) catch return null;
+fn on_completion(
+    completion_ctx: usize,
+    client: tb.tb_client_t,
+    packet: *tb.tb_packet_t,
+    result_ptr: ?[*]const u8,
+    result_len: u32,
+) callconv(.C) void {
+    switch (packet.status) {
+        .ok => {},
+        .too_much_data => unreachable, // We limit packet data size during request().
+        .invalid_operation => unreachable, // We check the operation during request().
+        .invalid_data_size => unreachable, // We set correct data size during request().
     }
-    const message = context.client.get_message();
-    errdefer context.client.release(message);
-
-    const operation = @as(Operation, @enumFromInt(@as(u8, @intCast(operation_int))));
-    const body_length = decode_events(
-        env,
-        argv[2],
-        operation,
-        message.buffer[@sizeOf(Header)..],
-    ) catch |err| switch (err) {
-        error.ExceptionThrown => return null,
-    };
-
-    // This will create a reference (in V8) to the user's JS callback that we must eventually also
-    // free in order to avoid a leak. We therefore do this last to ensure we cannot fail after
-    // taking this reference.
-    const user_data = translate.user_data_from_value(env, argv[3]) catch return null;
-    context.client.request(@as(u128, @bitCast(user_data)), on_result, operation, message, body_length);
-
-    return null;
-}
 
-/// The batch has already been encoded into a byte slice. This means that we only have to do one
-/// copy directly into an available message. No validation of the encoded data is performed except
-/// that it will fit into the message buffer.
-fn raw_request(env: c.napi_env, info: c.napi_callback_info) callconv(.C) c.napi_value {
-    var argc: usize = 4;
-    var argv: [4]c.napi_value = undefined;
-    if (c.napi_get_cb_info(env, info, &argc, &argv, null, null) != c.napi_ok) {
-        translate.throw(env, "Failed to get args.") catch return null;
+    switch (@as(Operation, @enumFromInt(packet.operation))) {
+        inline else => |op| {
+            const event_count = @divExact(packet.data_size, @sizeOf(StateMachine.Event(op)));
+            const buffer: BufferType(op) = .{
+                .ptr = @ptrCast(packet.data.?),
+                .count = event_count,
+            };
+
+            const Result = StateMachine.Result(op);
+            const results: []const Result = @alignCast(std.mem.bytesAsSlice(
+                Result,
+                result_ptr.?[0..result_len],
+            ));
+            @memcpy(buffer.results()[0..results.len], results);
+
+            packet.data_size = @bitCast(BufferSize{
+                .event_count = @intCast(event_count),
+                .result_count = @intCast(results.len),
+            });
+        },
     }
 
-    if (argc != 4) translate.throw(
-        env,
-        "Function request() requires 4 arguments exactly.",
-    ) catch return null;
-
-    const context_raw = translate.value_external(
-        env,
-        argv[0],
-        "Failed to get Client Context pointer.",
-    ) catch return null;
-    const context = contextCast(context_raw.?) catch return null;
-    const operation_int = translate.u32_from_value(env, argv[1], "operation") catch return null;
-
-    if (!@as(vsr.Operation, @enumFromInt(operation_int)).valid(StateMachine)) {
-        translate.throw(env, "Unknown operation.") catch return null;
-    }
-    const operation = @as(Operation, @enumFromInt(@as(u8, @intCast(operation_int))));
+    // Stuff client pointer into packet.next to store it until the packet arrives on the JS thread.
+    @as(*usize, @ptrCast(&packet.next)).* = @intFromPtr(client);
 
-    if (context.client.messages_available == 0) {
-        translate.throw(
-            env,
-            "Too many outstanding requests - message pool exhausted.",
-        ) catch return null;
+    // Queue the packet to be processed on the JS thread to invoke its JS callback.
+    const completion_tsfn: c.napi_threadsafe_function = @ptrFromInt(completion_ctx);
+    switch (c.napi_call_threadsafe_function(completion_tsfn, packet, c.napi_tsfn_nonblocking)) {
+        c.napi_ok => {},
+        c.napi_queue_full => @panic("ThreadSafe Function queue is full when created with no limit."),
+        else => unreachable,
     }
-    const message = context.client.get_message();
-    errdefer context.client.release(message);
+}
 
-    const body_length = translate.bytes_from_buffer(
-        env,
-        argv[2],
-        message.buffer[@sizeOf(Header)..],
-        "raw_batch",
-    ) catch |err| switch (err) {
-        error.ExceptionThrown => return null,
+fn on_completion_js(
+    env: c.napi_env,
+    unused_js_cb: c.napi_value,
+    unused_context: ?*anyopaque,
+    packet_argument: ?*anyopaque,
+) callconv(.C) void {
+    _ = unused_js_cb;
+    _ = unused_context;
+
+    const packet: *tb.tb_packet_t = @ptrCast(@alignCast(packet_argument.?));
+    assert(packet.status == .ok);
+
+    // Decode the packet's Buffer results into an array then free the Buffer.
+    const array_or_error = switch (@as(Operation, @enumFromInt(packet.operation))) {
+        inline else => |op| blk: {
+            const buffer_size: BufferSize = @bitCast(packet.data_size);
+            const buffer: BufferType(op) = .{
+                .ptr = @ptrCast(packet.data.?),
+                .count = buffer_size.event_count,
+            };
+            defer buffer.free();
+
+            const results = buffer.results()[0..buffer_size.result_count];
+            break :blk encode_array(StateMachine.Result(op), env, results);
+        },
     };
 
-    // This will create a reference (in V8) to the user's JS callback that we must eventually also
-    // free in order to avoid a leak. We therefore do this last to ensure we cannot fail after
-    // taking this reference.
-    const user_data = translate.user_data_from_value(env, argv[3]) catch return null;
-    context.client.request(@as(u128, @bitCast(user_data)), on_result, operation, message, body_length);
-
-    return null;
-}
+    // Extract the remaining packet information and release it back to the client.
+    const client: tb.tb_client_t = @ptrFromInt(@as(*usize, @ptrCast(&packet.next)).*);
+    const callback_ref: c.napi_ref = @ptrCast(@alignCast(packet.user_data.?));
+    tb.release_packet(client, packet);
+
+    // Parse Result array out of packet data, freeing it in the process.
+    // NOTE: Ensure this is called before anything that could early-return to avoid a alloc leak.
+    var callback_error = napi_null;
+    const callback_result = array_or_error catch |err| switch (err) {
+        error.ExceptionThrown => blk: {
+            if (c.napi_get_and_clear_last_exception(env, &callback_error) != c.napi_ok) {
+                std.log.warn("Failed to capture callback error from thrown Exception.", .{});
+            }
+            break :blk napi_null;
+        },
+    };
 
-fn on_result(user_data: u128, operation: Operation, results: []const u8) void {
-    // A reference to the user's JS callback was made in `request` or `raw_request`. This MUST be
-    // cleaned up regardless of the result of this function.
-    const env = @as(translate.UserData, @bitCast(user_data)).env;
-    const callback_reference = @as(translate.UserData, @bitCast(user_data)).callback_reference;
-    defer translate.delete_reference(env, callback_reference) catch {
-        std.log.warn("on_result: Failed to delete reference to user's JS callback.", .{});
+    // Make sure to delete the callback reference once we're done calling it.
+    defer if (c.napi_delete_reference(env, callback_ref) != c.napi_ok) {
+        std.log.warn("Failed to delete reference to user's JS callback.", .{});
     };
 
-    const napi_callback = translate.reference_value(
-        env,
-        callback_reference,
-        "Failed to get callback reference.",
-    ) catch return;
-    const scope = translate.scope(
+    const callback = translate.reference_value(
         env,
-        "Failed to get \"this\" for results callback.",
+        callback_ref,
+        "Failed to get callback from reference.",
     ) catch return;
-    const globals_raw = translate.globals(env) catch return;
-    const globals = globalsCast(globals_raw.?);
-    const argc: usize = 2;
-    var argv: [argc]c.napi_value = undefined;
-
-    const napi_results = switch (operation) {
-        .create_accounts => encode_napi_results_array(
-            CreateAccountsResult,
-            env,
-            results,
-        ) catch return,
-        .create_transfers => encode_napi_results_array(
-            CreateTransfersResult,
-            env,
-            results,
-        ) catch return,
-        .lookup_accounts => encode_napi_results_array(Account, env, results) catch return,
-        .lookup_transfers => encode_napi_results_array(Transfer, env, results) catch return,
-    };
 
-    argv[0] = globals.napi_undefined;
-    argv[1] = napi_results;
-
-    translate.call_function(env, scope, napi_callback, argc, argv[0..]) catch {
-        translate.throw(env, "Failed to call JS results callback.") catch return;
-    };
+    var args = [_]c.napi_value{ callback_error, callback_result };
+    _ = translate.call_function(env, napi_null, callback, &args) catch return;
 }
 
-fn tick(env: c.napi_env, info: c.napi_callback_info) callconv(.C) c.napi_value {
-    var argc: usize = 1;
-    var argv: [1]c.napi_value = undefined;
-    if (c.napi_get_cb_info(env, info, &argc, &argv, null, null) != c.napi_ok) {
-        translate.throw(env, "Failed to get args.") catch return null;
+// (De)Serialization
+
+fn decode_array(comptime Event: type, env: c.napi_env, array: c.napi_value, events: []Event) !void {
+    for (events, 0..) |*event, i| {
+        const object = try translate.array_element(env, array, @intCast(i));
+        switch (Event) {
+            Account, Transfer => {
+                inline for (std.meta.fields(Event)) |field| {
+                    const FieldInt = switch (@typeInfo(field.type)) {
+                        .Struct => |info| info.backing_integer.?,
+                        else => field.type,
+                    };
+
+                    const value = try @field(translate, @typeName(FieldInt) ++ "_from_object")(
+                        env,
+                        object,
+                        @ptrCast(field.name ++ "\x00"),
+                    );
+
+                    if (std.mem.eql(u8, field.name, "timestamp") and value != 0) {
+                        return translate.throw(
+                            env,
+                            "Timestamp should be set to 0 as this will be set correctly by Replica.",
+                        );
+                    }
+
+                    @field(event, field.name) = switch (@typeInfo(field.type)) {
+                        .Struct => @as(field.type, @bitCast(value)),
+                        else => value,
+                    };
+                }
+            },
+            u128 => event.* = try translate.u128_from_value(env, object, "lookup"),
+            else => @compileError("invalid Event type"),
+        }
     }
+}
 
-    if (argc != 1) translate.throw(
+fn encode_array(comptime Result: type, env: c.napi_env, results: []const Result) !c.napi_value {
+    const array = try translate.create_array(
         env,
-        "Function tick() requires 1 argument exactly.",
-    ) catch return null;
+        @intCast(results.len),
+        "Failed to allocate array for results.",
+    );
 
-    const context_raw = translate.value_external(
-        env,
-        argv[0],
-        "Failed to get Client Context pointer.",
-    ) catch return null;
-    const context = contextCast(context_raw.?) catch return null;
+    for (results, 0..) |*result, i| {
+        const object = try translate.create_object(
+            env,
+            "Failed to create " ++ @typeName(Result) ++ " object.",
+        );
 
-    context.client.tick();
-    context.io.tick() catch |err| switch (err) {
-        // TODO exhaustive switch
-        else => {
-            translate.throw(env, "Failed to tick IO.") catch return null;
-        },
-    };
-    return null;
+        inline for (std.meta.fields(Result)) |field| {
+            const FieldInt = switch (@typeInfo(field.type)) {
+                .Struct => |info| info.backing_integer.?,
+                .Enum => |info| info.tag_type,
+                else => field.type,
+            };
+
+            const value: FieldInt = switch (@typeInfo(field.type)) {
+                .Struct => @bitCast(@field(result, field.name)),
+                .Enum => @intFromEnum(@field(result, field.name)),
+                else => @field(result, field.name),
+            };
+
+            try @field(translate, @typeName(FieldInt) ++ "_into_object")(
+                env,
+                object,
+                @ptrCast(field.name ++ "\x00"),
+                value,
+                "Failed to set property \"" ++ field.name ++ "\" of " ++ @typeName(Result) ++ " object",
+            );
+
+            try translate.set_array_element(
+                env,
+                array,
+                @intCast(i),
+                object,
+                "Failed to set element in results array.",
+            );
+        }
+    }
+
+    return array;
 }
 
-fn deinit(env: c.napi_env, info: c.napi_callback_info) callconv(.C) c.napi_value {
-    var argc: usize = 1;
-    var argv: [1]c.napi_value = undefined;
-    if (c.napi_get_cb_info(env, info, &argc, &argv, null, null) != c.napi_ok) {
-        translate.throw(env, "Failed to get args.") catch return null;
-    }
+/// Each packet allocates enough room to hold both its Events and its Results.
+/// Buffer is an abstraction over the memory management for this.
+fn BufferType(comptime op: Operation) type {
+    return struct {
+        const Buffer = @This();
+        const Event = StateMachine.Event(op);
+        const Result = StateMachine.Result(op);
+        const max_align: u29 = @max(@alignOf(Event), @alignOf(Result));
+
+        ptr: [*]u8,
+        count: u32,
+
+        fn alloc(env: c.napi_env, count: u32) !Buffer {
+            // Allocate enough bytes to hold memory for the Events and the Results.
+            const max_bytes = @max(@sizeOf(Event) * count, @sizeOf(Result) * count);
+            if (@sizeOf(vsr.Header) + max_bytes > constants.message_size_max) {
+                return translate.throw(env, "Batch is larger than the maximum message size.");
+            }
 
-    if (argc != 1) translate.throw(
-        env,
-        "Function deinit() requires 1 argument exactly.",
-    ) catch return null;
+            const bytes = allocator.alignedAlloc(u8, max_align, max_bytes) catch |e| switch (e) {
+                error.OutOfMemory => return translate.throw(env, "Batch allocation ran out of memory."),
+            };
+            errdefer allocator.free(bytes);
 
-    const context_raw = translate.value_external(
-        env,
-        argv[0],
-        "Failed to get Client Context pointer.",
-    ) catch return null;
-    const context = contextCast(context_raw.?) catch return null;
+            return Buffer{
+                .ptr = bytes.ptr,
+                .count = count,
+            };
+        }
+
+        fn free(buffer: Buffer) void {
+            const max_bytes = @max(@sizeOf(Event) * buffer.count, @sizeOf(Result) * buffer.count);
+            const bytes: []align(max_align) u8 = @alignCast(buffer.ptr[0..max_bytes]);
+            allocator.free(bytes);
+        }
 
-    const allocator = std.heap.c_allocator;
-    context.client.deinit(allocator);
-    context.message_pool.deinit(allocator);
-    allocator.free(context.addresses);
+        fn events(buffer: Buffer) []Event {
+            const event_bytes = buffer.ptr[0 .. @sizeOf(Event) * buffer.count];
+            return @alignCast(std.mem.bytesAsSlice(Event, event_bytes));
+        }
 
-    return null;
+        fn results(buffer: Buffer) []Result {
+            const result_bytes = buffer.ptr[0 .. @sizeOf(Result) * buffer.count];
+            return @alignCast(std.mem.bytesAsSlice(Result, result_bytes));
+        }
+    };
 }