diff --git a/src/callback.zig b/src/callback.zig
index b1e427b..12ad3ee 100644
--- a/src/callback.zig
+++ b/src/callback.zig
@@ -39,10 +39,8 @@ pub fn wrapCallback(
                     if (error_info_status == .ok) {
                         e.throwError(@errorName(err), "NapiError") catch {};
                     } else {
-                        e.throwError(
-                            @tagName(error_info_status),
-                            std.mem.span(error_info.error_message),
-                        ) catch {};
+                        const message: [:0]const u8 = "Native callback failed";
+                        e.throwError(@tagName(error_info_status), message) catch {};
                     }
                 } else {
                     e.throwError(@errorName(err), @errorName(err)) catch {};
diff --git a/src/callback_info.zig b/src/callback_info.zig
index 7bab73c..0b97ecf 100644
--- a/src/callback_info.zig
+++ b/src/callback_info.zig
@@ -1,3 +1,4 @@
+const std = @import("std");
 const c = @import("c.zig");
 const status = @import("status.zig");
 const NapiError = @import("status.zig").NapiError;
@@ -17,10 +18,10 @@ pub fn CallbackInfo(comptime argc_cap: usize) type {
         pub fn init(env: c.napi_env, cb_info: c.napi_callback_info) NapiError!Self {
             var info = Self{
                 .env = env,
-                .args = undefined,
-                .this_arg = undefined,
-                .argc = undefined,
-                .data = undefined,
+                .args = std.mem.zeroes([argc_cap]c.napi_value),
+                .this_arg = std.mem.zeroes(c.napi_value),
+                .argc = 0,
+                .data = null,
             };
 
             var initial_argc = argc_cap;
diff --git a/src/create_callback.zig b/src/create_callback.zig
index 588a2aa..a8f9575 100644
--- a/src/create_callback.zig
+++ b/src/create_callback.zig
@@ -32,15 +32,28 @@ pub fn createCallback(
             var cb_arg_i: usize = 0;
             inline for (0..fn_info.params.len) |i| {
                 const arg_hint = comptime getArgsHint(options, i);
+                const param_type = fn_info.params[i].type.?;
+
+                const is_env_arg = arg_hint == .env or (arg_hint == .auto and param_type == Env);
+                const is_value_arg = arg_hint == .value or (arg_hint == .auto and param_type == Value);
+
                 if (arg_hint == .data) {
                     args[i] = @alignCast(@ptrCast(info.data));
-                } else if (arg_hint == .env) {
+                } else if (is_env_arg) {
                     args[i] = env;
-                } else if (arg_hint == .value) {
-                    args[i] = info.arg(cb_arg_i);
+                } else if (is_value_arg) {
+                    const value_arg = info.getArg(cb_arg_i) orelse {
+                        try env.throwError("ERR_INVALID_ARG_COUNT", "Invalid callback argument count");
+                        return error.PendingException;
+                    };
+                    args[i] = value_arg;
                     cb_arg_i += 1;
                 } else {
-                    args[i] = try fromValue(fn_info.params[i].type.?, info.arg(cb_arg_i), arg_hint);
+                    const value_arg = info.getArg(cb_arg_i) orelse {
+                        try env.throwError("ERR_INVALID_ARG_COUNT", "Invalid callback argument count");
+                        return error.PendingException;
+                    };
+                    args[i] = try fromValue(param_type, value_arg, arg_hint);
                     cb_arg_i += 1;
                 }
             }
@@ -73,6 +86,7 @@ pub const ArgHint = enum {
 pub const ReturnsHint = enum {
     auto,
     buffer,
+    external_buffer,
     string,
 
     /// napi.Value