objc-js 0.0.11 → 0.0.13

package/binding.gyp

@@ -5,7 +5,8 @@
             "sources": [
                 "src/native/nobjc.mm",
                 "src/native/ObjcObject.mm",
-                "src/native/protocol-impl.mm"
+                "src/native/protocol-impl.mm",
+                "src/native/method-forwarding.mm"
             ],
             "defines": [
                 "NODE_ADDON_API_CPP_EXCEPTIONS",

package/package.json

@@ -39,7 +39,7 @@
     "format": "prettier --write \"**/*.{ts,js,json,md}\"",
     "preinstall-disabled": "npm run build-scripts && npm run make-clangd-config"
   },
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "Objective-C bridge for Node.js",
   "main": "dist/index.js",
   "dependencies": {

package/src/native/bridge.h

@@ -1,4 +1,5 @@
 #include "ObjcObject.h"
+#include "type-conversion.h"
 #include <Foundation/Foundation.h>
 #include <format>
 #include <napi.h>
@@ -218,51 +219,6 @@ T ConvertToNativeValue(const Napi::Value &value,
 
 // MARK: - Conversion Top Layer
 
-// Helper class to manage the lifetime of simplified type encodings
-class SimplifiedTypeEncoding {
-private:
-  std::string simplified;
-
-public:
-  SimplifiedTypeEncoding(const char *typeEncoding) : simplified(typeEncoding) {
-    // Remove any leading qualifiers
-    while (!simplified.empty() && (simplified[0] == 'r' || simplified[0] == 'n' ||
-                                   simplified[0] == 'N' || simplified[0] == 'o' ||
-                                   simplified[0] == 'O' || simplified[0] == 'R' ||
-                                   simplified[0] == 'V')) {
-      simplified.erase(0, 1);
-    }
-  }
-
-  const char *c_str() const { return simplified.c_str(); }
-  char operator[](size_t index) const { return simplified[index]; }
-  operator const char *() const { return simplified.c_str(); }
-};
-
-// Legacy function for compatibility - returns pointer to internal string
-// WARNING: The returned pointer is only valid as long as the typeEncoding parameter is valid
-inline const char *SimplifyTypeEncoding(const char *typeEncoding) {
-  // For simple cases where there are no qualifiers, return the original pointer
-  if (typeEncoding && typeEncoding[0] != 'r' && typeEncoding[0] != 'n' &&
-      typeEncoding[0] != 'N' && typeEncoding[0] != 'o' &&
-      typeEncoding[0] != 'O' && typeEncoding[0] != 'R' &&
-      typeEncoding[0] != 'V') {
-    return typeEncoding;
-  }
-  
-  // For complex cases, we need to skip qualifiers
-  // This is a temporary fix - callers should use SimplifiedTypeEncoding class
-  static thread_local std::string buffer;
-  buffer = typeEncoding;
-  while (!buffer.empty() && (buffer[0] == 'r' || buffer[0] == 'n' ||
-                             buffer[0] == 'N' || buffer[0] == 'o' ||
-                             buffer[0] == 'O' || buffer[0] == 'R' ||
-                             buffer[0] == 'V')) {
-    buffer.erase(0, 1);
-  }
-  return buffer.c_str();
-}
-
 // Convert a Napi::Value to an ObjcType based on the provided type encoding.
 inline auto AsObjCArgument(const Napi::Value &value, const char *typeEncoding,
                            const ObjcArgumentContext &context)
@@ -321,71 +277,11 @@ inline auto AsObjCArgument(const Napi::Value &value, const char *typeEncoding,
 }
 
 // Convert the return value of an Objective-C method to a Napi::Value.
+// This is an alias for GetInvocationReturnAsJS for backward compatibility.
 inline Napi::Value
 ConvertReturnValueToJSValue(Napi::Env env, NSInvocation *invocation,
                             NSMethodSignature *methodSignature) {
-#define NOBJC_NUMERIC_RETURN_CASE(encoding, ctype)                             \
-  case encoding: {                                                             \
-    ctype result;                                                              \
-    [invocation getReturnValue:&result];                                       \
-    return Napi::Number::New(env, result);                                     \
-  }
-  switch (*SimplifyTypeEncoding([methodSignature methodReturnType])) {
-    NOBJC_NUMERIC_RETURN_CASE('c', char)
-    NOBJC_NUMERIC_RETURN_CASE('i', int)
-    NOBJC_NUMERIC_RETURN_CASE('s', short)
-    NOBJC_NUMERIC_RETURN_CASE('l', long)
-    NOBJC_NUMERIC_RETURN_CASE('q', long long)
-    NOBJC_NUMERIC_RETURN_CASE('C', unsigned char)
-    NOBJC_NUMERIC_RETURN_CASE('I', unsigned int)
-    NOBJC_NUMERIC_RETURN_CASE('S', unsigned short)
-    NOBJC_NUMERIC_RETURN_CASE('L', unsigned long)
-    NOBJC_NUMERIC_RETURN_CASE('Q', unsigned long long)
-    NOBJC_NUMERIC_RETURN_CASE('f', float)
-    NOBJC_NUMERIC_RETURN_CASE('d', double)
-  case 'B': {
-    bool result;
-    [invocation getReturnValue:&result];
-    return Napi::Boolean::New(env, result);
-  }
-  case 'v':
-    return env.Undefined();
-  case '*': {
-    char *result = nullptr;
-    [invocation getReturnValue:&result];
-    if (result == nullptr) {
-      return env.Null();
-    }
-    Napi::String jsString = Napi::String::New(env, result);
-    // free(result); // It might not be safe to free this memory.
-    return jsString;
-  }
-  case '@':
-  case '#': {
-    id result = nil;
-    [invocation getReturnValue:&result];
-    if (result == nil) {
-      return env.Null();
-    }
-    return ObjcObject::NewInstance(env, result);
-  }
-  case ':': {
-    SEL result = nullptr;
-    [invocation getReturnValue:&result];
-    if (result == nullptr) {
-      return env.Null();
-    }
-    NSString *selectorString = NSStringFromSelector(result);
-    if (selectorString == nil) {
-      return env.Null();
-    }
-    return Napi::String::New(env, [selectorString UTF8String]);
-  }
-  default:
-    Napi::TypeError::New(env, "Unsupported return type (post-invoke)")
-        .ThrowAsJavaScriptException();
-    return env.Null();
-  }
+  return GetInvocationReturnAsJS(env, invocation, methodSignature);
 }
 
-#endif // NATIVE_BRIDGE_H
+#endif // NATIVE_BRIDGE_H

package/src/native/method-forwarding.h

@@ -0,0 +1,38 @@
+#ifndef METHOD_FORWARDING_H
+#define METHOD_FORWARDING_H
+
+#include "protocol-storage.h"
+#include <napi.h>
+#include <objc/runtime.h>
+
+// Forward declarations for Objective-C types
+#ifdef __OBJC__
+@class NSMethodSignature;
+@class NSInvocation;
+#else
+typedef struct NSMethodSignature NSMethodSignature;
+typedef struct NSInvocation NSInvocation;
+#endif
+
+// MARK: - ThreadSafeFunction Callback
+
+// Callback that runs on the JavaScript thread to invoke JS functions
+void CallJSCallback(Napi::Env env, Napi::Function jsCallback,
+                    InvocationData *data);
+
+// MARK: - ObjC Runtime Method Implementations
+
+// Override respondsToSelector to return YES for methods we implement
+BOOL RespondsToSelector(id self, SEL _cmd, SEL selector);
+
+// Method signature provider for message forwarding
+NSMethodSignature *MethodSignatureForSelector(id self, SEL _cmd, SEL selector);
+
+// Forward invocation handler for dynamic method dispatch
+void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation);
+
+// Deallocation implementation to clean up when instance is destroyed
+void DeallocImplementation(id self, SEL _cmd);
+
+#endif // METHOD_FORWARDING_H
+

package/src/native/method-forwarding.mm

@@ -0,0 +1,416 @@
+#include "method-forwarding.h"
+#include "ObjcObject.h"
+#include "protocol-storage.h"
+#include "type-conversion.h"
+#include <CoreFoundation/CoreFoundation.h>
+#include <Foundation/Foundation.h>
+#include <napi.h>
+#include <objc/runtime.h>
+
+// MARK: - ThreadSafeFunction Callback Handler
+
+// This function runs on the JavaScript thread
+void CallJSCallback(Napi::Env env, Napi::Function jsCallback,
+                    InvocationData *data) {
+  if (!data) {
+    NSLog(@"Error: InvocationData is null in CallJSCallback");
+    return;
+  }
+
+  // Check if the callback is valid before proceeding
+  if (jsCallback.IsEmpty()) {
+    NSLog(@"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;
+  }
+
+  NSInvocation *invocation = data->invocation;
+  if (!invocation) {
+    NSLog(@"Error: NSInvocation is null in CallJSCallback");
+    SignalInvocationComplete(data);
+    delete data;
+    return;
+  }
+
+  // Extract arguments using NSInvocation
+  NSMethodSignature *sig = [invocation methodSignature];
+  if (!sig) {
+    NSLog(@"Error: Failed to get method signature for selector %s",
+          data->selectorName.c_str());
+    SignalInvocationComplete(data);
+    [invocation release];
+    delete data;
+    return;
+  }
+
+  std::vector<napi_value> jsArgs;
+
+  // Skip first two arguments (self and _cmd)
+  for (NSUInteger i = 2; i < [sig numberOfArguments]; i++) {
+    const char *type = [sig getArgumentTypeAtIndex:i];
+    SimplifiedTypeEncoding argType(type);
+    jsArgs.push_back(ExtractInvocationArgumentToJS(env, invocation, i, argType[0]));
+  }
+
+  NSLog(@"[DEBUG] About to call JS callback for %s with %zu arguments",
+        data->selectorName.c_str(), jsArgs.size());
+
+  // Call the JavaScript callback
+  try {
+    Napi::Value result = jsCallback.Call(jsArgs);
+
+    NSLog(@"[DEBUG] JS callback for %s returned, result type: %d",
+          data->selectorName.c_str(), result.Type());
+
+    // Handle return value if the method expects one
+    const char *returnType = [sig methodReturnType];
+    SimplifiedTypeEncoding retType(returnType);
+
+    if (retType[0] != 'v') { // Not void
+      NSLog(@"[DEBUG] Setting return value for %s, return type: %c, JS result is %s",
+            data->selectorName.c_str(), retType[0],
+            result.IsNull() ? "null" : result.IsUndefined() ? "undefined" : "value");
+      SetInvocationReturnFromJS(invocation, result, retType[0],
+                                data->selectorName.c_str());
+      NSLog(@"[DEBUG] Return value set for %s", data->selectorName.c_str());
+    }
+  } catch (const Napi::Error &e) {
+    NSLog(@"Error calling JavaScript callback for %s: %s",
+          data->selectorName.c_str(), e.what());
+  } catch (const std::exception &e) {
+    NSLog(@"Exception calling JavaScript callback for %s: %s",
+          data->selectorName.c_str(), e.what());
+  } catch (...) {
+    NSLog(@"Unknown error calling JavaScript callback for %s",
+          data->selectorName.c_str());
+  }
+
+  // Signal completion to the waiting ForwardInvocation
+  SignalInvocationComplete(data);
+
+  // Clean up the invocation data
+  // Release the invocation that we retained in ForwardInvocation
+  [invocation release];
+  delete data;
+}
+
+// MARK: - Message Forwarding Implementation
+
+// Override respondsToSelector to return YES for methods we implement
+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()) {
+      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;
+        }
+      }
+    }
+  }
+
+  // For methods we don't implement, check if NSObject responds to them
+  // This handles standard NSObject methods like description, isEqual:, etc.
+  return [NSObject instancesRespondToSelector:selector];
+}
+
+// Provide method signature for message forwarding
+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()];
+    }
+  }
+  // Fall back to superclass for methods we don't implement
+  return [NSObject instanceMethodSignatureForSelector:selector];
+}
+
+// Handle forwarded invocations
+void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
+  if (!invocation) {
+    NSLog(@"Error: ForwardInvocation called with nil invocation");
+    return;
+  }
+
+  // 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
+
+  SEL selector = [invocation selector];
+  NSString *selectorString = NSStringFromSelector(selector);
+  if (!selectorString) {
+    NSLog(@"Error: Failed to convert selector to string");
+    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()) {
+      NSLog(@"Warning: Protocol implementation not found for instance %p",
+            self);
+      return;
+    }
+
+    auto callbackIt = it->second.callbacks.find(selectorName);
+    if (callbackIt == it->second.callbacks.end()) {
+      NSLog(@"Warning: 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) {
+      NSLog(@"Warning: 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);
+
+  NSLog(@"[DEBUG] ForwardInvocation for %s: is_js_thread=%d, isElectron=%d, current_thread=%p, js_thread=%p",
+        selectorName.c_str(), is_js_thread, isElectron, 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.
+
+  // Create invocation data
+  auto data = new InvocationData();
+  data->invocation = invocation;
+  data->selectorName = selectorName;
+  data->typeEncoding = typeEncoding;
+
+  napi_status status;
+
+  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.
+    NSLog(@"[DEBUG] Taking JS thread direct call path for %s", selectorName.c_str());
+    data->completionMutex = nullptr;
+    data->completionCv = nullptr;
+    data->isComplete = nullptr;
+
+    tsfn.Release();
+
+    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()) {
+        NSLog(@"Warning: Protocol implementation not found for instance %p "
+              @"(JS thread path)",
+              self);
+        [invocation release];
+        delete data;
+        return;
+      }
+
+      auto jsCallbackIt = it->second.jsCallbacks.find(selectorName);
+      if (jsCallbackIt == it->second.jsCallbacks.end()) {
+        NSLog(@"Warning: JS callback not found for selector %s "
+              @"(JS thread path)",
+              selectorName.c_str());
+        [invocation release];
+        delete data;
+        return;
+      }
+
+      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 {
+      NSLog(@"[DEBUG] Creating Napi::Env from stored_env for %s", selectorName.c_str());
+      Napi::Env callEnv(stored_env);
+      
+      // Create a HandleScope to properly manage V8 handles
+      // This is critical for Electron which may have multiple V8 contexts
+      NSLog(@"[DEBUG] Creating HandleScope for %s", selectorName.c_str());
+      Napi::HandleScope scope(callEnv);
+      
+      NSLog(@"[DEBUG] Calling CallJSCallback directly for %s", selectorName.c_str());
+      CallJSCallback(callEnv, jsFn, data);
+      NSLog(@"[DEBUG] CallJSCallback completed for %s", selectorName.c_str());
+      // CallJSCallback releases invocation and deletes data.
+    } catch (const std::exception &e) {
+      NSLog(@"Error calling JS callback directly (likely invalid env in "
+            @"Electron): %s",
+            e.what());
+      NSLog(@"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 and set up sync primitives
+      {
+        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) {
+              // Set up synchronization for fallback path
+              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) {
+                // Wait for callback by pumping CFRunLoop
+                CFTimeInterval timeout = 0.001; // 1ms per iteration
+                while (true) {
+                  {
+                    std::unique_lock<std::mutex> lock(completionMutex);
+                    if (isComplete) {
+                      break;
+                    }
+                  }
+                  CFRunLoopRunInMode(kCFRunLoopDefaultMode, timeout, true);
+                }
+                return; // Data cleaned up in callback
+              }
+            }
+          }
+        }
+      }
+      
+      // 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
+    NSLog(@"[DEBUG] Taking non-JS thread path for %s", selectorName.c_str());
+    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) {
+      NSLog(@"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
+
+    while (true) {
+      {
+        std::unique_lock<std::mutex> lock(completionMutex);
+        if (isComplete) {
+          break;
+        }
+      }
+      CFRunLoopRunInMode(kCFRunLoopDefaultMode, timeout, true);
+    }
+    // Data cleaned up in callback
+  }
+
+  // Return value (if any) has been set on the invocation
+}
+
+// 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);
+    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();
+        }
+        it->second.callbacks.clear();
+        it->second.jsCallbacks.clear();
+        it->second.typeEncodings.clear();
+      } catch (...) {
+        // Ignore errors during cleanup
+        NSLog(@"Warning: Exception during callback cleanup for instance %p",
+              self);
+      }
+      g_implementations.erase(it);
+    }
+  }
+
+  // Call the superclass dealloc
+  // Note: Under ARC, we don't need to manually call [super dealloc]
+  // The runtime handles this automatically
+}

