@aguacerowx/react-native 0.0.21 → 0.0.23

package/lib/module/ios/Shaders.metal

@@ -22,8 +22,9 @@ struct FragmentUniforms {
     float missingQuantized;
     float2 textureSize;
     int smoothing;
-    int scaleType; // 0 for linear, 1 for sqrt
-    int isPtype;   // ADD THIS
+    int scaleType;
+    int isPtype;
+    int isMRMS;
 };
 
 // --- Vertex Shader (Unchanged) ---
@@ -64,15 +65,26 @@ float get_value(texture2d<float, access::sample> dataTexture, sampler dataSample
 }
 
 // Maps a physical value to a precipitation type category
-float get_ptype_from_physical(float val) {
-    if (val < 0.0) return -1.0;   // Missing/Invalid
-    if (val < 100.0) return 0.0; // Rain
-    if (val < 200.0) return 1.0; // Mix
-    if (val < 300.0) return 2.0; // Snow
-    return 3.0;                  // Pellets
+// Maps a physical value to a precipitation type category
+float get_ptype_from_physical(float val, constant FragmentUniforms &uniforms) {  // ADD uniforms parameter
+    if (val < 0.0) return -1.0;
+    
+    if (uniforms.isMRMS == 1) {  // ADD THIS BRANCH
+        // MRMS: 0-100 rain, 100-200 snow, 200-300 freezing rain
+        if (val < 100.0) return 0.0;
+        if (val < 200.0) return 1.0;
+        if (val < 300.0) return 2.0;
+        return -1.0;
+    } else {
+        // Models: 0-100 rain, 100-200 snow, 200-300 freezing rain, 300-400 ice pellets
+        if (val < 100.0) return 0.0;
+        if (val < 200.0) return 1.0;
+        if (val < 300.0) return 2.0;
+        if (val < 400.0) return 3.0;
+        return -1.0;
+    }
 }
 
-
 // --- Main Fragment Shader ---
 fragment float4 fragment_main(RasterizerData in [[stage_in]],
                                 constant FragmentUniforms &uniforms [[buffer(0)]],
@@ -110,10 +122,10 @@ fragment float4 fragment_main(RasterizerData in [[stage_in]],
             float v01 = dequantize_val(get_value(dataTexture, dataSampler, v01_coord, uniforms), uniforms);
             float v11 = dequantize_val(get_value(dataTexture, dataSampler, v11_coord, uniforms), uniforms);
 
-            float p00 = get_ptype_from_physical(v00);
-            float p10 = get_ptype_from_physical(v10);
-            float p01 = get_ptype_from_physical(v01);
-            float p11 = get_ptype_from_physical(v11);
+            float p00 = get_ptype_from_physical(v00, uniforms);
+            float p10 = get_ptype_from_physical(v10, uniforms);
+            float p01 = get_ptype_from_physical(v01, uniforms);
+            float p11 = get_ptype_from_physical(v11, uniforms);
 
             // Determine the dominant precipitation type for this pixel
             float dominant_ptype = -1.0;

package/lib/module/lib/commonjs/aguacerowx-react-native.podspec

@@ -24,26 +24,11 @@ Pod::Spec.new do |s|
     'DEFINES_MODULE' => 'YES'
   }
   
-  s.resources = ['ios/compiled-shaders/*.metallib', 'ios/*.metal']
-  
-  s.script_phases = [
-    {
-      :name => 'Copy Metal Shaders',
-      :script => 'echo "🔨 Copying Metal shaders..."
-SHADER_DIR="${PODS_TARGET_SRCROOT}/ios/compiled-shaders"
-METAL_SOURCE="${PODS_TARGET_SRCROOT}/ios/Shaders.metal"
-
-if [ -f "$SHADER_DIR/Shaders.metallib" ]; then
-  cp -v "$SHADER_DIR/Shaders.metallib" "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/" || true
-  echo "✅ Pre-compiled Metal shader copied"
-elif [ -f "$METAL_SOURCE" ]; then
-  echo "⚠️ No pre-compiled shader found, will compile from source"
-  cp -v "$METAL_SOURCE" "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/" || true
-else
-  echo "❌ No Metal shaders found!"
-fi',
-      :execution_position => :before_compile
-    }
+  # Include both pre-compiled shaders AND source as fallback
+  s.resources = [
+    'ios/compiled-shaders/Shaders-simulator.metallib',
+    'ios/compiled-shaders/Shaders-device.metallib',
+    'ios/Shaders.metal'
   ]
   
   s.source_files = "ios/**/*.{h,m,mm,swift}", "ios/generated/**/*.{h,m,mm,cpp}"

package/lib/module/lib/commonjs/ios/FragmentUniforms.swift

@@ -12,4 +12,5 @@ struct FragmentUniforms {
     var smoothing: Int32
     var scaleType: Int32
     var isPtype: Int32
+    var isMRMS: Int32
 }

package/lib/module/lib/commonjs/ios/GridRenderLayer.swift

@@ -61,7 +61,8 @@ public class GridRenderLayer: NSObject {
         textureSize: SIMD2<Float>(0.0, 0.0),
         smoothing: 1,
         scaleType: 0,
-        isPtype: 0 // ADD THIS
+        isPtype: 0,
+        isMRMS: 0
     )
     private var isVisible = false
     private var pendingActiveFrameKey: String?
@@ -75,15 +76,13 @@ public class GridRenderLayer: NSObject {
         let nx: Float
         let ny: Float
         let filePath: String
-        let originalScale: Float  // ADD THIS
-        let originalOffset: Float  // ADD THIS
+        let originalScale: Float
+        let originalOffset: Float
     }
     private var frameCache: [String: FrameMetadata] = [:]
-    private let highPriorityTextureQueue = DispatchQueue(label: "com.aguacero.texture-processing-high-priority", qos: .userInitiated)
+    private let frameProcessingQueue = DispatchQueue(label: "com.aguacero.frame-processing", qos: .userInitiated, attributes: .concurrent)
+    private let semaphore = DispatchSemaphore(value: 8)  
 
-    // The concurrent queue for background preloading all other frames.
-    private let backgroundTextureQueue = DispatchQueue(label: "com.aguacero.texture-processing-background", qos: .utility, attributes: .concurrent)
-    // MARK: - Initializer
     private struct VertexInfo {
         var mercX: Float
         var mercY: Float
@@ -125,6 +124,13 @@ public class GridRenderLayer: NSObject {
         // ADD THIS: Force the map to repaint to show the smoothing change immediately.
         NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
     }
+
+    @objc(setIsMRMSWithIsMRMS:)
+    public func setIsMRMS(isMRMS: Bool) {
+        self.uniforms.isMRMS = isMRMS ? 1 : 0
+        print("🟢 [GridRenderLayer] Set isMRMS: \(isMRMS)")
+        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+    }
     
     // ADD THIS METHOD
     @objc(setVariableWithVariable:)
@@ -182,11 +188,10 @@ public class GridRenderLayer: NSObject {
         self.colormapTexture = texture
     }
 
-    @objc(clearGpuCache) // Explicitly name the Obj-C selector
+    @objc(clearGpuCache)
     public func clearGpuCache() {
-        backgroundTextureQueue.async {
-            self.frameCache.removeAll()
-            print("🟢 [GridRenderLayer] GPU frame cache cleared.")
+        frameProcessingQueue.async { [weak self] in
+            self?.frameCache.removeAll()
         }
     }
 
@@ -219,42 +224,39 @@ public class GridRenderLayer: NSObject {
     }
 
     private func updateInspectorCache(filePath: String, nx: Int, ny: Int, scale: Float, offset: Float, missing: Float, scaleType: Int) {
-        highPriorityTextureQueue.async {
-
-            guard let fileData = try? Data(contentsOf: URL(fileURLWithPath: filePath)) else {
-                print("❌ [Inspector] FATAL: Failed to read file data from path.")
-                self.inspectorCache.clear()
-                return
-            }
-            print("💡 [Inspector] 2. Successfully read \(fileData.count) bytes from file.")
-            
-            guard let decompressedDeltas = self.decompressZstd(data: fileData) else {
-                print("❌ [Inspector] FATAL: Failed to decompress Zstd data.")
-                self.inspectorCache.clear()
-                return
-            }
-            print("💡 [Inspector] 3. Successfully decompressed data.")
-
-            let reconstructedData = self.reconstructData(decompressedDeltas: decompressedDeltas)
-            print("💡 [Inspector] 4. Reconstructed data with \(reconstructedData.count) bytes.")
-            
-            self.inspectorCache.update(
-                data: reconstructedData,
-                nx: nx,
-                ny: ny,
-                scale: scale,
-                offset: offset,
-                missing: missing,
-                scaleType: scaleType
-            )
-            
-            print("💡 [Inspector] 5. ✅ Cache updated successfully with scaleType=\(scaleType)")
+        // This is now called from frameProcessingQueue, so we can do the work synchronously
+        guard let fileData = try? Data(contentsOf: URL(fileURLWithPath: filePath)) else {
+            print("❌ [Inspector] FATAL: Failed to read file data from path.")
+            self.inspectorCache.clear()
+            return
+        }
+        print("💡 [Inspector] 2. Successfully read \(fileData.count) bytes from file.")
+        
+        guard let decompressedDeltas = self.decompressZstd(data: fileData) else {
+            print("❌ [Inspector] FATAL: Failed to decompress Zstd data.")
+            self.inspectorCache.clear()
+            return
         }
+        print("💡 [Inspector] 3. Successfully decompressed data.")
+
+        let reconstructedData = self.reconstructData(decompressedDeltas: decompressedDeltas)
+        print("💡 [Inspector] 4. Reconstructed data with \(reconstructedData.count) bytes.")
+        
+        self.inspectorCache.update(
+            data: reconstructedData,
+            nx: nx,
+            ny: ny,
+            scale: scale,
+            offset: offset,
+            missing: missing,
+            scaleType: scaleType
+        )
+        
+        print("💡 [Inspector] 5. ✅ Cache updated successfully with scaleType=\(scaleType)")
     }
 
     @objc(setActiveFrameWithCacheKey:)
     public func setActiveFrame(cacheKey: String) {
-        // First, check if the frame is already in the cache.
         if let frame = frameCache[cacheKey] {
             print("⚡️ [GridRenderLayer] Cache HIT for key: \(cacheKey). Swapping texture.")
             
@@ -266,42 +268,51 @@ public class GridRenderLayer: NSObject {
             self.uniforms.scaleType = Int32(frame.scaleType)
             
             self.isVisible = true
-            self.pendingActiveFrameKey = nil // Clear any pending key
+            self.pendingActiveFrameKey = nil
             NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
             
-            // --- ADD THIS ---
-            // Now that the frame is active, update the inspector cache with its data.
-            self.updateInspectorCache(
-                filePath: frame.filePath,
-                nx: Int(frame.nx),
-                ny: Int(frame.ny),
-                scale: frame.scale,
-                offset: frame.offset,
-                missing: frame.missing,
-                scaleType: frame.scaleType
-            )
+            // Update inspector cache on background thread since we already have the frame data
+            frameProcessingQueue.async { [weak self] in
+                self?.updateInspectorCache(
+                    filePath: frame.filePath,
+                    nx: Int(frame.nx),
+                    ny: Int(frame.ny),
+                    scale: frame.scale,
+                    offset: frame.offset,
+                    missing: frame.missing,
+                    scaleType: frame.scaleType
+                )
+            }
 
         } else {
-            // --- FIX: If it's a miss, store the key and wait for it to be primed. ---
             print("⚠️ [GridRenderLayer] setActiveFrame cache MISS for key: \(cacheKey). Will apply when primed.")
             self.pendingActiveFrameKey = cacheKey
-            self.isVisible = false // Hide the layer until the frame is ready
+            self.isVisible = false
         }
     }
-
     @objc(primeGpuCacheWithFrameInfo:)
     public func primeGpuCache(frameInfo: [String: [String: Any]]) {
         let group = DispatchGroup()
         
         if (frameInfo.count > 1) {
-            print("🟡 [GridRenderLayer] Starting to prime \(frameInfo.count) textures concurrently...")
+            print("🟡 [GridRenderLayer] Starting to prime \(frameInfo.count) textures with concurrent processing...")
         }
 
         for (cacheKey, info) in frameInfo {
             group.enter()
             
-            backgroundTextureQueue.async {
-                defer { group.leave() }
+            frameProcessingQueue.async { [weak self] in
+                guard let self = self else {
+                    group.leave()
+                    return
+                }
+                
+                self.semaphore.wait()
+                defer {
+                    self.semaphore.signal()
+                    group.leave()
+                }
+
                 if self.frameCache[cacheKey] != nil { return }
                 
                 guard let filePath = info["filePath"] as? String,
@@ -311,16 +322,25 @@ public class GridRenderLayer: NSObject {
                     let offset = info["offset"] as? NSNumber,
                     let missing = info["missing"] as? NSNumber,
                     let scaleTypeStr = info["scaleType"] as? String,
-                    let originalScale = info["originalScale"] as? NSNumber,  // ADD THIS
-                    let originalOffset = info["originalOffset"] as? NSNumber,  // ADD THIS
-                    let fileData = try? Data(contentsOf: URL(fileURLWithPath: filePath)),
-                    let finalTextureBytes = self.processRawData(fileData: fileData)
+                    let originalScale = info["originalScale"] as? NSNumber,
+                    let originalOffset = info["originalOffset"] as? NSNumber
                 else {
                     print("❌ [GridRenderLayer] Skipping prime for \(cacheKey), missing data.")
                     return
                 }
                 
-                DispatchQueue.main.sync {
+                // Process data OFF the main thread
+                guard let fileData = try? Data(contentsOf: URL(fileURLWithPath: filePath)),
+                    let finalTextureBytes = self.processRawData(fileData: fileData)
+                else {
+                    print("❌ [GridRenderLayer] Failed to process data for \(cacheKey)")
+                    return
+                }
+                
+                // Create texture on main thread
+                DispatchQueue.main.async { [weak self] in
+                    guard let self = self else { return }
+                    
                     if let texture = self.createTextureFromBytes(bytes: finalTextureBytes, nx: nx.intValue, ny: ny.intValue) {
                         let metadata = FrameMetadata(
                             texture: texture,
@@ -331,11 +351,10 @@ public class GridRenderLayer: NSObject {
                             nx: nx.floatValue,
                             ny: ny.floatValue,
                             filePath: filePath,
-                            originalScale: originalScale.floatValue,  // ADD THIS
-                            originalOffset: originalOffset.floatValue  // ADD THIS
+                            originalScale: originalScale.floatValue,
+                            originalOffset: originalOffset.floatValue
                         )
                         self.frameCache[cacheKey] = metadata
-                        print("   ✅ [GridRenderLayer] Primed and cached frame for key: \(cacheKey)")
 
                         if let pendingKey = self.pendingActiveFrameKey, pendingKey == cacheKey {
                             print("👍 [GridRenderLayer] The pending frame is now ready. Activating it.")
@@ -348,7 +367,7 @@ public class GridRenderLayer: NSObject {
         
         group.notify(queue: .main) {
             if (frameInfo.count > 1) {
-                print("🎉 [GridRenderLayer] All \(frameInfo.count) frames have been processed and cached to the GPU.")
+                print("🎉 [GridRenderLayer] All \(frameInfo.count) frames have been processed and cached.")
             }
         }
     }
@@ -356,19 +375,20 @@ public class GridRenderLayer: NSObject {
     @objc public func updateDataTexture(data: String, nx: NSNumber, ny: NSNumber, scale: NSNumber, offset: NSNumber, missing: NSNumber, scaleType: String) {
         print("🚀 [GridRenderLayer] FAST LANE: updateDataTexture called for initial frame...")
         
-        let filePath = data // Assuming 'data' is always the file path for this method.
+        let filePath = data
         
-        // USE THE HIGH-PRIORITY QUEUE
-        highPriorityTextureQueue.async {
-            guard let fileData = try? Data(contentsOf: URL(fileURLWithPath: filePath)) else { return }
+        frameProcessingQueue.async { [weak self] in
+            guard let self = self else { return }
             
-            guard let finalTextureBytes = self.processRawData(fileData: fileData) else {
+            guard let fileData = try? Data(contentsOf: URL(fileURLWithPath: filePath)),
+                let finalTextureBytes = self.processRawData(fileData: fileData)
+            else {
                 print("❌ [GridRenderLayer] FAST LANE: Failed to process initial frame data.")
                 return
             }
             
-            DispatchQueue.main.async {
-                guard let texture = self.createTextureFromBytes(bytes: finalTextureBytes, nx: nx.intValue, ny: ny.intValue) else {
+            DispatchQueue.main.async { [weak self] in
+                guard let self = self, let texture = self.createTextureFromBytes(bytes: finalTextureBytes, nx: nx.intValue, ny: ny.intValue) else {
                     return
                 }
                 
@@ -383,8 +403,6 @@ public class GridRenderLayer: NSObject {
                 print("✅ [GridRenderLayer] FAST LANE: Initial frame processed and displayed.")
                 NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
                 
-                // --- ADD THIS ---
-                // Update the inspector cache for the initial frame.
                 self.updateInspectorCache(
                     filePath: filePath,
                     nx: nx.intValue,
@@ -399,9 +417,6 @@ public class GridRenderLayer: NSObject {
     }
 
     @objc public func updateGeometry(corners: [String: Any], gridDef: [String: Any]) {
-        print("🟢 [GridRenderLayer] updateGeometry called")
-        print("   device: \(self.device != nil)")
-        
         guard self.device != nil else {
             print("⚠️ [GridRenderLayer] Device not ready yet, storing geometry for later")
             pendingGeometryUpdate = (corners: corners, gridDef: gridDef)
@@ -423,8 +438,6 @@ public class GridRenderLayer: NSObject {
                 return
             }
             
-            print("   ✅ Generated \(vertices.count/4) vertices, \(indices.count/3) triangles")
-            
             self.indexCount = indices.count
             
             DispatchQueue.main.async {
@@ -438,7 +451,6 @@ public class GridRenderLayer: NSObject {
                 print("   indexBuffer: \(self.indexBuffer != nil)")
                 print("   indexCount: \(self.indexCount)")
 
-                // TRIGGER A REPAINT - ADD THIS:
                 NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
             }
         }
@@ -610,11 +622,11 @@ public class GridRenderLayer: NSObject {
 
     private func lccToLonLat(i: Double, j: Double, gridDef: [String: Any]) -> (lon: Double, lat: Double)? {
         guard let projParams = gridDef["proj_params"] as? [String: Any],
-            let lat_0 = projParams["lat_0"] as? Double,  // latitude of origin
-            let lon_0 = projParams["lon_0"] as? Double,  // longitude of origin
-            let lat_1 = projParams["lat_1"] as? Double,  // first standard parallel
-            let lat_2 = projParams["lat_2"] as? Double,  // second standard parallel (HRRR uses two!)
-            let r_earth = projParams["R"] as? Double else {
+              let lat_0 = (projParams["lat_0"] as? NSNumber)?.doubleValue,
+              let lon_0 = (projParams["lon_0"] as? NSNumber)?.doubleValue,
+              let lat_1 = (projParams["lat_1"] as? NSNumber)?.doubleValue,
+              let lat_2 = (projParams["lat_2"] as? NSNumber)?.doubleValue,
+              let r_earth = (projParams["R"] as? NSNumber)?.doubleValue else {
             print("❌ [LCC Geometry] Failed to extract LCC parameters.")
             return nil
         }
@@ -628,10 +640,9 @@ public class GridRenderLayer: NSObject {
         let lat0_rad = lat_0 * toRad
         let lon0_rad = lon_0 * toRad
         
-        // Calculate cone constant (n) using two standard parallels
         let n: Double
         if abs(lat_1 - lat_2) < 1e-10 {
-            n = sin(lat1_rad)  // Single parallel case
+            n = sin(lat1_rad)
         } else {
             n = log(cos(lat1_rad) / cos(lat2_rad)) / log(tan(π/4.0 + lat2_rad/2.0) / tan(π/4.0 + lat1_rad/2.0))
         }
@@ -639,7 +650,6 @@ public class GridRenderLayer: NSObject {
         let F = cos(lat1_rad) * pow(tan(π/4.0 + lat1_rad/2.0), n) / n
         let rho_0 = r_earth * F * pow(tan(π/4.0 + lat0_rad/2.0), -n)
         
-        // i, j are the x, y projection coordinates
         let x = i
         let y = j
         
@@ -665,11 +675,16 @@ public class GridRenderLayer: NSObject {
     
     private func generateGeometryData(gridDef: [String: Any], vertices: inout [Float], indices: inout [UInt16]) {
         guard let gridParams = gridDef["grid_params"] as? [String: Any] else {
+            print("❌ [generateGeometryData] No grid_params found")
             return
         }
 
-        // GFS Global Grid Path
-        if isGFSType(gridParams: gridParams) {
+        // Check grid type
+        let isGFS = isGFSType(gridParams: gridParams)
+        let isLCC = isLCCType(gridDef: gridDef)
+        
+        if isGFS {
+            // GFS path remains unchanged
             let subdivisions = 120
             let verticesPerRow = (subdivisions * 3) + 1
             let TILE_SIZE: Double = 512.0
@@ -701,12 +716,16 @@ public class GridRenderLayer: NSObject {
             }
             return
         }
-        if isLCCType(gridDef: gridDef) {
+        
+        if isLCC {
+            print("🗺️ [generateGeometryData] Using LCC projection path")
             generateLCCGeometry(gridDef: gridDef, vertices: &vertices, indices: &indices)
             return
         }
         
-        // Generic Grid Path (MRMS, etc.)
+        // Generic Grid Path (MRMS, regional models, etc.)
+        print("🗺️ [generateGeometryData] Using generic regional grid path")
+        
         let nx = gridParams["nx"] as? Int ?? 0
         let ny = gridParams["ny"] as? Int ?? 0
         let lon_first = gridParams["lon_first"] as? Double ?? 0.0
@@ -715,6 +734,7 @@ public class GridRenderLayer: NSObject {
         let dy = gridParams["dy_degrees"] as? Double ?? 0.0
         let lon_last = gridParams["lon_last"] as? Double ?? (lon_first + Double(nx - 1) * dx)
         let lat_last = gridParams["lat_last"] as? Double ?? (lat_first + Double(ny - 1) * dy)
+
         let lat_span = lat_last - lat_first
         let isSouthToNorth = lat_span > 0
 
@@ -727,14 +747,12 @@ public class GridRenderLayer: NSObject {
         let verticesPerRow = subdivisions_x + 1
         let TILE_SIZE: Double = 512.0
 
-        // 🔑 FIX: Only create ONE world copy for regional data, THREE for global data
-        let worldCopies = (data_lon_range > 300) ? [-1, 0, 1] : [0]  // Only wrap if nearly global
+        let worldCopies = (data_lon_range > 300) ? [-1, 0, 1] : [0]
         
         for world_copy in worldCopies {
             let vertexStartIndex = UInt16(vertices.count / 4)
             let lon_offset = Double(world_copy) * 360.0
 
-            // Generate vertices for this world copy
             for row in 0...subdivisions_y {
                 for col in 0...subdivisions_x {
                     let v_interp = Float(row) / Float(subdivisions_y)
@@ -759,7 +777,6 @@ public class GridRenderLayer: NSObject {
                 }
             }
 
-            // Generate indices (same as before)
             for row in 0..<UInt16(subdivisions_y) {
                 for col in 0..<UInt16(subdivisions_x) {
                     let tl = vertexStartIndex + row * UInt16(verticesPerRow) + col
@@ -925,9 +942,6 @@ internal func internalRenderingWillStart(_ metalDevice: MTLDevice, colorPixelFor
             return
         }
         
-        print("✅ [GridRenderLayer] Past guards, about to render!")
-        print("   🎨 About to draw \(indexCount) indices (\(indexCount/3) triangles)")
-        
         let needsLinear = (uniforms.smoothing != 0)
         if isDataSamplerLinear != needsLinear {
             let samplerDesc = MTLSamplerDescriptor()
@@ -956,9 +970,6 @@ internal func internalRenderingWillStart(_ metalDevice: MTLDevice, colorPixelFor
             SIMD4<Float>(floatArray[12], floatArray[13], floatArray[14], floatArray[15])
         )
         
-        print("   📐 MVP matrix after scaling: \(mvp)")
-        print("   📍 Zoom: \(zoom), Scale factor: \(scale)")
-        
         // Add depth state
         let depthStencilDescriptor = MTLDepthStencilDescriptor()
         depthStencilDescriptor.depthCompareFunction = .always
@@ -977,12 +988,9 @@ internal func internalRenderingWillStart(_ metalDevice: MTLDevice, colorPixelFor
         encoder.setFragmentSamplerState(dataSamplerState, index: 0)
         encoder.setFragmentSamplerState(colormapSamplerState, index: 1)
         
-        print("   🎨 Drawing indexed primitives now...")
         encoder.drawIndexedPrimitives(type: .triangle, indexCount: indexCount, indexType: .uint16, indexBuffer: indices, indexBufferOffset: 0)
-        print("   ✅ Draw call completed")
         
         encoder.endEncoding()
-        print("   ✅ Encoder ended")
     }
 
     internal func internalRenderingWillEnd() {

package/lib/module/lib/commonjs/ios/GridRenderLayerBridge.swift

@@ -10,8 +10,6 @@ import Foundation
         belowLayerId: String?
     ) -> Bool {
         let position: LayerPosition? = belowLayerId.map { .below($0) }
-        
-        // Create a CustomLayer object
         var customLayer = CustomLayer(id: layerId, renderer: layerHost)
         
         do {
@@ -23,8 +21,18 @@ import Foundation
             return false
         }
     }
-
+    
     @objc public static func triggerRepaint(on mapView: MapView) {
         mapView.mapboxMap.triggerRepaint()
     }
+    
+    // ADD THIS NEW METHOD
+    @objc public static func layerExists(in mapView: MapView, layerId: String) -> Bool {
+        do {
+            _ = try mapView.mapboxMap.layer(withId: layerId)
+            return true
+        } catch {
+            return false
+        }
+    }
 }

package/lib/module/lib/commonjs/ios/GridRenderLayerView.h

@@ -1,17 +1,31 @@
 #import <UIKit/UIKit.h>
+#import <React/RCTComponent.h>
+
 @class GridRenderLayer;
 @class MapView;
+
 NS_ASSUME_NONNULL_BEGIN
+
 @interface GridRenderLayerView : UIView
+
 @property (nonatomic, strong) GridRenderLayer *layerInstance;
 @property (nonatomic, weak) MapView *mapView;
 @property (nonatomic, strong) NSString *layerId;
 @property (nonatomic, strong, nullable) NSString *belowID;
+
 // Property setters for React Native
 - (void)setOpacity:(float)opacity;
 - (void)setDataRange:(NSArray *)dataRange;
 - (void)setSmoothing:(BOOL)smoothing;
 - (void)setBelowID:(NSString *)belowID;
-- (void)setVariable:(NSString *)variable; // ADD THIS LINE
+- (void)setVariable:(NSString *)variable;
+
+// ADD THESE METHOD DECLARATIONS
+- (void)waitForStyleLoadAndAddLayer;
+- (void)pollForLayerExistence;
+- (void)findMapViewAndAddLayerInView:(UIView *)view;
+- (void)addLayerToMap;
+
 @end
+
 NS_ASSUME_NONNULL_END