objc-js 0.0.15 → 1.0.0

package/src/native/method-forwarding.mm

@@ -1,8 +1,13 @@
 #include "method-forwarding.h"
 #include "debug.h"
+#include "forwarding-common.h"
+#include "memory-utils.h"
 #include "ObjcObject.h"
+#include "protocol-manager.h"
 #include "protocol-storage.h"
 #include "type-conversion.h"
+
+using nobjc::ProtocolManager;
 #include <CoreFoundation/CoreFoundation.h>
 #include <Foundation/Foundation.h>
 #include <napi.h>
@@ -12,8 +17,13 @@
 
 // This function runs on the JavaScript thread
 // Handles both protocol implementation and subclass method forwarding
+// NOTE: This function takes ownership of data and must clean it up
 void CallJSCallback(Napi::Env env, Napi::Function jsCallback,
                     InvocationData *data) {
+  // Use RAII to ensure cleanup even if we return early or throw
+  // The guard will release the invocation and delete data
+  InvocationDataGuard guard(data);
+  
   if (!data) {
     NOBJC_ERROR("InvocationData is null in CallJSCallback");
     return;
@@ -26,20 +36,15 @@ void CallJSCallback(Napi::Env env, Napi::Function jsCallback,
   if (jsCallback.IsEmpty()) {
     NOBJC_ERROR("jsCallback is null/empty in CallJSCallback for selector %s",
           data->selectorName.c_str());
-    if (data->invocation) {
-      [data->invocation release];
-    }
     SignalInvocationComplete(data);
-    delete data;
-    return;
+    return;  // guard cleans up
   }
 
   NSInvocation *invocation = data->invocation;
   if (!invocation) {
     NOBJC_ERROR("NSInvocation is null in CallJSCallback");
     SignalInvocationComplete(data);
-    delete data;
-    return;
+    return;  // guard cleans up
   }
 
   NOBJC_LOG("CallJSCallback: About to get method signature");
@@ -50,9 +55,7 @@ void CallJSCallback(Napi::Env env, Napi::Function jsCallback,
     NOBJC_ERROR("Failed to get method signature for selector %s",
           data->selectorName.c_str());
     SignalInvocationComplete(data);
-    [invocation release];
-    delete data;
-    return;
+    return;  // guard cleans up
   }
 
   NOBJC_LOG("CallJSCallback: Method signature: %s, numArgs: %lu", 
@@ -124,10 +127,7 @@ void CallJSCallback(Napi::Env env, Napi::Function jsCallback,
   SignalInvocationComplete(data);
   NOBJC_LOG("CallJSCallback: Signaled completion for %s", data->selectorName.c_str());
 
-  // Clean up the invocation data
-  // Release the invocation that we retained in ForwardInvocation
-  [invocation release];
-  delete data;
+  // guard destructor cleans up invocation and data
 }
 
 // MARK: - Fallback Helper
@@ -177,19 +177,23 @@ BOOL RespondsToSelector(id self, SEL _cmd, SEL selector) {
   void *ptr = (__bridge void *)self;
 
   // Check if this is one of our implemented methods
-  {
-    std::lock_guard<std::mutex> lock(g_implementations_mutex);
-    auto it = g_implementations.find(ptr);
-    if (it != g_implementations.end()) {
+  bool found = ProtocolManager::Instance().WithLock([ptr, selector](auto& map) {
+    auto it = map.find(ptr);
+    if (it != map.end()) {
       NSString *selectorString = NSStringFromSelector(selector);
       if (selectorString != nil) {
         std::string selName = [selectorString UTF8String];
         auto callbackIt = it->second.callbacks.find(selName);
         if (callbackIt != it->second.callbacks.end()) {
-          return YES;
+          return true;
         }
       }
     }
+    return false;
+  });
+
+  if (found) {
+    return YES;
   }
 
   // For methods we don't implement, check if NSObject responds to them
@@ -201,15 +205,21 @@ BOOL RespondsToSelector(id self, SEL _cmd, SEL selector) {
 NSMethodSignature *MethodSignatureForSelector(id self, SEL _cmd, SEL selector) {
   void *ptr = (__bridge void *)self;
 
-  std::lock_guard<std::mutex> lock(g_implementations_mutex);
-  auto it = g_implementations.find(ptr);
-  if (it != g_implementations.end()) {
-    NSString *selectorString = NSStringFromSelector(selector);
-    std::string selName = [selectorString UTF8String];
-    auto encIt = it->second.typeEncodings.find(selName);
-    if (encIt != it->second.typeEncodings.end()) {
-      return [NSMethodSignature signatureWithObjCTypes:encIt->second.c_str()];
+  NSMethodSignature *sig = ProtocolManager::Instance().WithLock([ptr, selector](auto& map) -> NSMethodSignature* {
+    auto it = map.find(ptr);
+    if (it != map.end()) {
+      NSString *selectorString = NSStringFromSelector(selector);
+      std::string selName = [selectorString UTF8String];
+      auto encIt = it->second.typeEncodings.find(selName);
+      if (encIt != it->second.typeEncodings.end()) {
+        return [NSMethodSignature signatureWithObjCTypes:encIt->second.c_str()];
+      }
     }
+    return nil;
+  });
+  
+  if (sig != nil) {
+    return sig;
   }
   // Fall back to superclass for methods we don't implement
   return [NSObject instanceMethodSignatureForSelector:selector];
@@ -223,222 +233,141 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
   }
 
   // Retain the invocation to keep it alive during async call
-  // retainArguments only retains the arguments, not the invocation itself
   [invocation retainArguments];
-  [invocation retain]; // Keep invocation alive until callback completes
+  [invocation retain];
 
   SEL selector = [invocation selector];
   NSString *selectorString = NSStringFromSelector(selector);
   if (!selectorString) {
     NOBJC_ERROR("Failed to convert selector to string");
+    [invocation release];
     return;
   }
 
   std::string selectorName = [selectorString UTF8String];
-
-  // Store self pointer for later lookups
   void *ptr = (__bridge void *)self;
 
-  // Get thread-safe data (TSFN, typeEncoding, js_thread)
-  // DO NOT access any N-API values here - we may not be on the JS thread!
-  Napi::ThreadSafeFunction tsfn;
-  std::string typeEncoding;
-  pthread_t js_thread;
-  bool isElectron;
-  {
-    std::lock_guard<std::mutex> lock(g_implementations_mutex);
-    auto it = g_implementations.find(ptr);
-    if (it == g_implementations.end()) {
-      NOBJC_WARN("Protocol implementation not found for instance %p", self);
-      return;
-    }
-
-    auto callbackIt = it->second.callbacks.find(selectorName);
-    if (callbackIt == it->second.callbacks.end()) {
-      NOBJC_WARN("Callback not found for selector %s", selectorName.c_str());
-      return;
-    }
-
-    // Get the ThreadSafeFunction - this is thread-safe by design
-    // IMPORTANT: We must Acquire() to increment the ref count, because copying
-    // a ThreadSafeFunction does NOT increment it. If DeallocImplementation
-    // runs and calls Release() on the original, our copy would become invalid.
-    tsfn = callbackIt->second;
-    napi_status acq_status = tsfn.Acquire();
-    if (acq_status != napi_ok) {
-      NOBJC_WARN("Failed to acquire ThreadSafeFunction for selector %s",
-            selectorName.c_str());
-      return;
-    }
-
-    // Get the type encoding for return value handling
-    auto encIt = it->second.typeEncodings.find(selectorName);
-    if (encIt != it->second.typeEncodings.end()) {
-      typeEncoding = encIt->second;
-    }
-
-    // Get the JS thread ID to check if we're on the same thread
-    js_thread = it->second.js_thread;
-    isElectron = it->second.isElectron;
-  }
-
-  // Check if we're on the JS thread
-  bool is_js_thread = pthread_equal(pthread_self(), js_thread);
-
-  // IMPORTANT: We call directly on the JS thread so return values are set
-  // synchronously; otherwise we use a ThreadSafeFunction to marshal work.
-  // EXCEPTION: In Electron, we ALWAYS use TSFN even on the JS thread because
-  // Electron's V8 context isn't properly set up for direct handle creation.
+  // Set up callbacks for protocol-specific storage access
+  ForwardingCallbacks callbacks;
+  callbacks.callbackType = CallbackType::Protocol;
+
+  // Lookup context and acquire TSFN
+  callbacks.lookupContext = [](void *lookupKey,
+                               const std::string &selName) -> std::optional<ForwardingContext> {
+    return ProtocolManager::Instance().WithLock([lookupKey, &selName](auto& map) -> std::optional<ForwardingContext> {
+      auto it = map.find(lookupKey);
+      if (it == map.end()) {
+        NOBJC_WARN("Protocol implementation not found for instance %p", lookupKey);
+        return std::nullopt;
+      }
 
-  // Create invocation data
-  auto data = new InvocationData();
-  data->invocation = invocation;
-  data->selectorName = selectorName;
-  data->typeEncoding = typeEncoding;
-  data->callbackType = CallbackType::Protocol;
+      auto callbackIt = it->second.callbacks.find(selName);
+      if (callbackIt == it->second.callbacks.end()) {
+        NOBJC_WARN("Callback not found for selector %s", selName.c_str());
+        return std::nullopt;
+      }
 
-  napi_status status;
+      // Acquire the TSFN
+      Napi::ThreadSafeFunction tsfn = callbackIt->second;
+      napi_status acq_status = tsfn.Acquire();
+      if (acq_status != napi_ok) {
+        NOBJC_WARN("Failed to acquire ThreadSafeFunction for selector %s", selName.c_str());
+        return std::nullopt;
+      }
 
-  if (is_js_thread && !isElectron) {
-    // We're on the JS thread in Node/Bun (NOT Electron)
-    // Call directly to ensure return values are set synchronously.
-    data->completionMutex = nullptr;
-    data->completionCv = nullptr;
-    data->isComplete = nullptr;
+      ForwardingContext ctx;
+      ctx.tsfn = tsfn;
+      ctx.js_thread = it->second.js_thread;
+      ctx.env = it->second.env;
+      ctx.skipDirectCallForElectron = it->second.isElectron;
+      ctx.instancePtr = nullptr;   // Not used for protocols
+      ctx.superClassPtr = nullptr; // Not used for protocols
+
+      // Cache the JS callback reference to avoid mutex re-acquisition
+      auto jsCallbackIt = it->second.jsCallbacks.find(selName);
+      if (jsCallbackIt != it->second.jsCallbacks.end()) {
+        ctx.cachedJsCallback = &jsCallbackIt->second;
+      }
 
-    tsfn.Release();
+      auto encIt = it->second.typeEncodings.find(selName);
+      if (encIt != it->second.typeEncodings.end()) {
+        ctx.typeEncoding = encIt->second;
+      }
 
-    Napi::Function jsFn;
-    napi_env stored_env;
-    {
-      std::lock_guard<std::mutex> lock(g_implementations_mutex);
-      auto it = g_implementations.find(ptr);
-      if (it == g_implementations.end()) {
-        NOBJC_WARN("Protocol implementation not found for instance %p (JS thread path)", self);
-        [invocation release];
-        delete data;
-        return;
+      return ctx;
+    });
+  };
+
+  // Get JS function for direct call path
+  callbacks.getJSFunction = [](void *lookupKey, const std::string &selName,
+                               Napi::Env /*env*/) -> Napi::Function {
+    return ProtocolManager::Instance().WithLock([lookupKey, &selName](auto& map) -> Napi::Function {
+      auto it = map.find(lookupKey);
+      if (it == map.end()) {
+        return Napi::Function();
       }
 
-      auto jsCallbackIt = it->second.jsCallbacks.find(selectorName);
+      auto jsCallbackIt = it->second.jsCallbacks.find(selName);
       if (jsCallbackIt == it->second.jsCallbacks.end()) {
-        NOBJC_WARN("JS callback not found for selector %s (JS thread path)",
-              selectorName.c_str());
-        [invocation release];
-        delete data;
-        return;
+        return Napi::Function();
       }
 
-      stored_env = it->second.env;
-      jsFn = jsCallbackIt->second.Value();
-    }
-
-    // Safely call the JS callback with proper V8 context setup
-    // Wrap in try-catch to handle invalid env (e.g., in Electron when context
-    // is destroyed)
-    try {
-      Napi::Env callEnv(stored_env);
-      
-      // Create a HandleScope to properly manage V8 handles
-      // This is critical for Electron which may have multiple V8 contexts
-      Napi::HandleScope scope(callEnv);
-      
-      CallJSCallback(callEnv, jsFn, data);
-      // CallJSCallback releases invocation and deletes data.
-    } catch (const std::exception &e) {
-      NOBJC_ERROR("Error calling JS callback directly (likely invalid env in Electron): %s", e.what());
-      NOBJC_LOG("Falling back to ThreadSafeFunction for selector %s", selectorName.c_str());
-      
-      // Fallback to TSFN if direct call fails (e.g., invalid env in Electron)
-      // We need to re-acquire the TSFN
-      {
-        std::lock_guard<std::mutex> lock(g_implementations_mutex);
-        auto it = g_implementations.find(ptr);
-        if (it != g_implementations.end()) {
-          auto callbackIt = it->second.callbacks.find(selectorName);
-          if (callbackIt != it->second.callbacks.end()) {
-            tsfn = callbackIt->second;
-            napi_status acq_status = tsfn.Acquire();
-            if (acq_status == napi_ok) {
-              // Use helper function for fallback
-              if (FallbackToTSFN(tsfn, data, selectorName)) {
-                return; // Data cleaned up in callback
-              }
-            }
-          }
-        }
+      return jsCallbackIt->second.Value();
+    });
+  };
+
+  // Re-acquire TSFN for fallback path
+  callbacks.reacquireTSFN = [](void *lookupKey,
+                               const std::string &selName) -> std::optional<Napi::ThreadSafeFunction> {
+    return ProtocolManager::Instance().WithLock([lookupKey, &selName](auto& map) -> std::optional<Napi::ThreadSafeFunction> {
+      auto it = map.find(lookupKey);
+      if (it == map.end()) {
+        return std::nullopt;
       }
-      
-      // If fallback also failed, clean up manually
-      [invocation release];
-      delete data;
-    }
-  } else {
-    // We're on a different thread (e.g., Cocoa callback from
-    // ASAuthorizationController) Use NonBlockingCall + runloop pumping to avoid
-    // deadlocks
-    std::mutex completionMutex;
-    std::condition_variable completionCv;
-    bool isComplete = false;
-
-    data->completionMutex = &completionMutex;
-    data->completionCv = &completionCv;
-    data->isComplete = &isComplete;
-
-    status = tsfn.NonBlockingCall(data, CallJSCallback);
-    tsfn.Release();
-
-    if (status != napi_ok) {
-      NOBJC_ERROR("Failed to call ThreadSafeFunction for selector %s (status: %d)",
-            selectorName.c_str(), status);
-      [invocation release];
-      delete data;
-      return;
-    }
 
-    // Wait for callback by pumping CFRunLoop
-    // This allows the event loop to process our callback
-    CFTimeInterval timeout = 0.001; // 1ms per iteration
+      auto callbackIt = it->second.callbacks.find(selName);
+      if (callbackIt == it->second.callbacks.end()) {
+        return std::nullopt;
+      }
 
-    while (true) {
-      {
-        std::unique_lock<std::mutex> lock(completionMutex);
-        if (isComplete) {
-          break;
-        }
+      Napi::ThreadSafeFunction tsfn = callbackIt->second;
+      napi_status acq_status = tsfn.Acquire();
+      if (acq_status != napi_ok) {
+        return std::nullopt;
       }
-      CFRunLoopRunInMode(kCFRunLoopDefaultMode, timeout, true);
-    }
-    // Data cleaned up in callback
-  }
 
-  // Return value (if any) has been set on the invocation
+      return tsfn;
+    });
+  };
+
+  ForwardInvocationCommon(invocation, selectorName, ptr, callbacks);
 }
 
 // Deallocation implementation
 void DeallocImplementation(id self, SEL _cmd) {
   @autoreleasepool {
-    // Remove the implementation from the global map
-    std::lock_guard<std::mutex> lock(g_implementations_mutex);
+    // Remove the implementation from the manager
     void *ptr = (__bridge void *)self;
-    auto it = g_implementations.find(ptr);
-    if (it != g_implementations.end()) {
-      // Release all ThreadSafeFunctions and JS callbacks
-      // Do this carefully to avoid issues during shutdown
-      try {
-        for (auto &pair : it->second.callbacks) {
-          // Release the ThreadSafeFunction
-          pair.second.Release();
+    ProtocolManager::Instance().WithLock([ptr, self](auto& map) {
+      auto it = map.find(ptr);
+      if (it != map.end()) {
+        // Release all ThreadSafeFunctions and JS callbacks
+        // Do this carefully to avoid issues during shutdown
+        try {
+          for (auto &pair : it->second.callbacks) {
+            // Release the ThreadSafeFunction
+            pair.second.Release();
+          }
+          it->second.callbacks.clear();
+          it->second.jsCallbacks.clear();
+          it->second.typeEncodings.clear();
+        } catch (...) {
+          // Ignore errors during cleanup
+          NOBJC_WARN("Exception during callback cleanup for instance %p", self);
         }
-        it->second.callbacks.clear();
-        it->second.jsCallbacks.clear();
-        it->second.typeEncodings.clear();
-      } catch (...) {
-        // Ignore errors during cleanup
-        NOBJC_WARN("Exception during callback cleanup for instance %p", self);
+        map.erase(it);
       }
-      g_implementations.erase(it);
-    }
+    });
   }
 
   // Call the superclass dealloc

package/src/native/nobjc.mm

@@ -1,4 +1,5 @@
 #include "ObjcObject.h"
+#include "pointer-utils.h"
 #include "protocol-impl.h"
 #include "subclass-impl.h"
 #include <Foundation/Foundation.h>
@@ -44,18 +45,7 @@ Napi::Value GetPointer(const Napi::CallbackInfo &info) {
   }
   
   ObjcObject *objcObj = Napi::ObjectWrap<ObjcObject>::Unwrap(obj);
-  uintptr_t ptrValue = reinterpret_cast<uintptr_t>(objcObj->objcObject);
-  
-  // Create a Buffer to hold the pointer (8 bytes on 64-bit macOS)
-  Napi::Buffer<uint8_t> buffer = Napi::Buffer<uint8_t>::New(env, sizeof(void*));
-  
-  // Write the pointer value to the buffer in little-endian format
-  uint8_t* data = buffer.Data();
-  for (size_t i = 0; i < sizeof(void*); ++i) {
-    data[i] = static_cast<uint8_t>((ptrValue >> (i * 8)) & 0xFF);
-  }
-  
-  return buffer;
+  return PointerToBuffer(env, objcObj->objcObject);
 }
 
 Napi::Value FromPointer(const Napi::CallbackInfo &info) {
@@ -65,39 +55,25 @@ Napi::Value FromPointer(const Napi::CallbackInfo &info) {
     throw Napi::TypeError::New(env, "Expected a single Buffer or BigInt argument");
   }
   
-  uintptr_t ptrValue = 0;
+  void *ptr = nullptr;
   
   if (info[0].IsBuffer()) {
-    // Read pointer from Buffer
     Napi::Buffer<uint8_t> buffer = info[0].As<Napi::Buffer<uint8_t>>();
     if (buffer.Length() != sizeof(void*)) {
       throw Napi::TypeError::New(env, "Buffer must be exactly 8 bytes for a 64-bit pointer");
     }
-    
-    uint8_t* data = buffer.Data();
-    for (size_t i = 0; i < sizeof(void*); ++i) {
-      ptrValue |= (static_cast<uintptr_t>(data[i]) << (i * 8));
-    }
+    ptr = ReadPointerFromBuffer(buffer.Data());
   } else if (info[0].IsBigInt()) {
-    // Read pointer from BigInt
-    bool lossless = false;
-    uint64_t value = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
-    if (!lossless) {
-      throw Napi::RangeError::New(env, "BigInt value out of range for pointer");
-    }
-    ptrValue = static_cast<uintptr_t>(value);
+    ptr = BigIntToPointer(env, info[0].As<Napi::BigInt>());
   } else {
     throw Napi::TypeError::New(env, "Expected a Buffer or BigInt argument");
   }
   
-  if (ptrValue == 0) {
+  if (ptr == nullptr) {
     return env.Null();
   }
   
-  // Convert the pointer value back to an Objective-C object pointer
-  id obj = reinterpret_cast<id>(ptrValue);
-  
-  return ObjcObject::NewInstance(env, obj);
+  return ObjcObject::NewInstance(env, reinterpret_cast<id>(ptr));
 }
 
 Napi::Object InitAll(Napi::Env env, Napi::Object exports) {

package/src/native/pointer-utils.h

@@ -0,0 +1,63 @@
+#ifndef POINTER_UTILS_H
+#define POINTER_UTILS_H
+
+#include <cstdint>
+#include <cstddef>
+#include <cstring>
+#include <napi.h>
+
+// MARK: - Pointer Conversion Utilities
+
+/**
+ * Write a pointer value to a buffer in little-endian format.
+ * The buffer must be at least sizeof(void*) bytes.
+ */
+inline void WritePointerToBuffer(const void *ptr, uint8_t *buffer) {
+  uintptr_t ptrValue = reinterpret_cast<uintptr_t>(ptr);
+  for (size_t i = 0; i < sizeof(void *); ++i) {
+    buffer[i] = static_cast<uint8_t>((ptrValue >> (i * 8)) & 0xFF);
+  }
+}
+
+/**
+ * Read a pointer value from a buffer in little-endian format.
+ * The buffer must be at least sizeof(void*) bytes.
+ */
+inline void *ReadPointerFromBuffer(const uint8_t *buffer) {
+  uintptr_t ptrValue = 0;
+  for (size_t i = 0; i < sizeof(void *); ++i) {
+    ptrValue |= static_cast<uintptr_t>(buffer[i]) << (i * 8);
+  }
+  return reinterpret_cast<void *>(ptrValue);
+}
+
+/**
+ * Create a N-API BigInt from a pointer value.
+ */
+inline Napi::BigInt PointerToBigInt(Napi::Env env, const void *ptr) {
+  return Napi::BigInt::New(env, reinterpret_cast<uint64_t>(ptr));
+}
+
+/**
+ * Extract a pointer value from a N-API BigInt.
+ * Throws if the value is out of range.
+ */
+inline void *BigIntToPointer(Napi::Env env, const Napi::BigInt &bigint) {
+  bool lossless;
+  uint64_t value = bigint.Uint64Value(&lossless);
+  if (!lossless) {
+    throw Napi::RangeError::New(env, "BigInt value out of range for pointer");
+  }
+  return reinterpret_cast<void *>(value);
+}
+
+/**
+ * Create a N-API Buffer containing a pointer value (little-endian).
+ */
+inline Napi::Buffer<uint8_t> PointerToBuffer(Napi::Env env, const void *ptr) {
+  Napi::Buffer<uint8_t> buffer = Napi::Buffer<uint8_t>::New(env, sizeof(void *));
+  WritePointerToBuffer(ptr, buffer.Data());
+  return buffer;
+}
+
+#endif // POINTER_UTILS_H

package/src/native/protocol-impl.mm

@@ -2,7 +2,9 @@
 #include "debug.h"
 #include "method-forwarding.h"
 #include "ObjcObject.h"
+#include "protocol-manager.h"
 #include "protocol-storage.h"
+#include "runtime-detection.h"
 #include "type-conversion.h"
 #include <Foundation/Foundation.h>
 #include <atomic>
@@ -11,10 +13,7 @@
 #include <objc/runtime.h>
 #include <sstream>
 
-// MARK: - Global Storage Definition
-
-std::unordered_map<void *, ProtocolImplementation> g_implementations;
-std::mutex g_implementations_mutex;
+using nobjc::ProtocolManager;
 
 // MARK: - Helper Functions
 
@@ -130,24 +129,8 @@ Napi::Value CreateProtocolImplementation(const Napi::CallbackInfo &info) {
   // Get the method implementations object's property names
   Napi::Array propertyNames = methodImplementations.GetPropertyNames();
 
-  // Detect if we're running in Electron by checking process.versions.electron
-  bool isElectron = false;
-  try {
-    Napi::Object global = env.Global();
-    if (global.Has("process")) {
-      Napi::Object process = global.Get("process").As<Napi::Object>();
-      if (process.Has("versions")) {
-        Napi::Object versions = process.Get("versions").As<Napi::Object>();
-        isElectron = versions.Has("electron");
-      }
-    }
-  } catch (...) {
-    // If detection fails, assume not Electron
-  }
-  
-  if (isElectron) {
-    // Electron runtime detected, will always use TSFN path
-  }
+  // Detect if we're running in Electron
+  bool isElectron = IsElectronRuntime(env);
 
   // Store callbacks for this instance (we'll set the instance pointer later)
   ProtocolImplementation impl{
@@ -270,12 +253,9 @@ Napi::Value CreateProtocolImplementation(const Napi::CallbackInfo &info) {
     throw Napi::Error::New(env, "Failed to instantiate class");
   }
 
-  // Store the implementation in the global map
+  // Store the implementation in the manager
   void *instancePtr = (__bridge void *)instance;
-  {
-    std::lock_guard<std::mutex> lock(g_implementations_mutex);
-    g_implementations.emplace(instancePtr, std::move(impl));
-  }
+  ProtocolManager::Instance().Register(instancePtr, std::move(impl));
 
   // Return wrapped object
   return ObjcObject::NewInstance(env, instance);