brick-module 0.1.26 → 0.4.0

package/BrickModule.podspec

@@ -17,7 +17,7 @@ Pod::Spec.new do |s|
   s.public_header_files = "ios/BrickModule/Public/*.h"
   s.private_header_files = "ios/BrickModule/Internal/*.h"
   
-  # Swift 설정
+  # Swift settings
   s.swift_version = "5.0"
   s.requires_arc = true
 

package/android/brick_modules.gradle

@@ -68,6 +68,29 @@ ext.getBrickAndroidPath = { projectRoot ->
     return new File(projectRoot, 'android/.brick').canonicalPath
 }
 
+ext.getBrickAndroidAppPath = { projectRoot ->
+    // Read brick.json from explicit project root
+    try {
+        def brickConfigFile = new File(projectRoot, 'brick.json')
+        if (brickConfigFile.exists()) {
+            def config = new JsonSlurper().parse(brickConfigFile)
+            def androidAppPath = config?.output?.androidAppPath
+            if (androidAppPath && !androidAppPath.isEmpty()) {
+                if (new File(androidAppPath).isAbsolute()) {
+                    println("[Brick] Warning: Using absolute path for Android app path is not recommended: ${androidAppPath}")
+                    return androidAppPath
+                }
+                return new File(projectRoot, androidAppPath).canonicalPath
+            }
+        }
+    } catch (Exception e) {
+        println("[Brick] Warning: Failed to read brick.json from ${projectRoot}: ${e.message}")
+    }
+
+    // Default: android/app in project root
+    return new File(projectRoot, 'android/app').canonicalPath
+}
+
 ext.getAllDependencies = { packageJson ->
     def deps = []
     deps.addAll(packageJson.dependencies?.keySet() ?: [])
@@ -396,7 +419,23 @@ ${moduleNames}
     project.preBuild.doFirst {
         def workingDir = projectRoot
         
-        // Run codegen inline
+        // Skip codegen if already generated to prevent deleting Gradle build outputs
+        // The codegen is already run during settings.gradle phase (applyBrickModules -> runBrickCodegen)
+        // Re-running here with --clean would delete .brick_android/build/ directory
+        // which contains package-aware-r.txt needed by dependent modules
+        def brickOutputDir = getBrickAndroidPath(workingDir)
+        def generatedMarker = new File(brickOutputDir, "src/main/kotlin/BrickModule.kt")
+        def androidAppPath = getBrickAndroidAppPath(workingDir)
+        def jniDir = new File(androidAppPath, "build/generated/autolinking/src/main/jni")
+        def hasJniOutputs = new File(jniDir, "BrickModuleSpec-generated.cpp").exists() &&
+            new File(jniDir, "BrickModuleSpec.h").exists() &&
+            new File(jniDir, "CMakeLists.txt").exists()
+        if (generatedMarker.exists() && hasJniOutputs) {
+            // Already generated, skip to preserve build outputs
+            return
+        }
+
+        // Run codegen only if not yet generated
         try {
             def proc = ['node', '-p', "require.resolve('brick-module/package.json')"].execute(null, workingDir)
             proc.waitFor()
@@ -408,7 +447,11 @@ ${moduleNames}
                     def codegenPath = new File(brickModuleDir, "bin/brick-codegen.js")
                     
                     if (codegenPath.exists()) {
-                        def codegenProc = ['node', codegenPath.absolutePath, '--platform', 'android', '--projectRoot', workingDir.absolutePath].execute(null, workingDir)
+                        def codegenArgs = ['node', codegenPath.absolutePath, '--platform', 'android', '--projectRoot', workingDir.absolutePath]
+                        if (generatedMarker.exists()) {
+                            codegenArgs.add('--no-clean')
+                        }
+                        def codegenProc = codegenArgs.execute(null, workingDir)
                         codegenProc.waitFor()
                     }
                 }

package/android/src/main/java/com/brickmodule/BrickModuleBase.kt

@@ -9,13 +9,22 @@ import com.facebook.react.bridge.ReactContext
 interface BrickModuleBase {
     /** The name of the module (required for registration) */
     val moduleName: String
-    
+
     /**
      * Returns the constants exposed by this module
      * Override this method to provide module-specific constants
      * @return Map of constant name to value
      */
     fun getConstants(): Map<String, Any> = emptyMap()
+
+    /**
+     * Emits an event to JavaScript using React Native's auto-generated event emitters
+     * This method should be implemented by the bridge layer to call the appropriate
+     * auto-generated emitModuleName_onEventName method from React Native Codegen
+     * @param eventName The name of the event (e.g., "onCalculationCompleted")
+     * @param payload The event data as a Map
+     */
+    fun emitEvent(eventName: String, payload: Map<String, Any>)
 }
 
 /**
@@ -31,38 +40,63 @@ abstract class BrickModuleSpec(private val reactContext: ReactContext) : BrickMo
     protected fun getReactContext(): ReactContext = reactContext
 
     /**
-     * Send an event to JavaScript This method handles event validation and routing through the
-     * BrickHost
-     *
-     * @param eventName The name of the event (without module prefix)
-     * @param data The event data to send
+     * Event emitter callback set by the bridge layer
+     * This allows the bridge to provide access to auto-generated event emitter methods
      */
-    protected fun sendEvent(eventName: String, data: Any?) {
-        val context = getReactContext()
-
-        // Format event name with module prefix
-        val fullEventName = "${moduleName}_$eventName"
+    var eventEmitterCallback: ((String, Map<String, Any>) -> Unit)? = null
 
-        // Get the BrickHost from ReactContext
-        val activity = context.currentActivity
-        if (activity !is BrickModuleRegistrar) {
-            println(
-                    "❌ $moduleName: Current activity does not implement BrickHost, cannot send event"
+    /**
+     * Emits an event to JavaScript using React Native's auto-generated event emitters
+     * Delegates to the bridge layer which has access to the generated emitModuleName_onEventName methods
+     */
+    override fun emitEvent(eventName: String, payload: Map<String, Any>) {
+        eventEmitterCallback?.invoke(eventName, payload)
+            ?: throw IllegalStateException(
+                "Event emitter callback not set for module $moduleName. " +
+                "Events cannot be emitted until the module is registered with the bridge."
             )
-            return
-        }
-
-        // Send event via BrickHost's moduleRegistry
-        try {
-            activity.getModuleRegistry().sendEvent(context, fullEventName, data)
-        } catch (e: Exception) {
-            println("❌ $moduleName: Failed to send event $fullEventName: ${e.message}")
-        }
     }
 }
 
-/** Error types for Brick modules */
-open class BrickModuleError(message: String, val errorCode: String) : Exception(message) {
+// MARK: - BrickError Interface
+
+/**
+ * Error interface for Brick modules.
+ * Implement this interface to propagate all error properties to JavaScript.
+ * Follows the same pattern as iOS BrickError protocol.
+ *
+ * Note: message is inherited from Throwable, so it's not defined in this interface.
+ * Classes implementing BrickError must extend Exception/Throwable.
+ */
+interface BrickError {
+    /** Error code (accessed as error.name in JS) */
+    val code: String
+
+    /** Additional properties (accessed as error.userInfo.xxx in JS) */
+    val userInfo: Map<String, Any>?
+        get() = null
+}
+
+/**
+ * Default implementation of BrickError.
+ * Extend this class to create custom errors.
+ */
+open class BrickException(
+    override val code: String,
+    message: String,
+    override val userInfo: Map<String, Any>? = null,
+    cause: Throwable? = null
+) : Exception(message, cause), BrickError
+
+/** Error types for Brick modules - implements BrickError interface */
+open class BrickModuleError(
+    message: String,
+    override val code: String
+) : Exception(message), BrickError {
+
+    override val userInfo: Map<String, Any>?
+        get() = null
+
     class TypeMismatch(message: String) : BrickModuleError("Type mismatch: $message", "TYPE_ERROR")
     class ExecutionError(message: String) :
             BrickModuleError("Execution error: $message", "EXECUTION_ERROR")

package/android/src/main/java/com/brickmodule/BrickModuleRegistry.kt

@@ -1,7 +1,6 @@
 package com.brickmodule
 
 import com.facebook.react.bridge.ReactContext
-import com.facebook.react.modules.core.DeviceEventManagerModule
 import java.util.concurrent.ConcurrentHashMap
 
 /**
@@ -73,37 +72,7 @@ class BrickModuleRegistry {
         return modules.keys.toList().sorted()
     }
 
-    /**
-     * Sends an event to JavaScript Used by modules to emit events to JavaScript
-     *
-     * @param context The ReactContext to send the event to
-     * @param eventName The name of the event to send
-     * @param data The event data
-     */
-    fun sendEvent(context: ReactContext, eventName: String, data: Any?) {
-        try {
-            // Ensure modules are registered
-            if (!isRegistered) {
-                println(
-                        "⚠️ BrickModuleRegistry: Modules not registered, skipping event: $eventName"
-                )
-                return
-            }
-
-            // Convert data to React Native compatible format using helper
-            val eventData = EventDataConverter.convert(data)
-
-            println("[BrickModule] sendEvent Context: $context")
-
-            context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                    .emit(eventName, eventData)
-
-            println("📡 BrickModuleRegistry: Event sent successfully: $eventName")
-        } catch (e: Exception) {
-            println("❌ BrickModuleRegistry: Failed to send event $eventName: ${e.message}")
-            e.printStackTrace()
-        }
-    }
+    // No DeviceEventEmitter-based event path; events handled via RN Codegen EventEmitter
 
     /** Returns all constants from registered modules */
     fun getAllConstants(): Map<String, Any> {

package/dist/BrickError.d.ts

@@ -0,0 +1,29 @@
+//#region src/BrickError.d.ts
+/**
+ * BrickError - Type-safe class for custom errors from native modules.
+ * Matches the structure of iOS/Android BrickError.
+ */
+declare class BrickError extends Error {
+  /** Error code (same as error.name) */
+  readonly code: string;
+  /** Additional properties (e.g., amount, currency) */
+  readonly userInfo: Record<string, unknown>;
+  /** Name of the module where the error occurred */
+  readonly moduleName?: string;
+  constructor(message: string, code: string, userInfo?: Record<string, unknown>, moduleName?: string);
+  /**
+   * Type guard to check if an error object is a BrickError.
+   * @param error - The error object to check
+   * @returns true if the error is a BrickError
+   */
+  static isBrickError(error: unknown): error is BrickError;
+  /**
+   * Converts a general error object to a BrickError.
+   * @param error - The error object to convert
+   * @param moduleName - Name of the module where the error occurred
+   * @returns A BrickError instance
+   */
+  static from(error: unknown, moduleName?: string): BrickError;
+}
+//#endregion
+export { BrickError };

package/dist/BrickError.js

@@ -0,0 +1,49 @@
+//#region src/BrickError.ts
+/**
+* BrickError - Type-safe class for custom errors from native modules.
+* Matches the structure of iOS/Android BrickError.
+*/
+var BrickError = class BrickError extends Error {
+	/** Error code (same as error.name) */
+	code;
+	/** Additional properties (e.g., amount, currency) */
+	userInfo;
+	/** Name of the module where the error occurred */
+	moduleName;
+	constructor(message, code, userInfo = {}, moduleName) {
+		super(message);
+		this.name = code;
+		this.code = code;
+		this.userInfo = userInfo;
+		this.moduleName = moduleName;
+	}
+	/**
+	* Type guard to check if an error object is a BrickError.
+	* @param error - The error object to check
+	* @returns true if the error is a BrickError
+	*/
+	static isBrickError(error) {
+		return error instanceof Error && typeof error.code === "string" && typeof error.userInfo === "object" && error.userInfo !== null;
+	}
+	/**
+	* Converts a general error object to a BrickError.
+	* @param error - The error object to convert
+	* @param moduleName - Name of the module where the error occurred
+	* @returns A BrickError instance
+	*/
+	static from(error, moduleName) {
+		if (error instanceof BrickError) {
+			if (moduleName && !error.moduleName) return new BrickError(error.message, error.code, error.userInfo, moduleName);
+			return error;
+		}
+		if (BrickError.isBrickError(error)) return new BrickError(error.message, error.code, error.userInfo, moduleName || error.moduleName);
+		if (error instanceof Error) {
+			const anyError = error;
+			return new BrickError(error.message, anyError.code || anyError.name || "UNKNOWN_ERROR", anyError.userInfo || {}, moduleName || anyError.moduleName);
+		}
+		return new BrickError(String(error), "UNKNOWN_ERROR", {}, moduleName);
+	}
+};
+
+//#endregion
+export { BrickError };

package/dist/BrickModule.d.ts

@@ -7,7 +7,6 @@ import { TurboModule } from "react-native";
  */
 interface BrickModuleInterface extends TurboModule {
   readonly moduleName: string;
-  readonly supportedEvents?: readonly string[];
 }
 /**
  * Type alias for module specifications
@@ -23,15 +22,7 @@ type BrickModuleSpec = BrickModuleInterface;
 /**
  * Enhanced typed module interface with event listeners
  */
-type BrickModuleWithEvents<T extends BrickModuleInterface> = T & {
-  /**
-   * Adds a type-safe event listener for this module
-   * @param eventName - One of the supported events defined in the module spec
-   * @param listener - Callback function to handle the event
-   * @returns Unsubscription function to remove the listener
-   */
-  addEventListener<TEvent = unknown>(eventName: T["supportedEvents"] extends readonly (infer U)[] ? U : never, listener: (event: TEvent) => void): () => void;
-};
+type BrickModuleWithEvents<T extends BrickModuleInterface> = T;
 /**
  * Gets a typed module instance by name with explicit type parameter
  * @param moduleName - The exact name of the module as defined in its spec

package/dist/BrickModule.js

@@ -1,9 +1,9 @@
-import { NativeEventEmitter, TurboModuleRegistry } from "react-native";
+import { BrickError } from "./BrickError.js";
+import { TurboModuleRegistry } from "react-native";
 
 //#region src/BrickModule.ts
 const moduleCache = /* @__PURE__ */ new Map();
 let nativeModule = null;
-let eventEmitter = null;
 /**
 * Gets the native TurboModule instance
 * @private
@@ -12,13 +12,6 @@ function getNativeModule() {
 	if (!nativeModule) nativeModule = TurboModuleRegistry.getEnforcing("BrickModule");
 	return nativeModule;
 }
-function getEventEmitter() {
-	if (!eventEmitter) {
-		eventEmitter = new NativeEventEmitter(getNativeModule());
-		console.log("eventEmitter", eventEmitter);
-	}
-	return eventEmitter;
-}
 /**
 * Gets a typed module instance by name with explicit type parameter
 * @param moduleName - The exact name of the module as defined in its spec
@@ -28,33 +21,46 @@ function get(moduleName) {
 	const cacheKey = moduleName;
 	if (moduleCache.has(cacheKey)) return moduleCache.get(cacheKey);
 	const nativeModuleInstance = getNativeModule();
+	let constantsCache = null;
 	const moduleProxy = new Proxy({}, {
 		get: (_target, property) => {
 			if (typeof property !== "string") return;
-			if (property === "addEventListener") return (eventName, listener) => {
-				const emitter = getEventEmitter();
-				try {
-					const native = getNativeModule();
-					const moduleAddName = `${moduleName}_onEventListenerAdded`;
-					if (typeof native[moduleAddName] === "function") native[moduleAddName](eventName);
-				} catch {}
-				const subscription = emitter.addListener(`${moduleName}_${eventName}`, listener);
-				return () => {
-					const native = getNativeModule();
-					const moduleRemoveName = `${moduleName}_onEventListenerRemoved`;
-					try {
-						if (typeof native[moduleRemoveName] === "function") native[moduleRemoveName](eventName);
-					} catch {} finally {
-						subscription.remove();
-					}
-				};
+			if (property.startsWith("on") && property.length > 2 && property[2] === property[2].toUpperCase()) return (listener) => {
+				const nativeEventMethod = `${moduleName}_${property}`;
+				const nativeFn = nativeModuleInstance[nativeEventMethod];
+				if (typeof nativeFn === "function") return nativeFn(listener);
+				throw new Error(`${nativeEventMethod} is not available. Did you run RN codegen?`);
+			};
+			if (property === "getConstants") return () => {
+				if (constantsCache !== null) return constantsCache;
+				const allConstants = nativeModuleInstance?.getConstants?.() ?? {};
+				const moduleConstants = {};
+				const constantPrefix = `${moduleName}_`;
+				for (const key in allConstants) if (key.startsWith(constantPrefix)) {
+					const propName = key.substring(constantPrefix.length);
+					moduleConstants[propName] = allConstants[key];
+				}
+				constantsCache = moduleConstants;
+				return moduleConstants;
 			};
-			const allConstants = nativeModuleInstance?.getConstants?.() ?? {};
-			const constantKey = `${moduleName}_${property}`;
-			if (constantKey in allConstants) return allConstants[constantKey];
 			return (...args) => {
 				const methodKey = `${moduleName}_${property}`;
-				if (typeof nativeModuleInstance[methodKey] === "function") return nativeModuleInstance[methodKey](...args);
+				if (typeof nativeModuleInstance[methodKey] === "function") {
+					const result = nativeModuleInstance[methodKey](...args);
+					if (result && typeof result === "object" && result["~sync"] === true) if (result.success === true) return result.value;
+					else {
+						const errorInfo = result.error || {};
+						const message = errorInfo.message || errorInfo.errorMessage || "Unknown error";
+						const code = errorInfo.code || errorInfo.errorCode || "BRICK_ERROR";
+						const userInfo = { code };
+						for (const key of Object.keys(errorInfo)) if (key !== "code" && key !== "message" && key !== "errorCode" && key !== "errorMessage") userInfo[key] = errorInfo[key];
+						throw new BrickError(message, code, userInfo, moduleName);
+					}
+					if (result && typeof result.then === "function") return result.catch((error) => {
+						throw BrickError.from(error, moduleName);
+					});
+					return result;
+				}
 				throw new Error(`Method ${methodKey} not found`);
 			};
 		},

package/dist/index.d.ts

@@ -1,17 +1,9 @@
 import { BrickModule, BrickModuleInterface, BrickModuleSpec } from "./BrickModule.js";
+import { BrickError } from "./BrickError.js";
 import { Any, AnyObject } from "./types.js";
 
 //#region src/index.d.ts
 
-/**
- * Error types for Brick modules
- */
-declare class BrickModuleError extends Error {
-  code: string;
-  moduleName?: string | undefined;
-  methodName?: string | undefined;
-  constructor(message: string, code?: string, moduleName?: string | undefined, methodName?: string | undefined);
-}
 /**
  * Configuration interface for brick-codegen
  */
@@ -29,4 +21,4 @@ interface BrickCodegenConfig {
   dev?: boolean;
 }
 //#endregion
-export { Any, AnyObject, BrickCodegenConfig, BrickModule, BrickModuleError, type BrickModuleInterface, type BrickModuleSpec };
+export { Any, AnyObject, BrickCodegenConfig, BrickError, BrickModule, type BrickModuleInterface, type BrickModuleSpec };

package/dist/index.js

@@ -1,18 +1,4 @@
+import { BrickError } from "./BrickError.js";
 import BrickModule_default from "./BrickModule.js";
 
-//#region src/index.ts
-/**
-* Error types for Brick modules
-*/
-var BrickModuleError = class extends Error {
-	constructor(message, code = "BRICK_ERROR", moduleName, methodName) {
-		super(message);
-		this.code = code;
-		this.moduleName = moduleName;
-		this.methodName = methodName;
-		this.name = "BrickModuleError";
-	}
-};
-
-//#endregion
-export { BrickModule_default as BrickModule, BrickModuleError };
+export { BrickError, BrickModule_default as BrickModule };

package/ios/BrickModule/BrickCoreModule.swift

@@ -1,6 +1,48 @@
 import Foundation
 import React
 
+// MARK: - BrickError Protocol
+
+/// Error protocol for Brick modules.
+/// Conforming to this protocol propagates all error properties to JavaScript.
+public protocol BrickError: Error {
+    /// Error message (accessed as error.message in JS)
+    var message: String { get }
+
+    /// Error code (accessed as error.code in JS, optional)
+    var code: String? { get }
+
+    /// Additional properties (accessed as error.userInfo.xxx in JS)
+    var userInfo: [String: Any]? { get }
+
+    /// Convert to NSError (for React Native reject)
+    func asNSError() -> NSError
+}
+
+public extension BrickError {
+    /// Default code implementation
+    var code: String? { nil }
+
+    /// Default userInfo implementation
+    var userInfo: [String: Any]? { nil }
+
+    /// Default NSError conversion implementation
+    func asNSError() -> NSError {
+        var info: [String: Any] = userInfo ?? [:]
+        info["code"] = code ?? "EXECUTION_ERROR"
+        info["message"] = message
+        info[NSLocalizedDescriptionKey] = message
+        return NSError(domain: "BrickModule", code: 0, userInfo: info)
+    }
+
+    /// Error code to use when calling reject
+    var rejectCode: String {
+        code ?? "EXECUTION_ERROR"
+    }
+}
+
+// MARK: - BrickModuleBase
+
 /**
  * Base class for all Brick modules
  * Provides common functionality including event emission
@@ -9,7 +51,9 @@ open class BrickModuleBase: NSObject {
     /// The name of the module (required for registration)
     public let moduleName: String
     
-    public weak var eventEmitter: RCTEventEmitter?
+    /// The registry that manages this module (assigned during registration)
+    public weak var registry: BrickModuleRegistry?
+    
     public weak var bridgeProxy: RCTBridgeProxy?
     
     /// Initialize with module name
@@ -18,61 +62,45 @@ open class BrickModuleBase: NSObject {
         super.init()
     }
     
-    /// Sends an event with the given name and data
-    /// Automatically prefixes with module name and uses the registry's event emitter
-    public func sendEvent(_ eventName: String, data: Any?) {
-        // Format event name with module prefix
-        let fullEventName = "\(moduleName)_\(eventName)"
-        
-        // Get the shared event emitter instance and send event
-        if let eventEmitter = self.eventEmitter {
-            eventEmitter.sendEvent(withName: fullEventName, body: data)
-        } else {
-            let error = NSError(domain: "BrickModule", code: 500, userInfo: [
-                NSLocalizedDescriptionKey: "Event emitter not available, cannot send event: \(fullEventName)"
-            ])
-            print("Error: \(error.localizedDescription)")
+    // Emit via Registry event map (ObjC++ injects typed handlers per event)
+    public func emit(_ eventName: String, payload: [String: Any]) {
+        guard let registry = registry else {
+            print("⚠️ BrickModuleBase: registry not attached; cannot emit \(moduleName).\(eventName)")
+            return
         }
+        registry.emitEvent(module: moduleName, event: eventName, payload: payload)
     }
 }
 
+// MARK: - BrickModuleError
+
 /**
  * Error types for Brick modules
  */
-public enum BrickModuleError: Error, LocalizedError {
+public enum BrickModuleError: BrickError {
     case typeMismatch(String)
     case executionError(String)
     case invalidDefinition(String)
     case methodNotFound(String)
     case moduleNotFound(String)
-    
-    public var errorDescription: String? {
+
+    public var code: String? {
         switch self {
-        case .typeMismatch(let message):
-            return "Type mismatch: \(message)"
-        case .executionError(let message):
-            return "Execution error: \(message)"
-        case .invalidDefinition(let message):
-            return "Invalid definition: \(message)"
-        case .methodNotFound(let message):
-            return "Method not found: \(message)"
-        case .moduleNotFound(let message):
-            return "Module not found: \(message)"
+        case .typeMismatch: return "TYPE_ERROR"
+        case .executionError: return "EXECUTION_ERROR"
+        case .invalidDefinition: return "DEFINITION_ERROR"
+        case .methodNotFound: return "METHOD_NOT_FOUND"
+        case .moduleNotFound: return "MODULE_NOT_FOUND"
         }
     }
-    
-    public var errorCode: String {
+
+    public var message: String {
         switch self {
-        case .typeMismatch:
-            return "TYPE_ERROR"
-        case .executionError:
-            return "EXECUTION_ERROR"
-        case .invalidDefinition:
-            return "DEFINITION_ERROR"
-        case .methodNotFound:
-            return "METHOD_NOT_FOUND"
-        case .moduleNotFound:
-            return "MODULE_NOT_FOUND"
+        case .typeMismatch(let msg): return "Type mismatch: \(msg)"
+        case .executionError(let msg): return "Execution error: \(msg)"
+        case .invalidDefinition(let msg): return "Invalid definition: \(msg)"
+        case .methodNotFound(let msg): return "Method not found: \(msg)"
+        case .moduleNotFound(let msg): return "Module not found: \(msg)"
         }
     }
 }

package/ios/BrickModule/BrickModuleRegistry.swift

@@ -10,8 +10,11 @@ import React
     
     private var modules: [String: BrickModuleBase] = [:]
     private var isRegistered: Bool = false
-    private weak var eventEmitter: RCTEventEmitter?
+    public weak var brickTurboModule: NSObject?
     private weak var bridgeProxy: RCTBridgeProxy?;
+    // Event map injected from BrickModuleImpl (already converted to Swift types)
+    // Nested structure: [ModuleName: [EventName: Handler]]
+    private var eventMap: [String: [String: ([String: Any]) -> Void]] = [:]
     
     public override init() {
         super.init()
@@ -59,8 +62,8 @@ import React
         
         // Register the module
         modules[moduleName] = module
-        modules[moduleName]?.eventEmitter = self.eventEmitter;
         modules[moduleName]?.bridgeProxy = self.bridgeProxy;
+        modules[moduleName]?.registry = self
         print("📦 BrickModuleRegistry: Registered module '\(moduleName)'")
     }
     
@@ -82,33 +85,30 @@ import React
         }
     }
     
-    /**
-     * Returns list of registered module names
-     */
-    @objc public func getRegisteredModules() -> [String] {
-        return Array(modules.keys).sorted()
+    // Receives event map from BrickModuleImpl (already converted to Swift types)
+    public func setEventMap(_ map: [String: [String: ([String: Any]) -> Void]]) {
+        self.eventMap = map
     }
-    
-    // MARK: - Event Emitter Management
-    
-    /**
-     * Sets the React Native event emitter instance for event emission
-     * This should be called during app initialization frBrickModuleom the main BrickModule
-     */
-    public func setEventEmitter(_ eventEmitter: Any) {
-        self.eventEmitter = eventEmitter as? RCTEventEmitter
-        for module in modules {
-            module.value.eventEmitter = self.eventEmitter
+
+    // Emit event by module+event via typed block
+    @objc public func emitEvent(module: String, event: String, payload: [String: Any]) {
+        // Direct lookup without string manipulation
+        if let moduleEvents = eventMap[module],
+           let handler = moduleEvents[event] {
+            handler(payload)
+        } else {
+            print("⚠️ BrickModuleRegistry: No handler for module '\(module)' event '\(event)'")
         }
     }
     
     /**
-     * Returns the React Native event emitter instance for event emission
-     * Used by generated module code to emit events to JavaScript
+     * Returns list of registered module names
      */
-    @objc public func getEventEmitter() -> RCTEventEmitter? {
-        return eventEmitter
+    @objc public func getRegisteredModules() -> [String] {
+        return Array(modules.keys).sorted()
     }
+    
+    // MARK: - Event Emitter Management removed (CodegenTypes.EventEmitter is used)
         
     /**
      * Unregisters all modules and clears their registry references
@@ -125,8 +125,3 @@ import React
         unregister()
     }
 }
-
-public class ModuleRegistry {
-    
-}
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brick-module",
-  "version": "0.1.26",
+  "version": "0.4.0",
   "description": "Better React Native native module development",
   "type": "module",
   "main": "dist/index.js",
@@ -34,10 +34,6 @@
     "BrickModule.podspec",
     "podfile_helper.rb"
   ],
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org",
-    "access": "public"
-  },
   "keywords": [
     "react-native",
     "native-module",
@@ -62,7 +58,7 @@
     "brick-codegen": "./bin/brick-codegen.js"
   },
   "dependencies": {
-    "brick-codegen": "0.1.26"
+    "brick-codegen": "0.4.0"
   },
   "peerDependencies": {
     "react": ">=18.2.0",

package/podfile_helper.rb

@@ -27,7 +27,14 @@ def use_brick_modules!(app_path: nil)
     else
       File.expand_path(File.join(brick_root, ios_brick_path))
     end
-    brick_codegen_podspec_path = File.join(brick_codegen_pod_path, 'BrickCodegen.podspec')
+    brick_codegen_podspec_path = File.join(
+      brick_codegen_pod_path,
+      'BrickCodegen.podspec'
+    )
+    brick_codegen_pod_relative_path = relative_pod_path(
+      brick_codegen_pod_path,
+      podfile_dir
+    )
 
     # Run brick-codegen with real-time output and colors (iOS only)
     exit_status = system("cd #{brick_root} && FORCE_COLOR=1 npx brick-codegen --platform ios --projectRoot \"#{brick_root}\"")
@@ -42,8 +49,8 @@ def use_brick_modules!(app_path: nil)
     end
 
     # Link generated BrickCodegen pod
-    pod 'BrickCodegen', :path => brick_codegen_pod_path
-    Pod::UI.puts "[Brick] Linked BrickCodegen from #{brick_codegen_pod_path}"
+    pod 'BrickCodegen', :path => brick_codegen_pod_relative_path
+    Pod::UI.puts "[Brick] Linked BrickCodegen from #{brick_codegen_pod_relative_path}"
   rescue => e
     # Re-raise so CocoaPods fails the install
     raise e
@@ -74,3 +81,19 @@ def get_brick_ios_path(project_root)
   
   return File.expand_path(File.join(project_root, 'ios/.brick'))
 end
+
+def podfile_dir
+  podfile_path = Pod::Config.instance.podfile_path
+  return Pathname.new(Dir.pwd).expand_path if podfile_path.nil?
+
+  podfile_path.dirname.expand_path
+end
+
+def relative_pod_path(target_path, base_dir)
+  Pathname.new(target_path)
+    .expand_path
+    .relative_path_from(base_dir)
+    .to_s
+rescue ArgumentError
+  target_path
+end

package/src/BrickError.ts

@@ -0,0 +1,78 @@
+/**
+ * BrickError - Type-safe class for custom errors from native modules.
+ * Matches the structure of iOS/Android BrickError.
+ */
+export class BrickError extends Error {
+  /** Error code (same as error.name) */
+  readonly code: string;
+
+  /** Additional properties (e.g., amount, currency) */
+  readonly userInfo: Record<string, unknown>;
+
+  /** Name of the module where the error occurred */
+  readonly moduleName?: string;
+
+  constructor(
+    message: string,
+    code: string,
+    userInfo: Record<string, unknown> = {},
+    moduleName?: string
+  ) {
+    super(message);
+    this.name = code;
+    this.code = code;
+    this.userInfo = userInfo;
+    this.moduleName = moduleName;
+  }
+
+  /**
+   * Type guard to check if an error object is a BrickError.
+   * @param error - The error object to check
+   * @returns true if the error is a BrickError
+   */
+  static isBrickError(error: unknown): error is BrickError {
+    return (
+      error instanceof Error &&
+      typeof (error as any).code === "string" &&
+      typeof (error as any).userInfo === "object" &&
+      (error as any).userInfo !== null
+    );
+  }
+
+  /**
+   * Converts a general error object to a BrickError.
+   * @param error - The error object to convert
+   * @param moduleName - Name of the module where the error occurred
+   * @returns A BrickError instance
+   */
+  static from(error: unknown, moduleName?: string): BrickError {
+    if (error instanceof BrickError) {
+      // Update moduleName if provided
+      if (moduleName && !error.moduleName) {
+        return new BrickError(error.message, error.code, error.userInfo, moduleName);
+      }
+      return error;
+    }
+
+    if (BrickError.isBrickError(error)) {
+      return new BrickError(
+        error.message,
+        error.code,
+        error.userInfo,
+        moduleName || (error as any).moduleName
+      );
+    }
+
+    if (error instanceof Error) {
+      const anyError = error as any;
+      return new BrickError(
+        error.message,
+        anyError.code || anyError.name || "UNKNOWN_ERROR",
+        anyError.userInfo || {},
+        moduleName || anyError.moduleName
+      );
+    }
+
+    return new BrickError(String(error), "UNKNOWN_ERROR", {}, moduleName);
+  }
+}

package/src/BrickModule.ts

@@ -4,14 +4,14 @@
  */
 
 import type { TurboModule } from "react-native";
-import { TurboModuleRegistry, NativeEventEmitter } from "react-native";
+import { TurboModuleRegistry } from "react-native";
+import { BrickError } from "./BrickError";
 
 /**
  * Base interface that all Brick module specs must extend
  */
 export interface BrickModuleInterface extends TurboModule {
   readonly moduleName: string;
-  readonly supportedEvents?: readonly string[];
 }
 
 /**
@@ -29,7 +29,6 @@ export type BrickModuleSpec = BrickModuleInterface;
 // Module-level state (previously static class members)
 const moduleCache = new Map<string, any>();
 let nativeModule: any = null;
-let eventEmitter: NativeEventEmitter | null = null;
 
 /**
  * Gets the native TurboModule instance
@@ -42,30 +41,10 @@ function getNativeModule() {
   return nativeModule;
 }
 
-function getEventEmitter() {
-  if (!eventEmitter) {
-    const nativeModuleInstance = getNativeModule();
-    eventEmitter = new NativeEventEmitter(nativeModuleInstance);
-    console.log("eventEmitter", eventEmitter);
-  }
-  return eventEmitter;
-}
-
 /**
  * Enhanced typed module interface with event listeners
  */
-export type BrickModuleWithEvents<T extends BrickModuleInterface> = T & {
-  /**
-   * Adds a type-safe event listener for this module
-   * @param eventName - One of the supported events defined in the module spec
-   * @param listener - Callback function to handle the event
-   * @returns Unsubscription function to remove the listener
-   */
-  addEventListener<TEvent = unknown>(
-    eventName: T["supportedEvents"] extends readonly (infer U)[] ? U : never,
-    listener: (event: TEvent) => void
-  ): () => void;
-};
+export type BrickModuleWithEvents<T extends BrickModuleInterface> = T;
 
 /**
  * Gets a typed module instance by name with explicit type parameter
@@ -83,6 +62,9 @@ function get<T extends BrickModuleInterface>(
 
   const nativeModuleInstance = getNativeModule();
 
+  // Cache constants for this module (computed once, reused)
+  let constantsCache: Record<string, any> | null = null;
+
   // Create a proxy that intercepts method calls and forwards them to the native module
   const moduleProxy = new Proxy({} as BrickModuleWithEvents<T>, {
     get: (_target, property: string | symbol) => {
@@ -90,57 +72,95 @@ function get<T extends BrickModuleInterface>(
         return undefined;
       }
 
-      // Handle event listener methods
-      if (property === "addEventListener") {
-        return (eventName: string, listener: (event: unknown) => void) => {
-          const emitter = getEventEmitter();
-          // Inform native module about listener addition (module-specific)
-          try {
-            const native = getNativeModule();
-            const moduleAddName = `${moduleName}_onEventListenerAdded`;
-            if (typeof native[moduleAddName] === "function") {
-              native[moduleAddName](eventName);
-            }
-          } catch {
-            // ignore
+      // New-style event subscription: onXxx((event) => void) → EventSubscription
+      if (
+        property.startsWith("on") &&
+        property.length > 2 &&
+        property[2] === property[2].toUpperCase()
+      ) {
+        return (listener: (event: unknown) => void) => {
+          // Respect RN CodegenTypes.EventEmitter: call `${moduleName}_onXxx` and return as-is
+          const nativeEventMethod = `${moduleName}_${property}`;
+          const nativeFn = (nativeModuleInstance as any)[nativeEventMethod];
+          if (typeof nativeFn === "function") {
+            return nativeFn(listener);
           }
-
-          const subscription = emitter.addListener(
-            `${moduleName}_${eventName}`,
-            listener
+          throw new Error(
+            `${nativeEventMethod} is not available. Did you run RN codegen?`
           );
-
-          return () => {
-            const native = getNativeModule();
-            const moduleRemoveName = `${moduleName}_onEventListenerRemoved`;
-            try {
-              // Prefer module-specific native removal for precise cleanup
-              if (typeof native[moduleRemoveName] === "function") {
-                native[moduleRemoveName](eventName);
-              }
-            } catch {
-              // ignore
-            } finally {
-              subscription.remove();
-            }
-          };
         };
       }
 
-      // Handle individual constants - check if this property exists as a constant
-      const allConstants = nativeModuleInstance?.getConstants?.() ?? {};
-      const constantKey = `${moduleName}_${property}`;
-      if (constantKey in allConstants) {
-        return allConstants[constantKey];
+      // Special handling for getConstants method (with caching)
+      if (property === "getConstants") {
+        return () => {
+          if (constantsCache !== null) {
+            return constantsCache;
+          }
+
+          const allConstants = nativeModuleInstance?.getConstants?.() ?? {};
+          const moduleConstants: Record<string, any> = {};
+          const constantPrefix = `${moduleName}_`;
+
+          for (const key in allConstants) {
+            if (key.startsWith(constantPrefix)) {
+              const propName = key.substring(constantPrefix.length);
+              moduleConstants[propName] = allConstants[key];
+            }
+          }
+
+          constantsCache = moduleConstants;
+          return moduleConstants;
+        };
       }
 
       // Handle method calls
       return (...args: any[]) => {
         const methodKey = `${moduleName}_${property}`;
 
-        // Try direct method call first (generated by codegen)
+        // Try direct method call (generated by codegen)
         if (typeof nativeModuleInstance[methodKey] === "function") {
-          return nativeModuleInstance[methodKey](...args);
+          const result = nativeModuleInstance[methodKey](...args);
+
+          // Check if result is a wrapped sync method result
+          // Sync methods have explicit "~sync": true marker for reliable detection
+          // Format: { "~sync": true, success: true, value: T } | { "~sync": true, success: false, error: {...} }
+          if (
+            result &&
+            typeof result === "object" &&
+            result["~sync"] === true
+          ) {
+            if (result.success === true) {
+              // Success: return the unwrapped value
+              return result.value;
+            } else {
+              // Failure: throw a BrickError with all properties from error object
+              const errorInfo = result.error || {};
+              const message = errorInfo.message || errorInfo.errorMessage || "Unknown error";
+              const code = errorInfo.code || errorInfo.errorCode || "BRICK_ERROR";
+
+              // Build userInfo from additional properties
+              const userInfo: Record<string, unknown> = { code };
+              for (const key of Object.keys(errorInfo)) {
+                if (key !== "code" && key !== "message" && key !== "errorCode" && key !== "errorMessage") {
+                  userInfo[key] = errorInfo[key];
+                }
+              }
+
+              throw new BrickError(message, code, userInfo, moduleName);
+            }
+          }
+
+          // Async method: wrap Promise and convert to BrickError
+          if (result && typeof result.then === "function") {
+            return result.catch((error: unknown) => {
+              // Convert to BrickError with moduleName for type-safe error handling
+              throw BrickError.from(error, moduleName);
+            });
+          }
+
+          // Not wrapped: return as-is
+          return result;
         }
 
         throw new Error(`Method ${methodKey} not found`);

package/src/index.ts

@@ -4,20 +4,7 @@
 export type { BrickModuleInterface, BrickModuleSpec } from "./BrickModule";
 // Main API exports
 export { default as BrickModule } from "./BrickModule";
-/**
- * Error types for Brick modules
- */
-export class BrickModuleError extends Error {
-  constructor(
-    message: string,
-    public code: string = "BRICK_ERROR",
-    public moduleName?: string,
-    public methodName?: string
-  ) {
-    super(message);
-    this.name = "BrickModuleError";
-  }
-}
+export { BrickError } from "./BrickError";
 
 /**
  * Configuration interface for brick-codegen