objc-js 0.0.12 → 0.0.13

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.12",
+  "version": "0.0.13",
   "description": "Objective-C bridge for Node.js",
   "main": "dist/index.js",
   "dependencies": {

package/src/native/method-forwarding.mm

@@ -57,19 +57,27 @@ void CallJSCallback(Napi::Env env, Napi::Function jsCallback,
     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(@"Setting return value for %s, return type: %c",
-            data->selectorName.c_str(), retType[0]);
+      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",
@@ -165,6 +173,7 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
   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);
@@ -201,13 +210,19 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
 
     // 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();
@@ -217,9 +232,10 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
 
   napi_status status;
 
-  if (is_js_thread) {
-    // We're on the JS thread (e.g., called from performSelector in Bun/Node)
+  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;
@@ -258,13 +274,17 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
     // 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 "
@@ -323,6 +343,7 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
     // 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;

package/src/native/protocol-impl.mm

@@ -130,13 +130,33 @@ 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) {
+    NSLog(@"[DEBUG] Detected Electron runtime, will always use TSFN path");
+  }
+
   // Store callbacks for this instance (we'll set the instance pointer later)
   ProtocolImplementation impl{
       .callbacks = {},
       .typeEncodings = {},
       .className = className,
       .env = env,
-      .js_thread = pthread_self() // Store the current (JS) thread ID
+      .js_thread = pthread_self(), // Store the current (JS) thread ID
+      .isElectron = isElectron
   };
 
   // Store default type encodings to keep them alive

package/src/native/protocol-storage.h

@@ -43,6 +43,8 @@ struct ProtocolImplementation {
   napi_env env;
   // Store the JS thread ID for thread detection
   pthread_t js_thread;
+  // Flag to indicate if running in Electron (requires TSFN path always)
+  bool isElectron;
 };
 
 // MARK: - Global Storage