koffi 3.0.0 → 3.0.1

package/src/koffi/src/util.cc

@@ -17,6 +17,8 @@ const napi_type_tag DirectionMarker = { 0xf9c306238b480580, 0xc2e168524a0823f5 }
 const napi_type_tag UnionValueMarker = { 0x5eaf2245526a4c7d, 0x8c86c9ee2b96ffc8 };
 const napi_type_tag CastMarker = { 0x77f459614a0a412f, 0x80b3dda1341dc8df };
 
+#if !defined(EXTERNAL_TYPES)
+
 Napi::Function TypeObject::InitClass(Napi::Env env)
 {
     Napi::Function constructor = DefineClass(env, "TypeObject", {});
@@ -43,6 +45,8 @@ void TypeObject::Finalize(Napi::BasicEnv env)
     SuppressDestruct();
 }
 
+#endif
+
 Napi::Function UnionValue::InitClass(Napi::Env env, const TypeInfo *type)
 {
     K_ASSERT(type->primitive == PrimitiveKind::Union);
@@ -104,7 +108,7 @@ Napi::Value UnionValue::Getter(const Napi::CallbackInfo &info)
     Size idx = (Size)info.Data();
     const RecordMember &member = type->members[idx];
 
-    Napi::Value value;
+    napi_value value = nullptr;
 
     if (idx == active_idx) {
         value = Value().Get(instance->active_symbol.Value());
@@ -116,14 +120,14 @@ Napi::Value UnionValue::Getter(const Napi::CallbackInfo &info)
             return env.Null();
         }
 
-        value = Decode(env, raw.ptr, member.type);
+        value = Decode(instance, raw.ptr, member.type);
 
         Value().Set(instance->active_symbol.Value(), value);
         active_idx = idx;
     }
 
-    K_ASSERT(!value.IsEmpty());
-    return value;
+    K_ASSERT(value);
+    return Napi::Value(info.Env(), value);
 }
 
 void UnionValue::Setter(const Napi::CallbackInfo &info, const Napi::Value &value)
@@ -240,6 +244,16 @@ const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
             }
 
             return type;
+#if defined(EXTERNAL_TYPES)
+        } else if (kind == napi_external && CheckValueTag(env, value, &TypeObjectMarker)) {
+            Napi::External<TypeInfo> external = Napi::External<TypeInfo>(env, value);
+            const TypeInfo *type = external.Data();
+
+            if (out_directions) {
+                *out_directions = 1;
+            }
+            return type;
+#else
         } else if (kind == napi_object && CheckValueTag(env, value, &TypeObjectMarker)) {
             TypeObject *defn = nullptr;
             napi_unwrap(env, value, (void **)&defn);
@@ -248,6 +262,7 @@ const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
                 *out_directions = 1;
             }
             return defn->GetType();
+#endif
         } else {
             ThrowError<Napi::TypeError>(env, "Unexpected %1 value as type specifier, expected string or type", GetValueType(instance, value));
             return nullptr;
@@ -513,14 +528,18 @@ TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, A
     return MakeArrayType(instance, ref, len, hint, false);
 }
 
-Napi::Object WrapType(Napi::Env env, const TypeInfo *type, bool freeze)
+Napi::Value WrapType(Napi::Env env, const TypeInfo *type, bool freeze)
 {
     if (type->defn.IsEmpty()) {
+#if defined(EXTERNAL_TYPES)
+        Napi::Object defn = Napi::Object::New(env);
+#else
         InstanceData *instance = env.GetInstanceData<InstanceData>();
 
         Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)type);
         Napi::Object defn = instance->construct_type.New({ external });
         SetValueTag(env, defn, &TypeObjectMarker);
+#endif
 
         defn.Set("name", Napi::String::New(env, type->name));
         defn.Set("primitive", PrimitiveKindNames[(int)type->primitive]);
@@ -592,7 +611,14 @@ Napi::Object WrapType(Napi::Env env, const TypeInfo *type, bool freeze)
         }
     }
 
+#if defined(EXTERNAL_TYPES)
+    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)type);
+    SetValueTag(env, external, &TypeObjectMarker);
+
+    return external;
+#else
     return type->defn.Value();
