koffi 2.16.1 → 3.0.0-alpha.2

package/src/koffi/src/call.cc

@@ -21,37 +21,108 @@ struct RelayContext {
     bool done = false;
 };
 
+#if defined(_WIN32)
+
 extern "C" void *FindTrampolineStart();
 extern "C" void *FindTrampolineEnd();
 
 static const uint8_t *TrampolineStart = (const uint8_t *)FindTrampolineStart();
 static const Size TrampolineSize = ((const uint8_t *)FindTrampolineEnd() - TrampolineStart) / MaxTrampolines;
 
-CallData::CallData(Napi::Env env, InstanceData *instance, InstanceMemory *mem)
-    : env(env), instance(instance),
-      mem(mem), old_stack_mem(mem->stack), old_heap_mem(mem->heap)
-{
-    mem->depth++;
+#else
 
-    K_ASSERT(AlignUp(mem->stack.ptr, 16) == mem->stack.ptr);
-}
+extern "C" uint8_t Trampoline0;
+extern "C" uint8_t TrampolineEnd;
 
+static const uint8_t *TrampolineStart = (const uint8_t *)&Trampoline0;
+static const Size TrampolineSize = ((const uint8_t *)&TrampolineEnd - TrampolineStart) / MaxTrampolines;
+
+#endif
+
+#if defined(K_DEBUG)
 CallData::~CallData()
 {
-    if (!instance)
-        return;
-
-    Dispose();
+    K_ASSERT(mem->stack.end == prev_stack);
+    K_ASSERT(mem->heap.ptr == prev_heap);
+    K_ASSERT(!out_arguments.len);
+    K_ASSERT(!used_trampolines.len);
 }
+#endif
 
-void CallData::Dispose()
+void CallData::Finalize()
 {
-    for (const OutArgument &out: out_arguments) {
-        napi_delete_reference(env, out.ref);
-    }
+    FinalizeFast();
+
+    if (out_arguments.len) {
+        if (!env.IsExceptionPending()) {
+            for (const OutArgument &out: out_arguments) {
+                napi_value value = GetReferenceValue(env, out.ref);
+
+                switch (out.kind) {
+                    case OutArgument::Kind::Array: {
+                        K_ASSERT(IsArray(env, value));
+
+                        uint32_t len = GetArrayLength(env, value);
+                        DecodeElements(env, value, out.ptr, out.type, len);
+                    } break;
+
+                    case OutArgument::Kind::Buffer: {
+                        Span<uint8_t> buffer;
+
+                        bool success = TryBuffer(env, value, &buffer);
+                        K_ASSERT(success);
+
+                        DecodeBuffer(buffer, out.ptr, out.type);
+                    } break;
+
+                    case OutArgument::Kind::String: {
+                        K_ASSERT(IsArray(env, value));
+                        K_ASSERT(GetArrayLength(env, value) == 1);
+
+                        Size len = strnlen((const char *)out.ptr, out.max_len);
+                        Napi::String str = Napi::String::New(env, (const char *)out.ptr, len);
+
+                        napi_set_element(env, value, 0, str);
+                    } break;
+
+                    case OutArgument::Kind::String16: {
+                        K_ASSERT(IsArray(env, value));
+                        K_ASSERT(GetArrayLength(env, value) == 1);
+
+                        Size len = NullTerminatedLength((const char16_t *)out.ptr, out.max_len);
+                        Napi::String str = Napi::String::New(env, (const char16_t *)out.ptr, len);
+
+                        napi_set_element(env, value, 0, str);
+                    } break;
+
+                    case OutArgument::Kind::String32: {
+                        K_ASSERT(IsArray(env, value));
+                        K_ASSERT(GetArrayLength(env, value) == 1);
+
+                        Size len = NullTerminatedLength((const char32_t *)out.ptr, out.max_len);
+                        Napi::String str = MakeStringFromUTF32(env, (const char32_t *)out.ptr, len);
 
-    mem->stack = old_stack_mem;
-    mem->heap = old_heap_mem;
+                        napi_set_element(env, value, 0, str);
+                    } break;
+
+                    case OutArgument::Kind::Object: {
+                        if (CheckValueTag(env, value, &UnionClassMarker)) {
+                            Napi::Object obj = Napi::Object(env, value);
+
+                            UnionClass *u = UnionClass::Unwrap(obj);
+                            u->SetRaw(out.ptr);
+                        } else {
+                            DecodeObject(env, value, out.ptr, out.type);
+                        }
+                    } break;
+                }
+            }
+        }
+
+        for (const OutArgument &out: out_arguments) {
+            napi_delete_reference(env, out.ref);
+        }
+    }
 
     if (used_trampolines.len) {
         std::lock_guard<std::mutex> lock(shared.mutex);
@@ -63,17 +134,37 @@ void CallData::Dispose()
             K_ASSERT(trampoline->instance == instance);
             K_ASSERT(!trampoline->func.IsEmpty());
 
+            trampoline->state = 0;
             trampoline->func.Reset();
             trampoline->recv.Reset();
-            trampoline->used = false;
 
             shared.available.Append(idx);
         }
     }
 
-    ReleaseMemory(instance, mem);
+#if defined(K_DEBUG)
+    out_arguments.len = 0;
+    used_trampolines.len = 0;
+#endif
+}
 
-    instance = nullptr;
+void CallData::FinalizeFast()
+{
+#if defined(K_DEBUG)
+    K_ASSERT(!finalized);
+    K_DEFER { finalized = true; };
+#endif
+
+    mem->stack.end = prev_stack;
+    mem->heap.ptr = prev_heap;
+
+    if (release_alloc) {
+        // We could check for prev_stack == mem->stack.len and call ReleaseAll() if true, but
+        // it is a virtual method. Which means it could be slow (unless devirtualized), and
+        // most of the time there's nothing to release.
+        // So instead, take note of the need to call ReleaseAll() when big chunks are allocated.
+        mem->allocator.ReleaseAll();
+    }
 }
 
 void CallData::RelayAsync(Size idx, uint8_t *sp)
@@ -96,77 +187,76 @@ void CallData::RelayAsync(Size idx, uint8_t *sp)
     }
 }
 
-bool CallData::PushString(Napi::Value value, int directions, const char **out_str)
+bool CallData::PushString(napi_value value, int directions, const char **out_str)
 {
     // Fast path
-    if (value.IsString()) {
+    if (PushStringValue(value, out_str) >= 0) {
         if (directions & 2) [[unlikely]] {
             ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, value));
             return false;
         }
 
-        PushStringValue(value, out_str);
         return true;
     }
 
     return PushPointer(value, instance->str_type, directions, (void **)out_str);
 }
 
