objc-js 1.1.0 → 1.2.1

package/src/native/method-forwarding.mm

@@ -20,6 +20,7 @@ using nobjc::ProtocolManager;
 // NOTE: This function takes ownership of data and must clean it up
 void CallJSCallback(Napi::Env env, Napi::Function jsCallback,
                     InvocationData *data) {
+  @autoreleasepool {
   // Use RAII to ensure cleanup even if we return early or throw
   // The guard will release the invocation and delete data
   InvocationDataGuard guard(data);
@@ -128,6 +129,7 @@ void CallJSCallback(Napi::Env env, Napi::Function jsCallback,
   NOBJC_LOG("CallJSCallback: Signaled completion for %s", data->selectorName.c_str());
 
   // guard destructor cleans up invocation and data
+  } // @autoreleasepool
 }
 
 // MARK: - Fallback Helper
@@ -174,19 +176,18 @@ bool FallbackToTSFN(Napi::ThreadSafeFunction &tsfn, InvocationData *data,
 
 // Override respondsToSelector to return YES for methods we implement
 BOOL RespondsToSelector(id self, SEL _cmd, SEL selector) {
+  @autoreleasepool {
   void *ptr = (__bridge void *)self;
 
-  // Check if this is one of our implemented methods
-  bool found = ProtocolManager::Instance().WithLock([ptr, selector](auto& map) {
+  // Check if this is one of our implemented methods (read-only, shared lock)
+  bool found = ProtocolManager::Instance().WithLockConst([ptr, selector](const 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 true;
-        }
+      auto methodIt = it->second.methods.find(selector);
+      if (methodIt != it->second.methods.end()) {
+        // Cache type encoding for subsequent MethodSignatureForSelector call
+        GetForwardingCache().store(ptr, selector, methodIt->second.typeEncoding.c_str());
+        return true;
       }
     }
     return false;
@@ -199,20 +200,29 @@ BOOL RespondsToSelector(id self, SEL _cmd, SEL selector) {
   // 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];
+  } // @autoreleasepool
 }
 
 // Provide method signature for message forwarding
 NSMethodSignature *MethodSignatureForSelector(id self, SEL _cmd, SEL selector) {
   void *ptr = (__bridge void *)self;
 
-  NSMethodSignature *sig = ProtocolManager::Instance().WithLock([ptr, selector](auto& map) -> NSMethodSignature* {
+  // Check forwarding pipeline cache first (populated by RespondsToSelector)
+  auto& cache = GetForwardingCache();
+  if (cache.matches(ptr, selector)) {
+    NSMethodSignature *sig = [NSMethodSignature signatureWithObjCTypes:cache.typeEncoding];
+    cache.invalidate();
+    if (sig != nil) {
+      return sig;
+    }
+  }
+
+  NSMethodSignature *sig = ProtocolManager::Instance().WithLockConst([ptr, selector](const 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()];
+      auto methodIt = it->second.methods.find(selector);
+      if (methodIt != it->second.methods.end()) {
+        return [NSMethodSignature signatureWithObjCTypes:methodIt->second.typeEncoding.c_str()];
       }
     }
     return nil;
@@ -227,6 +237,7 @@ NSMethodSignature *MethodSignatureForSelector(id self, SEL _cmd, SEL selector) {
 
 // Handle forwarded invocations
 void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
+  @autoreleasepool {
   if (!invocation) {
     NOBJC_ERROR("ForwardInvocation called with nil invocation");
     return;
@@ -237,14 +248,7 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
   [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];
   void *ptr = (__bridge void *)self;
 
   // Set up callbacks for protocol-specific storage access
@@ -253,25 +257,25 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
 
   // 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> {
+                                SEL sel) -> std::optional<ForwardingContext> {
+    return ProtocolManager::Instance().WithLock([lookupKey, sel](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;
       }
 
-      auto callbackIt = it->second.callbacks.find(selName);
-      if (callbackIt == it->second.callbacks.end()) {
-        NOBJC_WARN("Callback not found for selector %s", selName.c_str());
+      auto methodIt = it->second.methods.find(sel);
+      if (methodIt == it->second.methods.end()) {
+        NOBJC_WARN("Callback not found for selector %s", sel_getName(sel));
         return std::nullopt;
       }
 
       // Acquire the TSFN
-      Napi::ThreadSafeFunction tsfn = callbackIt->second;
+      Napi::ThreadSafeFunction tsfn = methodIt->second.tsfn;
       napi_status acq_status = tsfn.Acquire();
       if (acq_status != napi_ok) {
-        NOBJC_WARN("Failed to acquire ThreadSafeFunction for selector %s", selName.c_str());
+        NOBJC_WARN("Failed to acquire ThreadSafeFunction for selector %s", sel_getName(sel));
         return std::nullopt;
       }
 
@@ -284,53 +288,46 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
       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;
-      }
-
-      auto encIt = it->second.typeEncodings.find(selName);
-      if (encIt != it->second.typeEncodings.end()) {
-        ctx.typeEncoding = encIt->second;
-      }
+      ctx.cachedJsCallback = &methodIt->second.jsCallback;
+      ctx.typeEncoding = methodIt->second.typeEncoding;
 
       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 {
+  callbacks.getJSFunction = [](void *lookupKey, SEL sel,
+                                Napi::Env /*env*/) -> Napi::Function {
+    return ProtocolManager::Instance().WithLock([lookupKey, sel](auto& map) -> Napi::Function {
       auto it = map.find(lookupKey);
       if (it == map.end()) {
         return Napi::Function();
       }
 
-      auto jsCallbackIt = it->second.jsCallbacks.find(selName);
-      if (jsCallbackIt == it->second.jsCallbacks.end()) {
+      auto methodIt = it->second.methods.find(sel);
+      if (methodIt == it->second.methods.end()) {
         return Napi::Function();
       }
 
-      return jsCallbackIt->second.Value();
+      return methodIt->second.jsCallback.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> {
+                                SEL sel) -> std::optional<Napi::ThreadSafeFunction> {
+    return ProtocolManager::Instance().WithLock([lookupKey, sel](auto& map) -> std::optional<Napi::ThreadSafeFunction> {
       auto it = map.find(lookupKey);
       if (it == map.end()) {
         return std::nullopt;
       }
 
-      auto callbackIt = it->second.callbacks.find(selName);
-      if (callbackIt == it->second.callbacks.end()) {
+      auto methodIt = it->second.methods.find(sel);
+      if (methodIt == it->second.methods.end()) {
         return std::nullopt;
       }
 
-      Napi::ThreadSafeFunction tsfn = callbackIt->second;
+      Napi::ThreadSafeFunction tsfn = methodIt->second.tsfn;
       napi_status acq_status = tsfn.Acquire();
       if (acq_status != napi_ok) {
         return std::nullopt;
@@ -340,7 +337,8 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
     });
   };
 
-  ForwardInvocationCommon(invocation, selectorName, ptr, callbacks);
+  ForwardInvocationCommon(invocation, selector, ptr, callbacks);
+  } // @autoreleasepool
 }
 
 // Deallocation implementation
@@ -354,13 +352,11 @@ void DeallocImplementation(id self, SEL _cmd) {
         // Release all ThreadSafeFunctions and JS callbacks
         // Do this carefully to avoid issues during shutdown
         try {
-          for (auto &pair : it->second.callbacks) {
+          for (auto &pair : it->second.methods) {
             // Release the ThreadSafeFunction
-            pair.second.Release();
+            pair.second.tsfn.Release();
           }
-          it->second.callbacks.clear();
-          it->second.jsCallbacks.clear();
-          it->second.typeEncodings.clear();
+          it->second.methods.clear();
         } catch (...) {
           // Ignore errors during cleanup
           NOBJC_WARN("Exception during callback cleanup for instance %p", self);

package/src/native/nobjc.mm

@@ -1,4 +1,5 @@
 #include "ObjcObject.h"
+#include "call-function.h"
 #include "pointer-utils.h"
 #include "protocol-impl.h"
 #include "subclass-impl.h"
@@ -21,6 +22,7 @@ Napi::Value LoadLibrary(const Napi::CallbackInfo &info) {
 
 Napi::Value GetClassObject(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
+  @autoreleasepool {
   if (info.Length() != 1 || !info[0].IsString()) {
     throw Napi::TypeError::New(env, "Expected a single string argument");
   }
@@ -31,6 +33,7 @@ Napi::Value GetClassObject(const Napi::CallbackInfo &info) {
     return env.Undefined();
   }
   return ObjcObject::NewInstance(env, cls);
+  } // @autoreleasepool
 }
 
 Napi::Value GetPointer(const Napi::CallbackInfo &info) {
@@ -86,6 +89,7 @@ Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
               Napi::Function::New(env, CreateProtocolImplementation));
   exports.Set("DefineClass", Napi::Function::New(env, DefineClass));
   exports.Set("CallSuper", Napi::Function::New(env, CallSuper));
+  exports.Set("CallFunction", Napi::Function::New(env, CallFunction));
   return exports;
 }
 

package/src/native/protocol-impl.mm

@@ -134,8 +134,7 @@ Napi::Value CreateProtocolImplementation(const Napi::CallbackInfo &info) {
 
   // Store callbacks for this instance (we'll set the instance pointer later)
   ProtocolImplementation impl{
-      .callbacks = {},
-      .typeEncodings = {},
+      .methods = {},
       .className = className,
       .env = env,
       .js_thread = pthread_self(), // Store the current (JS) thread ID
@@ -215,10 +214,12 @@ Napi::Value CreateProtocolImplementation(const Napi::CallbackInfo &info) {
         [](Napi::Env) {}    // Finalizer (no context to clean up)
     );
 
-    // Store both the TSFN and the original JS function
-    impl.callbacks[selectorName] = tsfn;
-    impl.jsCallbacks[selectorName] = Napi::Persistent(jsCallback);
-    impl.typeEncodings[selectorName] = std::string(typeEncoding);
+    // Store method info (TSFN, JS callback, type encoding) in single map
+    impl.methods[selector] = ProtocolMethodInfo{
+        .tsfn = tsfn,
+        .jsCallback = Napi::Persistent(jsCallback),
+        .typeEncoding = std::string(typeEncoding),
+    };
   }
 
   // Override respondsToSelector

package/src/native/protocol-manager.h

@@ -25,6 +25,7 @@
 #include "protocol-storage.h"
 #include <functional>
 #include <mutex>
+#include <shared_mutex>
 #include <optional>
 #include <unordered_map>
 
@@ -60,7 +61,7 @@ public:
    * @note Caller must NOT hold the lock. This method acquires the lock.
    */
   ProtocolImplementation* Find(void* instancePtr) {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::shared_lock<std::shared_mutex> lock(mutex_);
     auto it = implementations_.find(instancePtr);
     if (it != implementations_.end()) {
       return &it->second;
@@ -74,7 +75,7 @@ public:
    * @param impl The implementation to register (moved).
    */
   void Register(void* instancePtr, ProtocolImplementation&& impl) {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::unique_lock<std::shared_mutex> lock(mutex_);
     implementations_.emplace(instancePtr, std::move(impl));
   }
 
@@ -84,7 +85,7 @@ public:
    * @return true if the implementation was found and removed, false otherwise.
    */
   bool Unregister(void* instancePtr) {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::unique_lock<std::shared_mutex> lock(mutex_);
     return implementations_.erase(instancePtr) > 0;
   }
 
@@ -98,7 +99,7 @@ public:
   template <typename Callback>
   auto WithLock(Callback&& callback)
       -> decltype(callback(std::declval<std::unordered_map<void*, ProtocolImplementation>&>())) {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::unique_lock<std::shared_mutex> lock(mutex_);
     return callback(implementations_);
   }
 
@@ -109,7 +110,7 @@ public:
   template <typename Callback>
   auto WithLockConst(Callback&& callback) const
       -> decltype(callback(std::declval<const std::unordered_map<void*, ProtocolImplementation>&>())) {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::shared_lock<std::shared_mutex> lock(mutex_);
     return callback(implementations_);
   }
 
@@ -118,7 +119,7 @@ public:
    * @return Count of implementations.
    */
   size_t Size() const {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::shared_lock<std::shared_mutex> lock(mutex_);
     return implementations_.size();
   }
 
@@ -128,7 +129,7 @@ public:
    * @return true if registered, false otherwise.
    */
   bool Contains(void* instancePtr) const {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::shared_lock<std::shared_mutex> lock(mutex_);
     return implementations_.find(instancePtr) != implementations_.end();
   }
 
@@ -136,7 +137,7 @@ private:
   ProtocolManager() = default;
   ~ProtocolManager() = default;
 
-  mutable std::mutex mutex_;
+  mutable std::shared_mutex mutex_;
   std::unordered_map<void*, ProtocolImplementation> implementations_;
 };
 

package/src/native/protocol-storage.h

@@ -4,10 +4,18 @@
 #include <condition_variable>
 #include <mutex>
 #include <napi.h>
+#include <objc/runtime.h>
 #include <pthread.h>
 #include <string>
 #include <unordered_map>
 
+// Hash functor for SEL (interned pointer — O(1) hash, O(1) compare)
+struct SELHash {
+  size_t operator()(SEL sel) const noexcept {
+    return std::hash<const void *>{}(sel);
+  }
+};
+
 // Forward declarations for Objective-C types
 #ifdef __OBJC__
 @class NSInvocation;
@@ -42,14 +50,17 @@ struct InvocationData {
   void *superClassPtr;
 };
 
+// Information about a single protocol method (combines TSFN, JS callback, and type encoding)
+struct ProtocolMethodInfo {
+  Napi::ThreadSafeFunction tsfn;
+  Napi::FunctionReference jsCallback;
+  std::string typeEncoding;
+};
+
 // Stores information about a protocol implementation instance
 struct ProtocolImplementation {
-  // ThreadSafeFunction for each selector - allows calling JS from any thread
-  std::unordered_map<std::string, Napi::ThreadSafeFunction> callbacks;
-  // Original JS functions for direct calls (kept alive by persistent refs)
-  std::unordered_map<std::string, Napi::FunctionReference> jsCallbacks;
-  // Type encodings for each selector
-  std::unordered_map<std::string, std::string> typeEncodings;
+  // All method info keyed by SEL (interned pointer — O(1) hash/compare)
+  std::unordered_map<SEL, ProtocolMethodInfo, SELHash> methods;
   // Dynamically generated class name
   std::string className;
   // Store the environment for direct calls
@@ -79,8 +90,8 @@ struct SubclassImplementation {
   void *objcClass;       // Class
   // The superclass for super calls
   void *superClass;      // Class
-  // Methods defined by JS (selector -> info)
-  std::unordered_map<std::string, SubclassMethodInfo> methods;
+  // Methods defined by JS (keyed by SEL — O(1) hash/compare)
+  std::unordered_map<SEL, SubclassMethodInfo, SELHash> methods;
   // Store the environment for direct calls
   napi_env env;
   // Store the JS thread ID for thread detection

package/src/native/struct-utils.h

@@ -23,6 +23,7 @@
 #include "type-conversion.h"
 #include <Foundation/Foundation.h>
 #include <map>
+#include <unordered_map>
 #include <napi.h>
 #include <objc/runtime.h>
 #include <string>
@@ -37,7 +38,7 @@
  * field1, etc.
  */
 // clang-format off
-static const std::map<std::string, std::vector<std::string>> KNOWN_STRUCT_FIELDS = {
+static const std::unordered_map<std::string, std::vector<std::string>> KNOWN_STRUCT_FIELDS = {
   // CoreGraphics / AppKit geometry
   {"CGPoint",            {"x", "y"}},
   {"NSPoint",            {"x", "y"}},
@@ -273,6 +274,24 @@ inline ParsedStructType ParseStructEncodingWithNames(const char *encoding) {
   return result;
 }
 
+// MARK: - Cached Struct Encoding Lookup
+
+/**
+ * Return a cached ParsedStructType for the given encoding string.
+ * Avoids re-parsing identical struct type encodings (CGRect, NSRange, etc.)
+ * on every struct argument or return value.
+ */
+inline const ParsedStructType& GetOrParseStructEncoding(const char *encoding) {
+  static std::unordered_map<std::string, ParsedStructType> cache;
+  std::string key(encoding);
+  auto it = cache.find(key);
+  if (it != cache.end()) {
+    return it->second;
+  }
+  auto [inserted_it, _] = cache.emplace(key, ParseStructEncodingWithNames(encoding));
+  return inserted_it->second;
+}
+
 // MARK: - JS Object → Struct Buffer (for arguments)
 
 /**
@@ -498,15 +517,178 @@ inline bool IsStructTypeEncoding(const char *typeEncoding) {
   return *SimplifyTypeEncoding(typeEncoding) == '{';
 }
 
+// MARK: - Fast Path: Specialized Struct Pack/Unpack (H3)
+
+/**
+ * Extract struct name from a type encoding string.
+ * E.g., "{CGRect=...}" → "CGRect", "{_NSRange=QQ}" → "_NSRange"
+ * Returns empty string_view if encoding is malformed.
+ */
+inline std::string_view ExtractStructName(const char *encoding) {
+  if (!encoding || *encoding != '{') return {};
+  const char *start = encoding + 1;
+  const char *end = start;
+  while (*end && *end != '=' && *end != '}') end++;
+  return {start, static_cast<size_t>(end - start)};
+}
+
+/**
+ * Fast-path pack for CGPoint / NSPoint: { double x, y }
+ * Reads jsValue.x and jsValue.y directly into buffer.
+ * Returns true if handled, false to fall through to generic path.
+ */
+inline bool TryPackCGPoint(Napi::Env env, const Napi::Value &jsValue,
+                           uint8_t *buffer) {
+  if (!jsValue.IsObject() || jsValue.IsArray()) return false;
+  Napi::Object obj = jsValue.As<Napi::Object>();
+  double x = obj.Get("x").As<Napi::Number>().DoubleValue();
+  double y = obj.Get("y").As<Napi::Number>().DoubleValue();
+  memcpy(buffer, &x, sizeof(double));
+  memcpy(buffer + sizeof(double), &y, sizeof(double));
+  return true;
+}
+
+/**
+ * Fast-path unpack for CGPoint / NSPoint: { double x, y }
+ */
+inline Napi::Value TryUnpackCGPoint(Napi::Env env, const uint8_t *buffer) {
+  double x, y;
+  memcpy(&x, buffer, sizeof(double));
+  memcpy(&y, buffer + sizeof(double), sizeof(double));
+  Napi::Object result = Napi::Object::New(env);
+  result.Set("x", Napi::Number::New(env, x));
+  result.Set("y", Napi::Number::New(env, y));
+  return result;
+}
+
+/**
+ * Fast-path pack for CGSize / NSSize: { double width, height }
+ */
+inline bool TryPackCGSize(Napi::Env env, const Napi::Value &jsValue,
+                          uint8_t *buffer) {
+  if (!jsValue.IsObject() || jsValue.IsArray()) return false;
+  Napi::Object obj = jsValue.As<Napi::Object>();
+  double w = obj.Get("width").As<Napi::Number>().DoubleValue();
+  double h = obj.Get("height").As<Napi::Number>().DoubleValue();
+  memcpy(buffer, &w, sizeof(double));
+  memcpy(buffer + sizeof(double), &h, sizeof(double));
+  return true;
+}
+
+/**
+ * Fast-path unpack for CGSize / NSSize: { double width, height }
+ */
+inline Napi::Value TryUnpackCGSize(Napi::Env env, const uint8_t *buffer) {
+  double w, h;
+  memcpy(&w, buffer, sizeof(double));
+  memcpy(&h, buffer + sizeof(double), sizeof(double));
+  Napi::Object result = Napi::Object::New(env);
+  result.Set("width", Napi::Number::New(env, w));
+  result.Set("height", Napi::Number::New(env, h));
+  return result;
+}
+
+/**
+ * Fast-path pack for CGRect / NSRect: { CGPoint origin, CGSize size }
+ * Memory layout: [origin.x, origin.y, size.width, size.height] — 4 doubles
+ */
+inline bool TryPackCGRect(Napi::Env env, const Napi::Value &jsValue,
+                          uint8_t *buffer) {
+  if (!jsValue.IsObject() || jsValue.IsArray()) return false;
+  Napi::Object obj = jsValue.As<Napi::Object>();
+  Napi::Object origin = obj.Get("origin").As<Napi::Object>();
+  Napi::Object size = obj.Get("size").As<Napi::Object>();
+  double vals[4];
+  vals[0] = origin.Get("x").As<Napi::Number>().DoubleValue();
+  vals[1] = origin.Get("y").As<Napi::Number>().DoubleValue();
+  vals[2] = size.Get("width").As<Napi::Number>().DoubleValue();
+  vals[3] = size.Get("height").As<Napi::Number>().DoubleValue();
+  memcpy(buffer, vals, sizeof(vals));
+  return true;
+}
+
+/**
+ * Fast-path unpack for CGRect / NSRect.
+ */
+inline Napi::Value TryUnpackCGRect(Napi::Env env, const uint8_t *buffer) {
+  double vals[4];
+  memcpy(vals, buffer, sizeof(vals));
+
+  Napi::Object origin = Napi::Object::New(env);
+  origin.Set("x", Napi::Number::New(env, vals[0]));
+  origin.Set("y", Napi::Number::New(env, vals[1]));
+
+  Napi::Object size = Napi::Object::New(env);
+  size.Set("width", Napi::Number::New(env, vals[2]));
+  size.Set("height", Napi::Number::New(env, vals[3]));
+
+  Napi::Object result = Napi::Object::New(env);
+  result.Set("origin", origin);
+  result.Set("size", size);
+  return result;
+}
+
+/**
+ * Fast-path pack for NSRange / _NSRange: { NSUInteger location, length }
+ * On 64-bit, NSUInteger = unsigned long long = 8 bytes.
+ */
+inline bool TryPackNSRange(Napi::Env env, const Napi::Value &jsValue,
+                           uint8_t *buffer) {
+  if (!jsValue.IsObject() || jsValue.IsArray()) return false;
+  Napi::Object obj = jsValue.As<Napi::Object>();
+  uint64_t location = static_cast<uint64_t>(
+      obj.Get("location").As<Napi::Number>().Int64Value());
+  uint64_t length = static_cast<uint64_t>(
+      obj.Get("length").As<Napi::Number>().Int64Value());
+  memcpy(buffer, &location, sizeof(uint64_t));
+  memcpy(buffer + sizeof(uint64_t), &length, sizeof(uint64_t));
+  return true;
+}
+
+/**
+ * Fast-path unpack for NSRange / _NSRange.
+ */
+inline Napi::Value TryUnpackNSRange(Napi::Env env, const uint8_t *buffer) {
+  uint64_t location, length;
+  memcpy(&location, buffer, sizeof(uint64_t));
+  memcpy(&length, buffer + sizeof(uint64_t), sizeof(uint64_t));
+  Napi::Object result = Napi::Object::New(env);
+  result.Set("location", Napi::Number::New(env, static_cast<double>(location)));
+  result.Set("length", Napi::Number::New(env, static_cast<double>(length)));
+  return result;
+}
+
 /**
  * Pack a JS value into a newly allocated struct buffer.
  * Returns a vector<uint8_t> that must be kept alive until after the
  * NSInvocation is invoked.
+ *
+ * Tries specialized fast paths for CGRect/CGPoint/CGSize/NSRange first,
+ * falling through to the generic parser for other struct types.
  */
 inline std::vector<uint8_t>
 PackJSValueAsStruct(Napi::Env env, const Napi::Value &jsValue,
                     const char *typeEncoding) {
-  ParsedStructType parsed = ParseStructEncodingWithNames(typeEncoding);
+  // Fast path: check struct name for well-known types
+  auto name = ExtractStructName(typeEncoding);
+  if (!name.empty()) {
+    if (name == "CGRect" || name == "NSRect") {
+      std::vector<uint8_t> buffer(4 * sizeof(double), 0);
+      if (TryPackCGRect(env, jsValue, buffer.data())) return buffer;
+    } else if (name == "CGPoint" || name == "NSPoint") {
+      std::vector<uint8_t> buffer(2 * sizeof(double), 0);
+      if (TryPackCGPoint(env, jsValue, buffer.data())) return buffer;
+    } else if (name == "CGSize" || name == "NSSize") {
+      std::vector<uint8_t> buffer(2 * sizeof(double), 0);
+      if (TryPackCGSize(env, jsValue, buffer.data())) return buffer;
+    } else if (name == "_NSRange" || name == "NSRange") {
+      std::vector<uint8_t> buffer(2 * sizeof(uint64_t), 0);
+      if (TryPackNSRange(env, jsValue, buffer.data())) return buffer;
+    }
+  }
+
+  // Generic path: parse encoding and pack recursively
+  const ParsedStructType &parsed = GetOrParseStructEncoding(typeEncoding);
 
   if (parsed.fields.empty()) {
     throw Napi::Error::New(
@@ -520,11 +702,29 @@ PackJSValueAsStruct(Napi::Env env, const Napi::Value &jsValue,
 
 /**
  * Unpack a struct byte buffer into a JS object.
+ *
+ * Tries specialized fast paths for CGRect/CGPoint/CGSize/NSRange first,
+ * falling through to the generic parser for other struct types.
  */
 inline Napi::Value UnpackStructToJSValue(Napi::Env env,
-                                         const uint8_t *buffer,
-                                         const char *typeEncoding) {
-  ParsedStructType parsed = ParseStructEncodingWithNames(typeEncoding);
+                                          const uint8_t *buffer,
+                                          const char *typeEncoding) {
+  // Fast path: check struct name for well-known types
+  auto name = ExtractStructName(typeEncoding);
+  if (!name.empty()) {
+    if (name == "CGRect" || name == "NSRect") {
+      return TryUnpackCGRect(env, buffer);
+    } else if (name == "CGPoint" || name == "NSPoint") {
+      return TryUnpackCGPoint(env, buffer);
+    } else if (name == "CGSize" || name == "NSSize") {
+      return TryUnpackCGSize(env, buffer);
+    } else if (name == "_NSRange" || name == "NSRange") {
+      return TryUnpackNSRange(env, buffer);
+    }
+  }
+
+  // Generic path
+  const ParsedStructType &parsed = GetOrParseStructEncoding(typeEncoding);
 
   if (parsed.fields.empty()) {
     NOBJC_ERROR("UnpackStructToJSValue: Failed to parse struct encoding '%s'",