package/src/native/protocol-impl.h

@@ -2,68 +2,21 @@
 #define PROTOCOL_IMPL_H
 
 #include <napi.h>
-#include <objc/runtime.h>
 #include <string>
-#include <unordered_map>
 #include <vector>
 
-// Forward declarations for Objective-C types
-#ifdef __OBJC__
-@class NSMethodSignature;
-@class NSInvocation;
-#else
-typedef struct NSMethodSignature NSMethodSignature;
-typedef struct NSInvocation NSInvocation;
-#endif
-
-// MARK: - Data Structures
-
-// Data passed from native thread to JS thread for invocation handling
-struct InvocationData {
-  NSInvocation *invocation;
-  std::string selectorName;
-  std::string typeEncoding;
-  // The invocation itself stores the return value, so we don't need separate storage
-  // BlockingCall ensures the callback completes before returning, so no sync primitives needed
-};
-
-// Stores information about a protocol implementation instance
-struct ProtocolImplementation {
-  std::unordered_map<std::string, Napi::ThreadSafeFunction> callbacks;
-  std::unordered_map<std::string, Napi::FunctionReference> jsCallbacks; // Original JS functions for direct calls
-  std::unordered_map<std::string, std::string> typeEncodings;
-  std::string className;
-  napi_env env; // Store the environment for direct calls
-  pthread_t js_thread; // Store the JS thread ID
-};
-
-// Global map: instance pointer -> implementation details
-// This keeps JavaScript callbacks alive for the lifetime of the Objective-C object
-extern std::unordered_map<void *, ProtocolImplementation> g_implementations;
-
-// MARK: - Function Declarations
+// MARK: - Public API
 
 // Main entry point: creates a new Objective-C class that implements a protocol
+// Arguments:
+//   - protocolName (string): Name of the Objective-C protocol to implement
+//   - methodImplementations (object): Map of selector names to JS functions
+// Returns: An ObjcObject wrapping the new instance
 Napi::Value CreateProtocolImplementation(const Napi::CallbackInfo &info);
 
-// Override respondsToSelector to return YES for implemented methods
-BOOL RespondsToSelector(id self, SEL _cmd, SEL selector);
-
-// Method signature provider for message forwarding
-NSMethodSignature* MethodSignatureForSelector(id self, SEL _cmd, SEL selector);
-
-// Forward invocation handler for dynamic method dispatch
-void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation);
+// MARK: - Utility Functions
 
 // Helper: Parses an Objective-C method signature to extract argument types
 std::vector<std::string> ParseMethodSignature(const char *typeEncoding);
 
-// Helper: Converts an Objective-C value to a JavaScript value
-Napi::Value ConvertObjCValueToJS(Napi::Env env, void *value,
-                                 const char *typeEncoding);
-
-// Deallocation implementation to clean up when instance is destroyed
-void DeallocImplementation(id self, SEL _cmd);
-
 #endif // PROTOCOL_IMPL_H
-