-bool CallData::PushString16(Napi::Value value, int directions, const char16_t **out_str16)
+bool CallData::PushString16(napi_value value, int directions, const char16_t **out_str16)
 {
     // Fast path
-    if (value.IsString()) {
+    if (PushString16Value(value, out_str16) >= 0) {
         if (directions & 2) [[unlikely]] {
             ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, value));
             return false;
         }
 
-        PushString16Value(value, out_str16);
         return true;
     }
 
     return PushPointer(value, instance->str16_type, directions, (void **)out_str16);
 }
 
-bool CallData::PushString32(Napi::Value value, int directions, const char32_t **out_str32)
+bool CallData::PushString32(napi_value value, int directions, const char32_t **out_str32)
 {
     // Fast path
-    if (value.IsString()) {
+    if (PushString32Value(value, out_str32) >= 0) {
         if (directions & 2) [[unlikely]] {
             ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, value));
             return false;
         }
 
-        PushString32Value(value, out_str32);
         return true;
     }
 
     return PushPointer(value, instance->str32_type, directions, (void **)out_str32);
 }
 
-Size CallData::PushStringValue(Napi::Value value, const char **out_str)
+Size CallData::PushStringValue(napi_value value, const char **out_str)
 {
     Span<char> buf;
     size_t len = 0;
     napi_status status;
 
     buf.ptr = (char *)mem->heap.ptr;
-    buf.len = std::max((Size)0, mem->heap.len - Kibibytes(32));
+    buf.len = mem->heap.end - mem->heap.ptr;
 
     status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
+    if (status == napi_string_expected)
+        return -1;
     K_ASSERT(status == napi_ok);
 
     len++;
 
     if (len < (size_t)buf.len) [[likely]] {
-        mem->heap.ptr += (Size)len;
-        mem->heap.len -= (Size)len;
+        mem->heap.ptr += (Size)AlignLen(len, 16);
     } else {
         status = napi_get_value_string_utf8(env, value, nullptr, 0, &len);
         K_ASSERT(status == napi_ok);
 
         len++;
-        buf = AllocateSpan<char>(&alloc, (Size)len);
+        buf = AllocateSpan<char>(&mem->allocator, (Size)len);
+        release_alloc |= (prev_stack == mem->stack.end);
 
         status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
         K_ASSERT(status == napi_ok);
@@ -178,30 +268,31 @@ Size CallData::PushStringValue(Napi::Value value, const char **out_str)
     return (Size)len;
 }
 
-Size CallData::PushString16Value(Napi::Value value, const char16_t **out_str16)
+Size CallData::PushString16Value(napi_value value, const char16_t **out_str16)
 {
     Span<char16_t> buf;
     size_t len = 0;
     napi_status status;
 
-    mem->heap.ptr = AlignUp(mem->heap.ptr, 2);
     buf.ptr = (char16_t *)mem->heap.ptr;
-    buf.len = std::max((Size)0, mem->heap.len - Kibibytes(32)) / 2;
+    buf.len = (mem->heap.end - mem->heap.ptr) / 2;
 
     status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
+    if (status == napi_string_expected)
+        return -1;
     K_ASSERT(status == napi_ok);
 
     len++;
 
     if (len < (size_t)buf.len) [[likely]] {
-        mem->heap.ptr += (Size)len * 2;
-        mem->heap.len -= (Size)len * 2;
+        mem->heap.ptr += (Size)AlignLen(len * 2, 16);
     } else {
         status = napi_get_value_string_utf16(env, value, nullptr, 0, &len);
         K_ASSERT(status == napi_ok);
 
         len++;
-        buf = AllocateSpan<char16_t>(&alloc, (Size)len);
+        buf = AllocateSpan<char16_t>(&mem->allocator, (Size)len);
+        release_alloc |= (prev_stack == mem->stack.end);
 
         status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
         K_ASSERT(status == napi_ok);
@@ -213,7 +304,7 @@ Size CallData::PushString16Value(Napi::Value value, const char16_t **out_str16)
     return (Size)len;
 }
 
-Size CallData::PushString32Value(Napi::Value value, const char32_t **out_str32)
+Size CallData::PushString32Value(napi_value value, const char32_t **out_str32)
 {
     static const char32_t ReplacementChar = 0x0000FFFD;
 
@@ -224,15 +315,14 @@ Size CallData::PushString32Value(Napi::Value value, const char32_t **out_str32)
     if (buf16.len < 0) [[unlikely]]
         return -1;
 
-    mem->heap.ptr = AlignUp(mem->heap.ptr, 4);
     buf.ptr = (char32_t *)mem->heap.ptr;
-    buf.len = std::max((Size)0, mem->heap.len - Kibibytes(32)) / 4;
+    buf.len = (mem->heap.end - mem->heap.ptr) / 4;
 
     if (buf16.len < buf.len) [[likely]] {
-        mem->heap.ptr += buf16.len * 4;
-        mem->heap.len -= buf16.len * 4;
+        mem->heap.ptr += AlignLen(buf16.len * 4, 16);
     } else {
-        buf = AllocateSpan<char32_t>(&alloc, buf16.len);
+        buf = AllocateSpan<char32_t>(&mem->allocator, buf16.len);
+        release_alloc |= (prev_stack == mem->stack.end);
     }
 
     Size j = 0;
@@ -262,9 +352,25 @@ Size CallData::PushString32Value(Napi::Value value, const char32_t **out_str32)
     return j;
 }
 
-bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origin)
+static inline napi_value GetMemberValue(napi_env env, napi_value obj, const RecordMember &member)
+{
+    napi_value value = nullptr;
+
+    if (member.key) {
+        napi_value key = nullptr;
+        napi_get_reference_value(env, member.key, &key);
+
+        napi_get_property(env, obj, key, &value);
+    } else {
+        napi_get_named_property(env, obj, member.name, &value);
+    }
+
+    return value;
+}
+
+bool CallData::PushObject(napi_value obj, const TypeInfo *type, uint8_t *origin)
 {
-    K_ASSERT(IsObject(obj));
+    K_ASSERT(IsObject(env, obj));
     K_ASSERT(type->primitive == PrimitiveKind::Record ||
               type->primitive == PrimitiveKind::Union);
 
@@ -273,8 +379,8 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
     if (type->primitive == PrimitiveKind::Record) {
         members = type->members;
     } else if (type->primitive == PrimitiveKind::Union) {
-        if (CheckValueTag(obj, &MagicUnionMarker)) {
-            MagicUnion *u = MagicUnion::Unwrap(obj);
+        if (CheckValueTag(env, obj, &UnionClassMarker)) {
+            UnionClass *u = UnionClass::Unwrap(Napi::Object(env, obj));
             const uint8_t *raw = u->GetRaw();
 
             if (u->GetType() != type) [[unlikely]] {
@@ -296,7 +402,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                 return false;
             }
         } else {
-            Napi::Array properties = GetOwnPropertyNames(obj);
+            Napi::Array properties = GetOwnPropertyNames(env, obj);
 
             if (properties.Length() != 1 || !properties.Get(0u).IsString()) [[unlikely]] {
                 ThrowError<Napi::Error>(env, "Expected object with single property name for union");
@@ -320,9 +426,34 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
 
     MemSet(origin, 0, type->size);
 
+#define PUSH_INTEGER(CType) \
+        do { \
+            CType v; \
+            if (!TryNumber(env, value, &v)) [[unlikely]] { \
+                abort(); \
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
+                return false; \
+            } \
+             \
+            *(CType *)dest = v; \
+        } while (false)
+#define PUSH_INTEGER_SWAP(CType) \
+        do { \
+            CType v; \
+            if (!TryNumber(env, value, &v)) [[unlikely]] { \
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
+                return false; \
+            } \
+             \
+            *(CType *)dest = ReverseBytes(v); \
+        } while (false)
+
     for (Size i = 0; i < members.len; i++) {
         const RecordMember &member = members[i];
-        Napi::Value value = obj.Get(member.name);
+        napi_value value = GetMemberValue(env, obj, member);
+
+        if (GetKindOf(env, value) == napi_undefined)
+            continue;
 
         if (member.countedby >= 0) {
             const char *countedby = members[member.countedby].name;
@@ -331,149 +462,36 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                 return false;
         }
 
-        if (value.IsUndefined())
-            continue;
-
         uint8_t *dest = origin + member.offset;
 
         switch (member.type->primitive) {
             case PrimitiveKind::Void: { K_UNREACHABLE(); } break;
 
             case PrimitiveKind::Bool: {
-                if (!value.IsBoolean()) [[unlikely]] {
+                bool b;
+                napi_status status = napi_get_value_bool(env, value, &b);
+
+                if (status != napi_ok) [[unlikely]] {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected boolean", GetValueType(instance, value));
                     return false;
                 }
 
-                bool b = value.As<Napi::Boolean>();
                 *(bool *)dest = b;
             } break;
-            case PrimitiveKind::Int8: {
-                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
-                    return false;
-                }
-
-                int8_t v = GetNumber<int8_t>(value);
-                *(int8_t *)dest = v;
-            } break;
-            case PrimitiveKind::UInt8: {
-                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
-                    return false;
-                }
-
-                uint8_t v = GetNumber<uint8_t>(value);
-                *(uint8_t *)dest = v;
-            } break;
-            case PrimitiveKind::Int16: {
-                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
-                    return false;
-                }
-
-                int16_t v = GetNumber<int16_t>(value);
-                *(int16_t *)dest = v;
-            } break;
-            case PrimitiveKind::Int16S: {
-                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
-                    return false;
-                }
-
-                int16_t v = GetNumber<int16_t>(value);
-                *(int16_t *)dest = ReverseBytes(v);
-            } break;
-            case PrimitiveKind::UInt16: {
-                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
-                    return false;
-                }
-
-                uint16_t v = GetNumber<uint16_t>(value);
-                *(uint16_t *)dest = v;
-            } break;
-            case PrimitiveKind::UInt16S: {
-                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
-                    return false;
-                }
-
-                uint16_t v = GetNumber<uint16_t>(value);
-                *(uint16_t *)dest = ReverseBytes(v);
-            } break;
-            case PrimitiveKind::Int32: {
-                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
-                    return false;
-                }
-
-                int32_t v = GetNumber<int32_t>(value);
-                *(int32_t *)dest = v;
-            } break;
-            case PrimitiveKind::Int32S: {
-                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
-                    return false;
-                }
-
-                int32_t v = GetNumber<int32_t>(value);
-                *(int32_t *)dest = ReverseBytes(v);
-            } break;
-            case PrimitiveKind::UInt32: {
-                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
-                    return false;
-                }
-
-                uint32_t v = GetNumber<uint32_t>(value);
-                *(uint32_t *)dest = v;
-            } break;
-            case PrimitiveKind::UInt32S: {
-                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
-                    return false;
-                }
-
-                uint32_t v = GetNumber<uint32_t>(value);
-                *(uint32_t *)dest = ReverseBytes(v);
-            } break;
-            case PrimitiveKind::Int64: {
-                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
-                    return false;
-                }
-
-                int64_t v = GetNumber<int64_t>(value);
-                *(int64_t *)dest = v;
-            } break;
-            case PrimitiveKind::Int64S: {
-                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
-                    return false;
-                }
-
-                int64_t v = GetNumber<int64_t>(value);
-                *(int64_t *)dest = ReverseBytes(v);
-            } break;
-            case PrimitiveKind::UInt64: {
-                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
-                    return false;
-                }
-
-                uint64_t v = GetNumber<uint64_t>(value);
-                *(uint64_t *)dest = v;
-            } break;
-            case PrimitiveKind::UInt64S: {
-                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
-                    return false;
-                }
-
-                uint64_t v = GetNumber<uint64_t>(value);
-                *(uint64_t *)dest = ReverseBytes(v);
-            } break;
+            case PrimitiveKind::Int8: { PUSH_INTEGER(int8_t); } break;
+            case PrimitiveKind::UInt8: { PUSH_INTEGER(uint8_t); } break;
+            case PrimitiveKind::Int16: { PUSH_INTEGER(int16_t); } break;
+            case PrimitiveKind::Int16S: { PUSH_INTEGER_SWAP(int16_t); } break;
+            case PrimitiveKind::UInt16: { PUSH_INTEGER(uint16_t); } break;
+            case PrimitiveKind::UInt16S: { PUSH_INTEGER_SWAP(uint16_t); } break;
+            case PrimitiveKind::Int32: { PUSH_INTEGER(int32_t); } break;
+            case PrimitiveKind::Int32S: { PUSH_INTEGER_SWAP(int32_t); } break;
+            case PrimitiveKind::UInt32: { PUSH_INTEGER(uint32_t); } break;
+            case PrimitiveKind::UInt32S: { PUSH_INTEGER_SWAP(uint32_t); } break;
+            case PrimitiveKind::Int64: { PUSH_INTEGER(int64_t); } break;
+            case PrimitiveKind::Int64S: { PUSH_INTEGER_SWAP(int64_t); } break;
+            case PrimitiveKind::UInt64: { PUSH_INTEGER(uint64_t); } break;
+            case PrimitiveKind::UInt64S: { PUSH_INTEGER_SWAP(uint64_t); } break;
             case PrimitiveKind::String: {
                 const char *str;
                 if (!PushString(value, 1, &str)) [[unlikely]]
@@ -504,24 +522,22 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             } break;
             case PrimitiveKind::Record:
             case PrimitiveKind::Union: {
-                if (!IsObject(value)) [[unlikely]] {
+                if (!IsObject(env, value)) [[unlikely]] {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
                     return false;
                 }
 
-                Napi::Object obj2 = value.As<Napi::Object>();
-                if (!PushObject(obj2, member.type, dest))
+                if (!PushObject(value, member.type, dest))
                     return false;
             } break;
             case PrimitiveKind::Array: {
-                if (value.IsArray()) {
-                    Napi::Array array = value.As<Napi::Array>();
+                if (IsArray(env, value)) {
+                    Napi::Array array = Napi::Array(env, value);
                     if (!PushNormalArray(array, member.type, member.type->size, dest))
                         return false;
-                } else if (IsRawBuffer(value)) {
-                    Span<const uint8_t> buffer = GetRawBuffer(value);
+                } else if (Span<uint8_t> buffer = {}; TryBuffer(env, value, &buffer)) {
                     PushBuffer(buffer, member.type, dest);
-                } else if (value.IsString()) {
+                } else if (GetKindOf(env, value) == napi_string) {
                     if (!PushStringArray(value, member.type, dest))
                         return false;
                 } else {
@@ -530,22 +546,22 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                 }
             } break;
             case PrimitiveKind::Float32: {
-                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                float f;
+                if (!TryNumber(env, value, &f)) [[unlikely]] {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
-                float f = GetNumber<float>(value);
-                *(float *)dest = f;
+                memcpy(dest, &f, 4);
             } break;
             case PrimitiveKind::Float64: {
-                if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                double d;
+                if (!TryNumber(env, value, &d)) [[unlikely]] {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
-                double d = GetNumber<double>(value);
-                *(double *)dest = d;
+                memcpy(dest, &d, 8);
             } break;
             case PrimitiveKind::Callback: {
                 void *ptr;
@@ -559,6 +575,9 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
         }
     }
 
+#undef PUSH_INTEGER_SWAP
+#undef PUSH_INTEGER
+
     return true;
 }
 
@@ -578,7 +597,7 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
 
     Size offset = 0;
 
-#define PUSH_ARRAY(Check, Expected, GetCode) \
+#define PUSH_ARRAY(Code) \
         do { \
             for (Size i = 0; i < len; i++) { \
                 Napi::Value value = array[(uint32_t)i]; \
@@ -586,16 +605,33 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
                 offset = AlignLen(offset, ref->align); \
                 uint8_t *dest = origin + offset; \
                  \
-                if (!(Check)) [[unlikely]] { \
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected %2", GetValueType(instance, value), (Expected)); \
-                    return false; \
-                } \
-                 \
-                GetCode \
+                Code \
                  \
                 offset += ref->size; \
             } \
         } while (false)
+#define PUSH_INTEGERS(CType) \
+        PUSH_ARRAY({ \
+            CType v; \
+             \
+            if (!TryNumber(env, value, &v)) [[unlikely]] { \
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
+                return false; \
+            } \
+             \
+            *(CType *)dest = v; \
+        })
+#define PUSH_INTEGERS_SWAP(CType) \
+        PUSH_ARRAY({ \
+            CType v; \
+             \
+            if (!TryNumber(env, value, &v)) [[unlikely]] { \
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
+                return false; \
+            } \
+             \
+            *(CType *)dest = ReverseBytes(v); \
+        })
 
     switch (ref->primitive) {
         case PrimitiveKind::Void: {
@@ -604,97 +640,34 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
         } break;
 
         case PrimitiveKind::Bool: {
-            PUSH_ARRAY(value.IsBoolean(), "boolean", {
-                bool b = value.As<Napi::Boolean>();
+            PUSH_ARRAY({
+                bool b;
+                napi_status status = napi_get_value_bool(env, value, &b);
+
+                if (status != napi_ok) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected boolean", GetValueType(instance, value));
+                    return false;
+                }
+
                 *(bool *)dest = b;
             });
         } break;
-        case PrimitiveKind::Int8: {
-            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                int8_t v = GetNumber<int8_t>(value);
-                *(int8_t *)dest = v;
-            });
-        } break;
-        case PrimitiveKind::UInt8: {
-            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                uint8_t v = GetNumber<uint8_t>(value);
-                *(uint8_t *)dest = v;
-            });
-        } break;
-        case PrimitiveKind::Int16: {
-            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                int16_t v = GetNumber<int16_t>(value);
-                *(int16_t *)dest = v;
-            });
-        } break;
-        case PrimitiveKind::Int16S: {
-            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                int16_t v = GetNumber<int16_t>(value);
-                *(int16_t *)dest = ReverseBytes(v);
-            });
-        } break;
-        case PrimitiveKind::UInt16: {
-            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                uint16_t v = GetNumber<uint16_t>(value);
-                *(uint16_t *)dest = v;
-            });
-        } break;
-        case PrimitiveKind::UInt16S: {
-            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                uint16_t v = GetNumber<uint16_t>(value);
-                *(uint16_t *)dest = ReverseBytes(v);
-            });
-        } break;
-        case PrimitiveKind::Int32: {
-            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                int32_t v = GetNumber<int32_t>(value);
-                *(int32_t *)dest = v;
-            });
-        } break;
-        case PrimitiveKind::Int32S: {
-            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                int32_t v = GetNumber<int32_t>(value);
-                *(int32_t *)dest = ReverseBytes(v);
-            });
-        } break;
-        case PrimitiveKind::UInt32: {
-            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                uint32_t v = GetNumber<uint32_t>(value);
-                *(uint32_t *)dest = v;
-            });
-        } break;
-        case PrimitiveKind::UInt32S: {
-            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                uint32_t v = GetNumber<uint32_t>(value);
-                *(uint32_t *)dest = ReverseBytes(v);
-            });
-        } break;
-        case PrimitiveKind::Int64: {
-            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                int64_t v = GetNumber<int64_t>(value);
-                *(int64_t *)dest = v;
-            });
-        } break;
-        case PrimitiveKind::Int64S: {
-            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                int64_t v = GetNumber<int64_t>(value);
-                *(int64_t *)dest = ReverseBytes(v);
-            });
-        } break;
-        case PrimitiveKind::UInt64: {
-            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                uint64_t v = GetNumber<uint64_t>(value);
-                *(uint64_t *)dest = v;
-            });
-        } break;
-        case PrimitiveKind::UInt64S: {
-            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                uint64_t v = GetNumber<uint64_t>(value);
-                *(uint64_t *)dest = ReverseBytes(v);
-            });
-        } break;
+        case PrimitiveKind::Int8: { PUSH_INTEGERS(int8_t); } break;
+        case PrimitiveKind::UInt8: { PUSH_INTEGERS(uint8_t); } break;
+        case PrimitiveKind::Int16: { PUSH_INTEGERS(int16_t); } break;
+        case PrimitiveKind::Int16S: { PUSH_INTEGERS_SWAP(int16_t); } break;
+        case PrimitiveKind::UInt16: { PUSH_INTEGERS(uint16_t); } break;
+        case PrimitiveKind::UInt16S: { PUSH_INTEGERS_SWAP(uint16_t); } break;
+        case PrimitiveKind::Int32: { PUSH_INTEGERS(int32_t); } break;
+        case PrimitiveKind::Int32S: { PUSH_INTEGERS_SWAP(int32_t); } break;
+        case PrimitiveKind::UInt32: { PUSH_INTEGERS(uint32_t); } break;
+        case PrimitiveKind::UInt32S: { PUSH_INTEGERS_SWAP(uint32_t); } break;
+        case PrimitiveKind::Int64: { PUSH_INTEGERS(int64_t); } break;
+        case PrimitiveKind::Int64S: { PUSH_INTEGERS_SWAP(int64_t); } break;
+        case PrimitiveKind::UInt64: { PUSH_INTEGERS(uint64_t); } break;
+        case PrimitiveKind::UInt64S: { PUSH_INTEGERS_SWAP(uint64_t); } break;
         case PrimitiveKind::String: {
-            PUSH_ARRAY(true, "string", {
+            PUSH_ARRAY({
                 const char *str;
                 if (!PushString(value, 1, &str)) [[unlikely]]
                     return false;
@@ -703,7 +676,7 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
             });
         } break;
         case PrimitiveKind::String16: {
-            PUSH_ARRAY(true, "string", {
+            PUSH_ARRAY({
                 const char16_t *str16;
                 if (!PushString16(value, 1, &str16)) [[unlikely]]
                     return false;
@@ -712,7 +685,7 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
             });
         } break;
         case PrimitiveKind::String32: {
-            PUSH_ARRAY(true, "string", {
+            PUSH_ARRAY({
                 const char32_t *str32;
                 if (!PushString32(value, 1, &str32)) [[unlikely]]
                     return false;
@@ -721,7 +694,12 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
             });
         } break;
         case PrimitiveKind::Pointer: {
-            PUSH_ARRAY(true, ref->name, {
+            PUSH_ARRAY({
+                if (!IsObject(env, value)) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
+                    return false;
+                }
+
                 void *ptr;
                 if (!PushPointer(value, ref, 1, &ptr)) [[unlikely]]
                     return false;
@@ -731,7 +709,12 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
         } break;
         case PrimitiveKind::Record:
         case PrimitiveKind::Union: {
-            PUSH_ARRAY(IsObject(value), "object", {
+            PUSH_ARRAY({
+                if (!IsObject(env, value)) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
+                    return false;
+                }
+
                 Napi::Object obj2 = value.As<Napi::Object>();
                 if (!PushObject(obj2, ref, dest))
                     return false;
@@ -749,8 +732,7 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
                     Napi::Array array2 = value.As<Napi::Array>();
                     if (!PushNormalArray(array2, ref, (Size)ref->size, dest))
                         return false;
-                } else if (IsRawBuffer(value)) {
-                    Span<const uint8_t> buffer = GetRawBuffer(value);
+                } else if (Span<uint8_t> buffer = {}; TryBuffer(env, value, &buffer)) {
                     PushBuffer(buffer, ref, dest);
                 } else if (value.IsString()) {
                     if (!PushStringArray(value, ref, dest))
@@ -764,15 +746,25 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
             }
         } break;
         case PrimitiveKind::Float32: {
-            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                float f = GetNumber<float>(value);
-                *(float *)dest = f;
+            PUSH_ARRAY({
+                float f;
+                if (!TryNumber(env, value, &f)) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                    return false;
+                }
+
+                memcpy(dest, &f, 4);
             });
         } break;
         case PrimitiveKind::Float64: {
-            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                double d = GetNumber<double>(value);
-                *(double *)dest = d;
+            PUSH_ARRAY({
+                double d;
+                if (!TryNumber(env, value, &d)) [[unlikely]] {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                    return false;
+                }
+
+                memcpy(dest, &d, 8);
             });
         } break;
         case PrimitiveKind::Callback: {
@@ -796,6 +788,8 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
         case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
     }
 
+#undef PUSH_INTEGERS_SWAP
+#undef PUSH_INTEGERS
 #undef PUSH_ARRAY
 
     return true;
@@ -834,20 +828,20 @@ void CallData::PushBuffer(Span<const uint8_t> buffer, const TypeInfo *type, uint
 #undef SWAP
 }
 
-bool CallData::PushStringArray(Napi::Value obj, const TypeInfo *type, uint8_t *origin)
+bool CallData::PushStringArray(napi_value value, const TypeInfo *type, uint8_t *origin)
 {
-    K_ASSERT(obj.IsString());
+    K_ASSERT(GetKindOf(env, value) == napi_string);
     K_ASSERT(type->primitive == PrimitiveKind::Array);
 
     size_t encoded = 0;
 
     switch (type->ref.type->primitive) {
         case PrimitiveKind::Int8: {
-            napi_status status = napi_get_value_string_utf8(env, obj, (char *)origin, type->size, &encoded);
+            napi_status status = napi_get_value_string_utf8(env, value, (char *)origin, type->size, &encoded);
             K_ASSERT(status == napi_ok);
         } break;
         case PrimitiveKind::Int16: {
-            napi_status status = napi_get_value_string_utf16(env, obj, (char16_t *)origin, type->size / 2, &encoded);
+            napi_status status = napi_get_value_string_utf16(env, value, (char16_t *)origin, type->size / 2, &encoded);
             K_ASSERT(status == napi_ok);
 
             encoded *= 2;
@@ -864,190 +858,164 @@ bool CallData::PushStringArray(Napi::Value obj, const TypeInfo *type, uint8_t *o
     return true;
 }
 
-bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directions, void **out_ptr)
+bool CallData::PushPointer(napi_value value, const TypeInfo *type, int directions, void **out_ptr)
 {
-    if (CheckValueTag(value, &CastMarker)) {
-        Napi::External<ValueCast> external = value.As<Napi::External<ValueCast>>();
-        ValueCast *cast = external.Data();
-
-        value = cast->ref.Value();
-        type = cast->type;
-    }
-
-    const TypeInfo *ref = type->ref.type;
+    // In the past we were naively using napi_typeof() and a switch to "reduce" branching,
+    // but it did not match the common types very well (so there was still various if tests),
+    // and it turns out that napi_typeof() is made of successive type tests anyway so it
+    // just made things worse. Oh, well.
 
-    switch (value.Type()) {
-        case napi_undefined:
-        case napi_null: {
-            *out_ptr = nullptr;
-            return true;
-        } break;
+    void *ptr = nullptr;
 
-        case napi_external: {
-            K_ASSERT(type->primitive == PrimitiveKind::Pointer ||
-                      type->primitive == PrimitiveKind::String ||
-                      type->primitive == PrimitiveKind::String16 ||
-                      type->primitive == PrimitiveKind::String32);
+restart:
 
-            if (!CheckValueTag(value, type->ref.marker) &&
-                    !CheckValueTag(value, instance->void_type) &&
-                    ref != instance->void_type) [[unlikely]]
-                goto unexpected;
+    // Fast path
+    if (bool external = false; TryPointer(env, value, &ptr, &external)) {
+        if (external && CheckValueTag(env, value, &CastMarker)) {
+            Napi::External<ValueCast> external = Napi::External<ValueCast>(env, value);
+            ValueCast *cast = external.Data();
 
-            *out_ptr = value.As<Napi::External<uint8_t>>().Data();
-            return true;
-        } break;
+            napi_get_reference_value(env, cast->ref, &value);
+            type = cast->type;
 
-        case napi_object: {
-            uint8_t *ptr = nullptr;
+            goto restart;
+        }
 
-            OutArgument::Kind out_kind;
-            Size out_max_len = -1;
+        *out_ptr = ptr;
+        return true;
+    }
 
-            if (value.IsArray()) {
-                Napi::Array array = value.As<Napi::Array>();
-                Size len = PushIndirectString(array, ref, &ptr);
+    return PushPointerSlow(value, type, directions, out_ptr);
+}
 
-                if (len >= 0) {
-                    if (!ref->size && ref != instance->void_type) [[unlikely]] {
-                        ThrowError<Napi::TypeError>(env, "Cannot pass [string] value to %1", type->name);
-                        return false;
-                    }
-
-                    switch (ref->size) {
-                        default: { out_kind = OutArgument::Kind::String; } break;
-                        case 2: { out_kind = OutArgument::Kind::String16; } break;
-                        case 4: { out_kind = OutArgument::Kind::String32; } break;
-                    }
-                    out_max_len = len;
-                } else {
-                    if (!ref->size) [[unlikely]] {
-                        ThrowError<Napi::TypeError>(env, "Cannot pass %1 value to %2, use koffi.as()",
-                                                    ref != instance->void_type ? "opaque" : "ambiguous", type->name);
-                        return false;
-                    }
+bool CallData::PushPointerSlow(napi_value value, const TypeInfo *type, int directions, void **out_ptr)
+{
+    const TypeInfo *ref = type->ref.type;
 
-                    Size len = (Size)array.Length();
-                    Size size = len * ref->size;
+    void *ptr = nullptr;
 
-                    ptr = AllocHeap(size, 16);
+    if (IsArray(env, value)) {
+        Napi::Array array = Napi::Array(env, value);
+        Size len = PushIndirectString(array, ref, &ptr);
 
-                    if (directions & 1) {
-                        if (!PushNormalArray(array, type, size, ptr))
-                            return false;
-                    } else {
-                        MemSet(ptr, 0, size);
-                    }
+        OutArgument::Kind out_kind;
+        Size out_max_len = -1;
 
-                    out_kind = OutArgument::Kind::Array;
-                }
-            } else if (IsRawBuffer(value)) {
-                Span<uint8_t> buffer = GetRawBuffer(value);
+        if (len >= 0) {
+            if (!ref->size && ref != instance->void_type) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Cannot pass [string] value to %1", type->name);
+                return false;
+            }
 
-                // We can fast path
-                ptr = buffer.ptr;
-                directions = 1;
+            switch (ref->size) {
+                default: { out_kind = OutArgument::Kind::String; } break;
+                case 2: { out_kind = OutArgument::Kind::String16; } break;
+                case 4: { out_kind = OutArgument::Kind::String32; } break;
+            }
+            out_max_len = len;
+        } else {
+            Size size = (Size)array.Length() * ref->size;
 
-                out_kind = OutArgument::Kind::Buffer;
-            } else if (ref->primitive == PrimitiveKind::Record ||
-                       ref->primitive == PrimitiveKind::Union) [[likely]] {
-                Napi::Object obj = value.As<Napi::Object>();
-                K_ASSERT(IsObject(value));
+            if (!ref->size) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Cannot pass %1 value to %2, use koffi.as()",
+                                            ref != instance->void_type ? "opaque" : "ambiguous", type->name);
+                return false;
+            }
 
-                ptr = AllocHeap(ref->size, 16);
+            ptr = AllocHeap(size);
 
-                if (ref->primitive == PrimitiveKind::Union &&
-                        (directions & 2) && !CheckValueTag(obj, &MagicUnionMarker)) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected union value", GetValueType(instance, obj));
+            if (directions & 1) {
+                if (!PushNormalArray(array, type, size, (uint8_t *)ptr))
                     return false;
-                }
-
-                if (directions & 1) {
-                    if (!PushObject(obj, ref, ptr))
-                        return false;
-                } else {
-                    MemSet(ptr, 0, ref->size);
-                }
-
-                out_kind = OutArgument::Kind::Object;
             } else {
-                goto unexpected;
+                MemSet(ptr, 0, size);
             }
 
-            if (directions & 2) {
-                OutArgument *out = out_arguments.AppendDefault();
+            out_kind = OutArgument::Kind::Array;
+        }
 
-                napi_status status = napi_create_reference(env, value, 1, &out->ref);
-                K_ASSERT(status == napi_ok);
+        if (directions & 2) {
+            OutArgument *out = out_arguments.AppendDefault();
 
-                out->kind = out_kind;
-                out->ptr = ptr;
-                out->type = ref;
-                out->max_len = out_max_len;
-            }
+            napi_status status = napi_create_reference(env, value, 1, &out->ref);
+            K_ASSERT(status == napi_ok);
 
-            *out_ptr = ptr;
-            return true;
-        } break;
+            out->kind = out_kind;
+            out->ptr = (const uint8_t *)ptr;
+            out->type = ref;
+            out->max_len = out_max_len;
+        }
 
-        case napi_string: {
-            K_ASSERT(type->primitive == PrimitiveKind::Pointer);
+        *out_ptr = ptr;
+        return true;
+    } else if (ref->primitive == PrimitiveKind::Record ||
+               ref->primitive == PrimitiveKind::Union) [[likely]] {
+        K_ASSERT(IsObject(env, value));
 
-            if (directions & 2) [[unlikely]]
-                goto unexpected;
+        ptr = (void *)AllocHeap(ref->size);
 
-            if (ref == instance->void_type) {
-                PushStringValue(value, (const char **)out_ptr);
-                return true;
-            } else if (ref->primitive == PrimitiveKind::Int8) {
-                PushStringValue(value, (const char **)out_ptr);
-                return true;
-            } else if (ref->primitive == PrimitiveKind::Int16) {
-                PushString16Value(value, (const char16_t **)out_ptr);
-                return true;
-            } else if (ref->primitive == PrimitiveKind::Int32) {
-                PushString32Value(value, (const char32_t **)out_ptr);
-                return true;
-            } else {
-                goto unexpected;
-            }
-        } break;
+        if (ref->primitive == PrimitiveKind::Union &&
+                (directions & 2) && !CheckValueTag(env, value, &UnionClassMarker)) [[unlikely]] {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected union value", GetValueType(instance, value));
+            return false;
+        }
 
-        case napi_function: {
-            if (type->primitive != PrimitiveKind::Callback) [[unlikely]] {
-                ThrowError<Napi::TypeError>(env, "Cannot pass function to type %1", type->name);
+        if (directions & 1) {
+            if (!PushObject(value, ref, (uint8_t *)ptr))
                 return false;
-            }
+        } else {
+            MemSet(ptr, 0, ref->size);
+        }
 
-            Napi::Function func = value.As<Napi::Function>();
+        if (directions & 2) {
+            OutArgument *out = out_arguments.AppendDefault();
 
-            void *ptr = ReserveTrampoline(type->ref.proto, func);
-            if (!ptr) [[unlikely]]
-                return false;
+            napi_status status = napi_create_reference(env, value, 1, &out->ref);
+            K_ASSERT(status == napi_ok);
 
-            *out_ptr = (void *)ptr;
-            return true;
-        } break;
+            out->kind = OutArgument::Kind::Object;
+            out->ptr = (const uint8_t *)ptr;
+            out->type = ref;
+            out->max_len = -1;
+        }
+
+        *out_ptr = ptr;
+        return true;
+    } else if (napi_valuetype kind = GetKindOf(env, value); kind == napi_string) {
+        K_ASSERT(type->primitive == PrimitiveKind::Pointer);
 
-        case napi_number: {
-            Napi::Number number = value.As<Napi::Number>();
-            intptr_t ptr = (intptr_t)number.Int32Value();
+        if (directions & 2) [[unlikely]]
+            goto unexpected;
 
-            *out_ptr = (void *)ptr;
+        if (ref == instance->void_type) {
+            PushStringValue(value, (const char **)out_ptr);
             return true;
-        } break;
-
-        case napi_bigint: {
-            Napi::BigInt bigint = value.As<Napi::BigInt>();
+        } else if (ref->primitive == PrimitiveKind::Int8) {
+            PushStringValue(value, (const char **)out_ptr);
+            return true;
+        } else if (ref->primitive == PrimitiveKind::Int16) {
+            PushString16Value(value, (const char16_t **)out_ptr);
+            return true;
+        } else if (ref->primitive == PrimitiveKind::Int32) {
+            PushString32Value(value, (const char32_t **)out_ptr);
+            return true;
+        } else {
+            goto unexpected;
+        }
+    } else if (kind == napi_function) {
+        if (type->primitive != PrimitiveKind::Callback) [[unlikely]] {
+            ThrowError<Napi::TypeError>(env, "Cannot pass function to type %1", type->name);
+            return false;
+        }
 
-            bool lossless;
-            intptr_t ptr = (intptr_t)bigint.Int64Value(&lossless);
+        Napi::Function func = Napi::Function(env, value);
 
-            *out_ptr = (void *)ptr;
-            return true;
-        } break;
+        ptr = ReserveTrampoline(type->ref.proto, func);
+        if (!ptr) [[unlikely]]
+            return false;
 
-        default: {} break;
+        *out_ptr = (void *)ptr;
+        return true;
     }
 
 unexpected:
@@ -1055,51 +1023,47 @@ unexpected:
     return false;
 }
 
-bool CallData::PushCallback(Napi::Value value, const TypeInfo *type, void **out_ptr)
+bool CallData::PushCallback(napi_value value, const TypeInfo *type, void **out_ptr)
 {
-    if (value.IsFunction()) {
-        Napi::Function func = value.As<Napi::Function>();
+    void *ptr = nullptr;
 
-        void *ptr = ReserveTrampoline(type->ref.proto, func);
-        if (!ptr) [[unlikely]]
-            return false;
+restart:
 
-        *out_ptr = ptr;
-    } else if (CheckValueTag(value, type->ref.marker)) {
-        *out_ptr = value.As<Napi::External<void>>().Data();
-    } else if (CheckValueTag(value, &CastMarker)) {
-        Napi::External<ValueCast> external = value.As<Napi::External<ValueCast>>();
-        ValueCast *cast = external.Data();
+    if (bool external = false; TryPointer(env, value, &ptr, &external)) {
+        if (external && CheckValueTag(env, value, &CastMarker)) {
+            Napi::External<ValueCast> external = Napi::External<ValueCast>(env, value);
+            ValueCast *cast = external.Data();
 
-        value = cast->ref.Value();
+            napi_get_reference_value(env, cast->ref, &value);
+            type = cast->type;
 
-        if (!value.IsExternal() || cast->type != type)
-            goto unexpected;
+            goto restart;
+        }
 
-        *out_ptr = value.As<Napi::External<void>>().Data();
-    } else if (IsNullOrUndefined(value)) {
-        *out_ptr = nullptr;
-    } else {
-        goto unexpected;
-    }
+        *out_ptr = ptr;
+        return true;
+    } else if (GetKindOf(env, value) == napi_function) {
+        Napi::Function func = Napi::Function(env, value);
 
-    return true;
+        ptr = ReserveTrampoline(type->ref.proto, func);
+        if (!ptr) [[unlikely]]
+            return false;
+
+        *out_ptr = ptr;
+        return true;
+    }
 
-unexpected:
     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected %2", GetValueType(instance, value), type->name);
     return false;
 }
 
-Size CallData::PushIndirectString(Napi::Array array, const TypeInfo *ref, uint8_t **out_ptr)
+Size CallData::PushIndirectString(Napi::Array array, const TypeInfo *ref, void **out_ptr)
 {
     if (array.Length() != 1)
         return -1;
 
     Napi::Value value = array[0u];
 
-    if (!value.IsString())
-        return -1;
-
     if (ref == instance->void_type) {
         return PushStringValue(value, (const char **)out_ptr);
     } else if (ref->primitive == PrimitiveKind::Int8) {
@@ -1137,67 +1101,48 @@ void *CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func
 
     TrampolineInfo *trampoline = &shared.trampolines[idx];
 
+    trampoline->state = 1;
     trampoline->instance = instance;
     trampoline->proto = proto;
     trampoline->func.Reset(func, 1);
     trampoline->recv.Reset();
-    trampoline->used = true;
 
     void *ptr = GetTrampoline(idx);
 
     return ptr;
 }
 
-void CallData::DumpForward(const FunctionInfo *func) const
-{
-    PrintLn(StdErr, "%!..+---- %1 (%2) ----%!0", func->name, CallConventionNames[(int)func->convention]);
-
-    if (func->parameters.len) {
-        PrintLn(StdErr, "Parameters:");
-        for (Size i = 0; i < func->parameters.len; i++) {
-            const ParameterInfo &param = func->parameters[i];
-            PrintLn(StdErr, "  %1 = %2 (%3)", i, param.type->name, FmtMemSize(param.type->size));
-        }
-    }
-    PrintLn(StdErr, "Return: %1 (%2)", func->ret.type->name, FmtMemSize(func->ret.type->size));
-
-    Span<const uint8_t> stack = MakeSpan(mem->stack.end(), old_stack_mem.end() - mem->stack.end());
-    Span<const uint8_t> heap = MakeSpan(old_heap_mem.ptr, mem->heap.ptr - old_heap_mem.ptr);
-
-    DumpMemory("Stack", stack);
-    DumpMemory("Heap", heap);
-}
-
-bool CallData::CheckDynamicLength(Napi::Object obj, Size element, const char *countedby, Napi::Value value)
+bool CallData::CheckDynamicLength(napi_value obj, Size element, const char *countedby, napi_value value)
 {
     int64_t expected = -1;
     int64_t size = -1;
 
     // Get expected size
     {
-        Napi::Value by = obj.Get(countedby);
+        napi_value by;
+        napi_status status = napi_get_named_property(env, obj, countedby, &by);
 
-        if (!by.IsNumber() && !by.IsBigInt()) [[unlikely]] {
+        if (status != napi_ok || !TryNumber(env, by, &expected)) [[unlikely]] {
             ThrowError<Napi::Error>(env, "Unexpected %1 value for dynamic length, expected number", GetValueType(instance, by));
             return false;
         }
 
         // If we get anywhere near overflow there are other problems to worry about.
         // So let's not worry about that.
-        expected = GetNumber<int64_t>(by) * element;
+        expected *= element;
     }
 
     // Get actual size
-    if (value.IsArray()) {
-        Napi::Array array = value.As<Napi::Array>();
+    if (IsArray(env, value)) {
+        Napi::Array array = Napi::Array(env, value);
         size = array.Length() * element;
-    } else if (value.IsTypedArray()) {
-        Napi::TypedArray typed = value.As<Napi::TypedArray>();
+    } else if (IsTypedArray(env, value)) {
+        Napi::TypedArray typed = Napi::TypedArray(env, value);
         size = typed.ByteLength();
-    } else if (value.IsArrayBuffer()) {
-        Napi::ArrayBuffer buffer = value.As<Napi::ArrayBuffer>();
+    } else if (IsArrayBuffer(env, value)) {
+        Napi::ArrayBuffer buffer = Napi::ArrayBuffer(env, value);
         size = buffer.ByteLength();
-    } else if (!IsNullOrUndefined(value)) {
+    } else if (!IsNullOrUndefined(env, value)) {
         size = element;
     } else {
         size = 0;
@@ -1211,98 +1156,13 @@ bool CallData::CheckDynamicLength(Napi::Object obj, Size element, const char *co
     return true;
 }
 
-static inline Napi::Value GetReferenceValue(Napi::Env env, napi_ref ref)
-{
-    napi_value value;
-
-    napi_status status = napi_get_reference_value(env, ref, &value);
-    K_ASSERT(status == napi_ok);
-
-    return Napi::Value(env, value);
-}
-
-void CallData::PopOutArguments()
-{
-    for (const OutArgument &out: out_arguments) {
-        Napi::Value value = GetReferenceValue(env, out.ref);
-        K_ASSERT(!value.IsEmpty());
-
-        switch (out.kind) {
-            case OutArgument::Kind::Array: {
-                K_ASSERT(value.IsArray());
-
-                Napi::Array array(env, value);
-                DecodeNormalArray(array, out.ptr, out.type);
-            } break;
-
-            case OutArgument::Kind::Buffer: {
-                K_ASSERT(IsRawBuffer(value));
-
-                Span<uint8_t> buffer = GetRawBuffer(value);
-                DecodeBuffer(buffer, out.ptr, out.type);
-            } break;
-
-            case OutArgument::Kind::String: {
-                Napi::Array array(env, value);
-
-                K_ASSERT(array.IsArray());
-                K_ASSERT(array.Length() == 1);
-
-                Size len = strnlen((const char *)out.ptr, out.max_len);
-                Napi::String str = Napi::String::New(env, (const char *)out.ptr, len);
-
-                array.Set(0u, str);
-            } break;
-
-            case OutArgument::Kind::String16: {
-                Napi::Array array(env, value);
-
-                K_ASSERT(array.IsArray());
-                K_ASSERT(array.Length() == 1);
-
-                Size len = NullTerminatedLength((const char16_t *)out.ptr, out.max_len);
-                Napi::String str = Napi::String::New(env, (const char16_t *)out.ptr, len);
-
-                array.Set(0u, str);
-            } break;
-
-            case OutArgument::Kind::String32: {
-                Napi::Array array(env, value);
-
-                K_ASSERT(array.IsArray());
-                K_ASSERT(array.Length() == 1);
-
-                Size len = NullTerminatedLength((const char32_t *)out.ptr, out.max_len);
-                Napi::String str = MakeStringFromUTF32(env, (const char32_t *)out.ptr, len);
-
-                array.Set(0u, str);
-            } break;
-
-            case OutArgument::Kind::Object: {
-                Napi::Object obj = value.As<Napi::Object>();
-
-                if (CheckValueTag(value, &MagicUnionMarker)) {
-                    MagicUnion *u = MagicUnion::Unwrap(obj);
-                    u->SetRaw(out.ptr);
-                } else {
-                    DecodeObject(obj, out.ptr, out.type);
-                }
-            } break;
-        }
-    }
-}
-
 void PerformAsyncRelay(napi_env, napi_value, void *, void *udata)
 {
     RelayContext *ctx = (RelayContext *)udata;
     CallData *call = ctx->call;
 
     call->Relay(ctx->idx, ctx->sp);
-
-    // This CallData was created artificially just to perform the callback. Which means the
-    // creator may not run on the main thread, and cannot properly destroy it, because some
-    // members are managed by Node.
-    call->Dispose();
+    call->Finalize();
 
     // We're done!
     std::lock_guard<std::mutex> lock(ctx->mutex);