+#endif
 }
 
 const TypeInfo *ReshapeType(InstanceData *instance, const TypeInfo *type, int32_t stride, uint16_t flags)
@@ -868,23 +894,6 @@ Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *ptr, Size len)
     return str;
 }
 
-Napi::Object DecodeObject(Napi::Env env, const uint8_t *origin, const TypeInfo *type)
-{
-    // We can't decode unions because we don't know which member is valid
-    if (type->primitive == PrimitiveKind::Union) {
-        Napi::External<void> external = Napi::External<void>::New(env, (void *)origin);
-        Napi::Object wrapper = type->construct.New({ external }).As<Napi::Object>();
-        SetValueTag(env, wrapper, &UnionValueMarker);
-
-        return wrapper;
-    }
-
-    Napi::Object obj = Napi::Object::New(env);
-    DecodeObject(env, obj, origin, type);
-
-    return obj;
-}
-
 static uint32_t DecodeDynamicLength(const uint8_t *origin, const RecordMember &by)
 {
     const uint8_t *src = origin + by.offset;
@@ -977,27 +986,16 @@ static uint32_t DecodeDynamicLength(const uint8_t *origin, const RecordMember &b
     K_UNREACHABLE();
 }
 
-static inline void SetMemberValue(napi_env env, napi_value obj, const RecordMember &member, napi_value value)
-{
-    if (member.key) {
-        napi_value key = nullptr;
-        napi_get_reference_value(env, member.key, &key);
-
-        napi_status status = napi_set_property(env, obj, key, value);
-        K_ASSERT(status == napi_ok);
-    } else {
-        napi_status status = napi_set_named_property(env, obj, member.name, value);
-        K_ASSERT(status == napi_ok);
-    }
-}
-
-void DecodeObject(Napi::Env env, napi_value obj, const uint8_t *origin, const TypeInfo *type)
+template <typename SetFunc>
+static FORCE_INLINE void DecodeObject(InstanceData *instance, const uint8_t *origin, const TypeInfo *type, SetFunc set)
 {
     K_ASSERT(type->primitive == PrimitiveKind::Record);
 
+    Napi::Env env = instance->env;
     Span<const RecordMember> members = type->members;
 
-    for (const RecordMember &member: members) {
+    for (Size i = 0; i < members.len; i++) {
+        const RecordMember &member = members[i];
         const uint8_t *src = origin + member.offset;
 
         switch (member.type->primitive) {
@@ -1005,80 +1003,80 @@ void DecodeObject(Napi::Env env, napi_value obj, const uint8_t *origin, const Ty
 
             case PrimitiveKind::Bool: {
                 bool b = *(bool *)src;
-                SetMemberValue(env, obj, member, Napi::Boolean::New(env, b));
+                set(i, member, Napi::Boolean::New(env, b));
             } break;
             case PrimitiveKind::Int8: {
-                int8_t i = *(int8_t *)src;
-                SetMemberValue(env, obj, member, NewInt(env, i));
+                int8_t v = *(int8_t *)src;
+                set(i, member, NewInt(env, v));
             } break;
             case PrimitiveKind::UInt8: {
-                uint8_t u = *(uint8_t *)src;
-                SetMemberValue(env, obj, member, NewInt(env, u));
+                uint8_t v = *(uint8_t *)src;
+                set(i, member, NewInt(env, v));
             } break;
             case PrimitiveKind::Int16: {
-                int16_t i;
-                memcpy(&i, src, 2);
-                SetMemberValue(env, obj, member, NewInt(env, i));
+                int16_t v;
+                memcpy(&v, src, 2);
+                set(i, member, NewInt(env, v));
             } break;
             case PrimitiveKind::Int16S: {
-                int16_t i;
-                memcpy(&i, src, 2);
-                SetMemberValue(env, obj, member, NewInt(env, ReverseBytes(i)));
+                int16_t v;
+                memcpy(&v, src, 2);
+                set(i, member, NewInt(env, ReverseBytes(v)));
             } break;
             case PrimitiveKind::UInt16: {
-                uint16_t u;
-                memcpy(&u, src, 2);
-                SetMemberValue(env, obj, member, NewInt(env, u));
+                uint16_t v;
+                memcpy(&v, src, 2);
+                set(i, member, NewInt(env, v));
             } break;
             case PrimitiveKind::UInt16S: {
-                uint16_t u;
-                memcpy(&u, src, 2);
-                SetMemberValue(env, obj, member, NewInt(env, ReverseBytes(u)));
+                uint16_t v;
+                memcpy(&v, src, 2);
+                set(i, member, NewInt(env, ReverseBytes(v)));
             } break;
             case PrimitiveKind::Int32: {
-                int32_t i;
-                memcpy(&i, src, 4);
-                SetMemberValue(env, obj, member, NewInt(env, i));
+                int32_t v;
+                memcpy(&v, src, 4);
+                set(i, member, NewInt(env, v));
             } break;
             case PrimitiveKind::Int32S: {
-                int32_t i;
-                memcpy(&i, src, 4);
-                SetMemberValue(env, obj, member, NewInt(env, ReverseBytes(i)));
+                int32_t v;
+                memcpy(&v, src, 4);
+                set(i, member, NewInt(env, ReverseBytes(v)));
             } break;
             case PrimitiveKind::UInt32: {
-                uint32_t u;
-                memcpy(&u, src, 4);
-                SetMemberValue(env, obj, member, NewInt(env, u));
+                uint32_t v;
+                memcpy(&v, src, 4);
+                set(i, member, NewInt(env, v));
             } break;
             case PrimitiveKind::UInt32S: {
-                uint32_t u;
-                memcpy(&u, src, 4);
-                SetMemberValue(env, obj, member, NewInt(env, ReverseBytes(u)));
+                uint32_t v;
+                memcpy(&v, src, 4);
+                set(i, member, NewInt(env, ReverseBytes(v)));
             } break;
             case PrimitiveKind::Int64: {
-                int64_t i;
-                memcpy(&i, src, 8);
-                SetMemberValue(env, obj, member, NewInt(env, i));
+                int64_t v;
+                memcpy(&v, src, 8);
+                set(i, member, NewInt(env, v));
             } break;
             case PrimitiveKind::Int64S: {
-                int64_t i;
-                memcpy(&i, src, 8);
-                SetMemberValue(env, obj, member, NewInt(env, ReverseBytes(i)));
+                int64_t v;
+                memcpy(&v, src, 8);
+                set(i, member, NewInt(env, ReverseBytes(v)));
             } break;
             case PrimitiveKind::UInt64: {
-                uint64_t u;
-                memcpy(&u, src, 8);
-                SetMemberValue(env, obj, member, NewInt(env, u));
+                uint64_t v;
+                memcpy(&v, src, 8);
+                set(i, member, NewInt(env, v));
             } break;
             case PrimitiveKind::UInt64S: {
-                uint64_t u;
-                memcpy(&u, src, 8);
-                SetMemberValue(env, obj, member, NewInt(env, ReverseBytes(u)));
+                uint64_t v;
+                memcpy(&v, src, 8);
+                set(i, member, NewInt(env, ReverseBytes(v)));
             } break;
             case PrimitiveKind::String: {
                 const char *str;
                 memcpy(&str, src, K_SIZE(void *));
-                SetMemberValue(env, obj, member, str ? Napi::String::New(env, str) : env.Null());
+                set(i, member, str ? Napi::String::New(env, str) : env.Null());
 
                 if (member.type->dispose) {
                     member.type->dispose(env, member.type, str);
@@ -1087,7 +1085,7 @@ void DecodeObject(Napi::Env env, napi_value obj, const uint8_t *origin, const Ty
             case PrimitiveKind::String16: {
                 const char16_t *str16;
                 memcpy(&str16, src, K_SIZE(void *));
-                SetMemberValue(env, obj, member, str16 ? Napi::String::New(env, str16) : env.Null());
+                set(i, member, str16 ? Napi::String::New(env, str16) : env.Null());
 
                 if (member.type->dispose) {
                     member.type->dispose(env, member.type, str16);
@@ -1096,7 +1094,7 @@ void DecodeObject(Napi::Env env, napi_value obj, const uint8_t *origin, const Ty
             case PrimitiveKind::String32: {
                 const char32_t *str32;
                 memcpy(&str32, src, K_SIZE(void *));
-                SetMemberValue(env, obj, member, str32 ? MakeStringFromUTF32(env, str32) : env.Null());
+                set(i, member, str32 ? MakeStringFromUTF32(env, str32) : env.Null());
             } break;
             case PrimitiveKind::Pointer: {
                 void *ptr2;
@@ -1106,11 +1104,11 @@ void DecodeObject(Napi::Env env, napi_value obj, const uint8_t *origin, const Ty
                     const RecordMember &by = members[member.countedby];
                     uint32_t len = DecodeDynamicLength(origin, by);
 
-                    Napi::Value value = DecodeArray(env, (const uint8_t *)ptr2, member.type, len);
-                    SetMemberValue(env, obj, member, value);
+                    napi_value value = DecodeArray(instance, (const uint8_t *)ptr2, member.type, len);
+                    set(i, member, value);
                 } else {
-                    Napi::Value p = ptr2 ? WrapPointer(env, member.type->ref.type, ptr2) : env.Null();
-                    SetMemberValue(env, obj, member, p);
+                    napi_value p = ptr2 ? WrapPointer(env, member.type->ref.type, ptr2) : env.Null();
+                    set(i, member, p);
                 }
 
                 if (member.type->dispose) {
@@ -1121,8 +1119,8 @@ void DecodeObject(Napi::Env env, napi_value obj, const uint8_t *origin, const Ty
                 void *ptr2;
                 memcpy(&ptr2, src, K_SIZE(void *));
 
-                Napi::Value p = ptr2 ? WrapPointer(env, member.type->ref.type, ptr2) : env.Null();
-                SetMemberValue(env, obj, member, p);
+                napi_value p = ptr2 ? WrapPointer(env, member.type->ref.type, ptr2) : env.Null();
+                set(i, member, p);
 
                 if (member.type->dispose) {
                     member.type->dispose(env, member.type, ptr2);
@@ -1130,8 +1128,8 @@ void DecodeObject(Napi::Env env, napi_value obj, const uint8_t *origin, const Ty
             } break;
             case PrimitiveKind::Record:
             case PrimitiveKind::Union: {
-                Napi::Object obj2 = DecodeObject(env, src, member.type);
-                SetMemberValue(env, obj, member, obj2);
+                napi_value obj2 = DecodeObject(instance, src, member.type);
+                set(i, member, obj2);
             } break;
             case PrimitiveKind::Array: {
                 if (member.countedby >= 0) {
@@ -1143,22 +1141,22 @@ void DecodeObject(Napi::Env env, napi_value obj, const uint8_t *origin, const Ty
                     // Silently truncate result
                     len = std::min(len, max);
 
-                    Napi::Value value = DecodeArray(env, src, member.type, len);
-                    SetMemberValue(env, obj, member, value);
+                    napi_value value = DecodeArray(instance, src, member.type, len);
+                    set(i, member, value);
                 } else {
-                    Napi::Value value = DecodeArray(env, src, member.type);
-                    SetMemberValue(env, obj, member, value);
+                    napi_value value = DecodeArray(instance, src, member.type);
+                    set(i, member, value);
                 }
             } break;
             case PrimitiveKind::Float32: {
                 float f;
                 memcpy(&f, src, 4);
-                SetMemberValue(env, obj, member, Napi::Number::New(env, (double)f));
+                set(i, member, Napi::Number::New(env, (double)f));
             } break;
             case PrimitiveKind::Float64: {
                 double d;
                 memcpy(&d, src, 8);
-                SetMemberValue(env, obj, member, Napi::Number::New(env, d));
+                set(i, member, Napi::Number::New(env, d));
             } break;
 
             case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
@@ -1166,18 +1164,77 @@ void DecodeObject(Napi::Env env, napi_value obj, const uint8_t *origin, const Ty
     }
 }
 
-Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type)
+napi_value DecodeObject(InstanceData *instance, const uint8_t *origin, const TypeInfo *type)
+{
+    Napi::Env env = instance->env;
+
+    // We can't decode unions because we don't know which member is valid
+    if (type->primitive == PrimitiveKind::Union) {
+        Napi::External<void> external = Napi::External<void>::New(env, (void *)origin);
+        Napi::Object wrapper = type->construct.New({ external }).As<Napi::Object>();
+        SetValueTag(env, wrapper, &UnionValueMarker);
+
+        return wrapper;
+    }
+
+    // Only supported in recent Node versions, and still experimental at this time
+    if (node_api_create_object_with_properties && type->members.len <= 256) {
+        napi_value properties[256];
+        napi_value values[256];
+
+        DecodeObject(instance, origin, type, [&](Size i, const RecordMember &member, napi_value value) {
+            napi_status status = napi_get_reference_value(env, member.key, &properties[i]);
+            K_ASSERT(status == napi_ok);
+
+            values[i] = value;
+        });
+
+        napi_value obj;
+        napi_status status = node_api_create_object_with_properties(env, instance->object_constructor.Value(), properties, values, type->members.len, &obj);
+        K_ASSERT(status == napi_ok);
+
+        return obj;
+    }
+
+    Napi::Object obj = Napi::Object::New(env);
+    DecodeObject(instance, obj, origin, type);
+
+    return obj;
+}
+
+void DecodeObject(InstanceData *instance, napi_value obj, const uint8_t *origin, const TypeInfo *type)
+{
+    Napi::Env env = instance->env;
+
+    if (node_api_create_property_key_utf8) {
+        DecodeObject(instance, origin, type, [&](Size i, const RecordMember &member, napi_value value) {
+            napi_value key = nullptr;
+            napi_get_reference_value(env, member.key, &key);
+
+            napi_status status = napi_set_property(env, obj, key, value);
+            K_ASSERT(status == napi_ok);
+        });
+    } else {
+        DecodeObject(instance, origin, type, [&](Size i, const RecordMember &member, napi_value value) {
+            napi_status status = napi_set_named_property(env, obj, member.name, value);
+            K_ASSERT(status == napi_ok);
+        });
+    }
+}
+
+napi_value DecodeArray(InstanceData *instance, const uint8_t *origin, const TypeInfo *type)
 {
     K_ASSERT(type->primitive == PrimitiveKind::Array);
 
     uint32_t len = type->size / type->ref.stride;
-    return DecodeArray(env, origin, type, len);
+    return DecodeArray(instance, origin, type, len);
 }
 
-Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type, uint32_t len)
+napi_value DecodeArray(InstanceData *instance, const uint8_t *origin, const TypeInfo *type, uint32_t len)
 {
     K_ASSERT(type->primitive == PrimitiveKind::Array || type->primitive == PrimitiveKind::Pointer);
 
+    Napi::Env env = instance->env;
     const TypeInfo *ref = type->ref.type;
     int32_t stride = type->ref.stride;
 
@@ -1279,7 +1336,7 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
         K_ASSERT(type->hint == ArrayHint::Array);
 
         Napi::Array array = Napi::Array::New(env);
-        DecodeElements(env, array, origin, type, len);
+        DecodeElements(instance, array, origin, type, len);
 
         return array;
     }
@@ -1287,10 +1344,11 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
     K_UNREACHABLE();
 }
 
-void DecodeElements(Napi::Env env, napi_value array, const uint8_t *origin, const TypeInfo *type, uint32_t len)
+void DecodeElements(InstanceData *instance, napi_value array, const uint8_t *origin, const TypeInfo *type, uint32_t len)
 {
-    K_ASSERT(IsArray(env, array));
+    K_ASSERT(IsArray(instance->env, array));
 
+    Napi::Env env = instance->env;
     const TypeInfo *ref = type->ref.type;
     int32_t stride = type->ref.stride;
 
@@ -1377,7 +1435,7 @@ void DecodeElements(Napi::Env env, napi_value array, const uint8_t *origin, cons
             POP_ARRAY({
                 void *ptr2 = *(void **)src;
 
-                Napi::Value p = ptr2 ? WrapPointer(env, ref->ref.type, ptr2) : env.Null();
+                napi_value p = ptr2 ? WrapPointer(env, ref->ref.type, ptr2) : env.Null();
                 napi_set_element(env, array, i, p);
 
                 if (ref->dispose) {
@@ -1389,7 +1447,7 @@ void DecodeElements(Napi::Env env, napi_value array, const uint8_t *origin, cons
             POP_ARRAY({
                 void *ptr2 = *(void **)src;
 
-                Napi::Value p = ptr2 ? WrapPointer(env, ref->ref.type, ptr2) : env.Null();
+                napi_value p = ptr2 ? WrapPointer(env, ref->ref.type, ptr2) : env.Null();
                 napi_set_element(env, array, i, p);
 
                 if (ref->dispose) {
@@ -1400,13 +1458,13 @@ void DecodeElements(Napi::Env env, napi_value array, const uint8_t *origin, cons
         case PrimitiveKind::Record:
         case PrimitiveKind::Union: {
             POP_ARRAY({
-                Napi::Object obj = DecodeObject(env, src, ref);
+                napi_value obj = DecodeObject(instance, src, ref);
                 napi_set_element(env, array, i, obj);
             });
         } break;
         case PrimitiveKind::Array: {
             POP_ARRAY({
-                Napi::Value value = DecodeArray(env, src, ref);
+                napi_value value = DecodeArray(instance, src, ref);
                 napi_set_element(env, array, i, value);
             });
         } break;
@@ -1476,7 +1534,7 @@ void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *t
 #undef SWAP
 }
 
-Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, const Size *len)
+napi_value Decode(Napi::Value value, Size offset, const TypeInfo *type, const Size *len)
 {
     Napi::Env env = value.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
@@ -1506,13 +1564,12 @@ Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, const S
         return env.Null();
     src += offset;
 
-    Napi::Value ret = Decode(env, src, type, len);
-    return ret;
+    return Decode(instance, src, type, len);
 }
 
-Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, const Size *len)
+napi_value Decode(InstanceData *instance, const uint8_t *ptr, const TypeInfo *type, const Size *len)
 {
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    Napi::Env env = instance->env;
 
     if (len && type->primitive != PrimitiveKind::String &&
                type->primitive != PrimitiveKind::String16 &&
@@ -1554,12 +1611,12 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
 #define RETURN_INT(Type, NewCall) \
         do { \
             Type v = *(Type *)ptr; \
-            return Napi::Value(env, NewCall(env, v)); \
+            return NewCall(env, v); \
         } while (false)
 #define RETURN_INT_SWAP(Type, NewCall) \
         do { \
             Type v = ReverseBytes(*(Type *)ptr); \
-            return Napi::Value(env, NewCall(env, v)); \
+            return NewCall(env, v); \
         } while (false)
 
     switch (type->primitive) {
@@ -1622,12 +1679,9 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
             return ptr2 ? WrapPointer(env, type->ref.type, ptr2) : env.Null();
         } break;
         case PrimitiveKind::Record:
-        case PrimitiveKind::Union: {
-            Napi::Object obj = DecodeObject(env, ptr, type);
-            return obj;
-        } break;
+        case PrimitiveKind::Union: { return DecodeObject(instance, ptr, type); } break;
         case PrimitiveKind::Array: {
-            Napi::Value array = DecodeArray(env, ptr, type);
+            napi_value array = DecodeArray(instance, ptr, type);
             return array;
         } break;
         case PrimitiveKind::Float32: {
@@ -1704,12 +1758,12 @@ bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *typ
     }
     dest += offset;
 
-    return Encode(env, dest, value, type, len);
+    return Encode(instance, dest, value, type, len);
 }
 
-bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *type, const Size *len)
+bool Encode(InstanceData *instance, uint8_t *origin, Napi::Value value, const TypeInfo *type, const Size *len)
 {
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    Napi::Env env = instance->env;
 
     if (len && type->primitive != PrimitiveKind::String &&
                type->primitive != PrimitiveKind::String16 &&

package/src/koffi/src/util.hh

@@ -10,8 +10,6 @@
 
 namespace K {
 
-// #define EXTERNAL_POINTERS
-
 #if defined(_MSC_VER)
     #define FORCE_INLINE __forceinline
 #else
@@ -40,6 +38,8 @@ extern const napi_type_tag DirectionMarker;
 extern const napi_type_tag UnionValueMarker;
 extern const napi_type_tag CastMarker;
 
+#if !defined(EXTERNAL_TYPES)
+
 class TypeObject: public Napi::ObjectWrap<TypeObject> {
     const TypeInfo *type;
 
@@ -55,6 +55,8 @@ public:
     const TypeInfo *GetType() { return type; }
 };
 
+#endif
+
 class UnionValue: public Napi::ObjectWrap<UnionValue> {
     InstanceData *instance;
     const TypeInfo *type;
@@ -119,7 +121,7 @@ TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int count
 TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len);
 TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, ArrayHint hint);
 
-Napi::Object WrapType(Napi::Env env, const TypeInfo *type, bool freeze = true);
+Napi::Value WrapType(Napi::Env env, const TypeInfo *type, bool freeze = true);
 
 const TypeInfo *ReshapeType(InstanceData *instance, const TypeInfo *type, int32_t stride, uint16_t flags);
 
@@ -403,19 +405,19 @@ Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *ptr, Size len);
 static inline Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *ptr)
     { return MakeStringFromUTF32(env, ptr, NullTerminatedLength(ptr)); }
 
-Napi::Object DecodeObject(Napi::Env env, const uint8_t *origin, const TypeInfo *type);
-void DecodeObject(Napi::Env env, napi_value obj, const uint8_t *origin, const TypeInfo *type);
+napi_value DecodeObject(InstanceData *instance, const uint8_t *origin, const TypeInfo *type);
+void DecodeObject(InstanceData *instance, napi_value obj, const uint8_t *origin, const TypeInfo *type);
 
-Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type);
-Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type, uint32_t len);
-void DecodeElements(Napi::Env env, napi_value array, const uint8_t *origin, const TypeInfo *type, uint32_t len);
+napi_value DecodeArray(InstanceData *instance, const uint8_t *origin, const TypeInfo *type);
+napi_value DecodeArray(InstanceData *instance, const uint8_t *origin, const TypeInfo *type, uint32_t len);
+void DecodeElements(InstanceData *instance, napi_value array, const uint8_t *origin, const TypeInfo *type, uint32_t len);
 INLINE_UNITY void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *type);
 
-Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, const Size *len = nullptr);
-Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, const Size *len = nullptr);
+napi_value Decode(Napi::Value value, Size offset, const TypeInfo *type, const Size *len = nullptr);
+napi_value Decode(InstanceData *instance, const uint8_t *ptr, const TypeInfo *type, const Size *len = nullptr);
 
 bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *type, const Size *len = nullptr);
-bool Encode(Napi::Env env, uint8_t *ptr, Napi::Value value, const TypeInfo *type, const Size *len = nullptr);
+bool Encode(InstanceData *instance, uint8_t *ptr, Napi::Value value, const TypeInfo *type, const Size *len = nullptr);
 
 static FORCE_INLINE napi_value NewInt(Napi::Env env, char i) { napi_value value; napi_create_int32(env, (int32_t)i, &value); return value; }
 static FORCE_INLINE napi_value NewInt(Napi::Env env, signed char i) { napi_value value; napi_create_int32(env, (int32_t)i, &value); return value; }
@@ -480,9 +482,6 @@ static FORCE_INLINE Napi::Value WrapPointer(Napi::Env env, const TypeInfo *ref,
 #endif
 }
 
-Napi::Value INLINE_UNITY WrapPointer(Napi::Env env, const TypeInfo *ref, void *ptr);
-Napi::Value INLINE_UNITY WrapPointer(Napi::Env env, const TypeInfo *ref, void *ptr);
-
 bool DetectCallConvention(Span<const char> name, CallConvention *out_convention);
 
 int AnalyseFlat(const TypeInfo *type, FunctionRef<void(const TypeInfo *type, int offset, int count)> func);