@aguacerowx/react-native 0.0.34 → 0.0.35

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

@@ -0,0 +1,1004 @@
+import Foundation
+import MapboxMaps
+import Metal
+import libzstd
+import simd
+
+// MARK: - Swift-only wrapper for CustomLayerHost conformance
+@objc internal final class GridRenderLayerHost: NSObject, CustomLayerHost {
+    weak var layer: GridRenderLayer?
+
+    init(layer: GridRenderLayer) {
+        self.layer = layer
+        super.init()
+    }
+    
+    func renderingWillStart(_ metalDevice: MTLDevice, colorPixelFormat: UInt, depthStencilPixelFormat: UInt) {
+        layer?.internalRenderingWillStart(metalDevice, colorPixelFormat: colorPixelFormat, depthStencilPixelFormat: depthStencilPixelFormat)
+    }
+    
+    func render(_ parameters: CustomLayerRenderParameters, mtlCommandBuffer: MTLCommandBuffer, mtlRenderPassDescriptor: MTLRenderPassDescriptor) {
+        layer?.internalRender(parameters, mtlCommandBuffer: mtlCommandBuffer, mtlRenderPassDescriptor: mtlRenderPassDescriptor)
+    }
+    
+    func renderingWillEnd() {
+        layer?.internalRenderingWillEnd()
+    }
+}
+
+@objc(GridRenderLayer)
+public class GridRenderLayer: NSObject {
+    
+    // MARK: - Properties
+    
+    public var id: String
+    @objc internal var hostWrapper: GridRenderLayerHost!
+    
+    // Metal objects
+    private var device: MTLDevice!
+    private var commandQueue: MTLCommandQueue!
+    private var pipelineState: MTLRenderPipelineState!
+    private var vertexBuffer: MTLBuffer?
+    private var indexBuffer: MTLBuffer?
+    private var dataTexture: MTLTexture?
+    private var colormapTexture: MTLTexture?
+    private var dataSamplerState: MTLSamplerState!
+    private var colormapSamplerState: MTLSamplerState!
+    private var isDataSamplerLinear: Bool = false
+
+    private var pendingColormapUpdate: String?
+    private var pendingDataUpdate: (data: String, nx: NSNumber, ny: NSNumber, scale: NSNumber, offset: NSNumber, missing: NSNumber, scaleType: String)?
+    private var pendingGeometryUpdate: (corners: [String: Any], gridDef: [String: Any])?
+    
+    // Layer state
+    private var indexCount: Int = 0
+    private var uniforms = FragmentUniforms(
+        opacity: 1.0,
+        dataRange: SIMD2<Float>(0.0, 1.0),
+        scale: 1.0,
+        offset: 0.0,
+        missingQuantized: 127.0,
+        textureSize: SIMD2<Float>(0.0, 0.0),
+        smoothing: 1,
+        scaleType: 0,
+        isPtype: 0,
+        isMRMS: 0
+    )
+    private var isVisible = false
+    private var pendingActiveFrameKey: String?
+    private let inspectorCache = InspectorDataCache.shared
+    private struct FrameMetadata {
+        let scale: Float
+        let offset: Float
+        let missing: Float
+        let scaleType: Int
+        let nx: Float
+        let ny: Float
+        let filePath: String
+        let originalScale: Float
+        let originalOffset: Float
+    }
+    private var frameCache: [String: FrameMetadata] = [:]
+    private let frameProcessingQueue = DispatchQueue(label: "com.aguacero.frame-processing", qos: .userInitiated, attributes: .concurrent)
+    private let semaphore = DispatchSemaphore(value: 8)  
+
+    private struct VertexInfo {
+        var mercX: Float
+        var mercY: Float
+        var texU: Float
+        var texV: Float
+        var index: UInt16
+    }
+    @objc
+    public init(id: String) {
+        self.id = id
+        super.init()
+        self.hostWrapper = GridRenderLayerHost(layer: self)
+    }
+
+    @objc public func getHostWrapper() -> Any {
+      return self.hostWrapper as Any
+    }
+    
+    // MARK: - Public Methods (called from Manager)
+    
+    @objc public func setOpacity(value: Float) {
+        self.uniforms.opacity = value
+        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+    }
+
+    @objc public func setDataRange(value: [NSNumber]) {
+        self.uniforms.dataRange = SIMD2<Float>(value[0].floatValue, value[1].floatValue)
+        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+    }
+
+    @objc public func setSmoothing(value: Bool) {
+        self.uniforms.smoothing = value ? 1 : 0
+        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+    }
+
+    @objc(setIsMRMSWithIsMRMS:)
+    public func setIsMRMS(isMRMS: Bool) {
+        self.uniforms.isMRMS = isMRMS ? 1 : 0
+        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+    }
+    
+    // ADD THIS METHOD
+    @objc(setVariableWithVariable:)
+    public func setVariable(variable: String) {
+        let isPtypeVar = (variable == "ptypeRefl" || variable == "ptypeRate")
+        self.uniforms.isPtype = isPtypeVar ? 1 : 0
+        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+    }
+
+    @objc public func clear() {
+        self.isVisible = false
+        self.inspectorCache.clear()
+    }
+    
+    @objc public func updateDataParameters(scale: NSNumber, offset: NSNumber, missing: NSNumber, scaleType: NSNumber) {  // ADD scaleType parameter
+        // Update both the inspector cache AND the rendering uniforms
+        self.uniforms.scale = scale.floatValue
+        self.uniforms.offset = offset.floatValue
+        self.uniforms.missingQuantized = missing.floatValue
+        self.uniforms.scaleType = Int32(scaleType.intValue)  // ADD THIS
+        
+        inspectorCache.update(
+            data: inspectorCache.lastDecompressedData,
+            nx: inspectorCache.nx,
+            ny: inspectorCache.ny,
+            scale: scale.floatValue,
+            offset: offset.floatValue,
+            missing: missing.floatValue,
+            scaleType: scaleType.intValue  // ADD THIS
+        )  
+    }
+
+    @objc public func updateColormapTexture(colormapAsBase64: String) {
+        guard let device = self.device else {
+            pendingColormapUpdate = colormapAsBase64
+            return
+        }
+        guard let data = Data(base64Encoded: colormapAsBase64) else { return }
+        let textureDescriptor = MTLTextureDescriptor()
+        textureDescriptor.pixelFormat = .rgba8Unorm
+        textureDescriptor.width = 256
+        textureDescriptor.height = 1
+        textureDescriptor.usage = .shaderRead
+        guard let texture = device.makeTexture(descriptor: textureDescriptor) else { return }
+        texture.replace(
+            region: MTLRegionMake2D(0, 0, 256, 1),
+            mipmapLevel: 0,
+            withBytes: (data as NSData).bytes,
+            bytesPerRow: 256 * 4
+        )
+        self.colormapTexture = texture
+    }
+
+    @objc(clearGpuCache)
+    public func clearGpuCache() {
+        frameProcessingQueue.async { [weak self] in
+            self?.frameCache.removeAll()
+        }
+    }
+
+    private func processRawData(fileData: Data) -> Data? {
+        guard let decompressedDeltas = self.decompressZstd(data: fileData) else {
+            print("❌ [GridRenderLayer] Failed to decompress zstd data")
+            return nil
+        }
+        let reconstructedData = self.reconstructData(decompressedDeltas: decompressedDeltas)
+        let finalTextureBytes = self.transformData(finalData: reconstructedData)
+        return finalTextureBytes
+    }
+
+    private func createTextureFromBytes(bytes: Data, nx: Int, ny: Int) -> MTLTexture? {
+        guard let device = self.device else { return nil }
+        let textureDescriptor = MTLTextureDescriptor()
+        textureDescriptor.pixelFormat = .r8Unorm
+        textureDescriptor.width = nx
+        textureDescriptor.height = ny
+        textureDescriptor.usage = .shaderRead
+
+        guard let texture = device.makeTexture(descriptor: textureDescriptor) else { return nil }
+        texture.replace(
+            region: MTLRegionMake2D(0, 0, nx, ny),
+            mipmapLevel: 0,
+            withBytes: (bytes as NSData).bytes,
+            bytesPerRow: nx
+        )
+        return texture
+    }
+
+    private func updateInspectorCache(filePath: String, nx: Int, ny: Int, scale: Float, offset: Float, missing: Float, scaleType: Int) {
+        // 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
+        }
+        
+        guard let decompressedDeltas = self.decompressZstd(data: fileData) else {
+            print("❌ [Inspector] FATAL: Failed to decompress Zstd data.")
+            self.inspectorCache.clear()
+            return
+        }
+
+        let reconstructedData = self.reconstructData(decompressedDeltas: decompressedDeltas)
+        
+        self.inspectorCache.update(
+            data: reconstructedData,
+            nx: nx,
+            ny: ny,
+            scale: scale,
+            offset: offset,
+            missing: missing,
+            scaleType: scaleType
+        )
+    }
+
+    @objc(setActiveFrameWithCacheKey:)
+    public func setActiveFrame(cacheKey: String) {
+        if let frame = frameCache[cacheKey] {
+            frameProcessingQueue.async { [weak self] in
+                guard let self = self else { return }
+                
+                guard let fileData = try? Data(contentsOf: URL(fileURLWithPath: frame.filePath)),
+                    let finalTextureBytes = self.processRawData(fileData: fileData)
+                else {
+                    print("❌ [GridRenderLayer] Failed to load texture data for active frame")
+                    return
+                }
+                
+                DispatchQueue.main.async { [weak self] in
+                    guard let self = self,
+                        let texture = self.createTextureFromBytes(bytes: finalTextureBytes, nx: Int(frame.nx), ny: Int(frame.ny))
+                    else { return }
+                    
+                    self.dataTexture = texture
+                    self.uniforms.scale = frame.scale
+                    self.uniforms.offset = frame.offset
+                    self.uniforms.missingQuantized = frame.missing
+                    self.uniforms.textureSize = SIMD2<Float>(frame.nx, frame.ny)
+                    self.uniforms.scaleType = Int32(frame.scaleType)
+                    
+                    self.isVisible = true
+                    self.pendingActiveFrameKey = nil
+                    NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+                    
+                    // Update inspector cache
+                    self.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 {
+            print("⚠️ [GridRenderLayer] setActiveFrame cache MISS for key: \(cacheKey). Will apply when primed.")
+            self.pendingActiveFrameKey = cacheKey
+            self.isVisible = false
+        }
+    }
+
+    @objc(primeGpuCacheWithFrameInfo:)
+    public func primeGpuCache(frameInfo: [String: [String: Any]]) {
+        let group = DispatchGroup()
+
+        for (cacheKey, info) in frameInfo {
+            group.enter()
+            
+            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,
+                    let nx = info["nx"] as? NSNumber,
+                    let ny = info["ny"] as? NSNumber,
+                    let scale = info["scale"] as? NSNumber,
+                    let offset = info["offset"] as? NSNumber,
+                    let missing = info["missing"] as? NSNumber,
+                    let scaleTypeStr = info["scaleType"] as? String,
+                    let originalScale = info["originalScale"] as? NSNumber,
+                    let originalOffset = info["originalOffset"] as? NSNumber
+                else {
+                    print("❌ [GridRenderLayer] Skipping prime for \(cacheKey), missing data.")
+                    return
+                }
+                
+                let metadata = FrameMetadata(
+                    scale: scale.floatValue,
+                    offset: offset.floatValue,
+                    missing: missing.floatValue,
+                    scaleType: (scaleTypeStr == "sqrt") ? 1 : 0,
+                    nx: nx.floatValue,
+                    ny: ny.floatValue,
+                    filePath: filePath,
+                    originalScale: originalScale.floatValue,
+                    originalOffset: originalOffset.floatValue
+                )
+                self.frameCache[cacheKey] = metadata
+
+                if let pendingKey = self.pendingActiveFrameKey, pendingKey == cacheKey {
+                    DispatchQueue.main.async {
+                        self.setActiveFrame(cacheKey: pendingKey)
+                    }
+                }
+            }
+        }
+    }
+    
+    @objc public func updateDataTexture(data: String, nx: NSNumber, ny: NSNumber, scale: NSNumber, offset: NSNumber, missing: NSNumber, scaleType: String) {
+        let filePath = data
+        
+        frameProcessingQueue.async { [weak self] in
+            guard let self = self else { return }
+            
+            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 { [weak self] in
+                guard let self = self, let texture = self.createTextureFromBytes(bytes: finalTextureBytes, nx: nx.intValue, ny: ny.intValue) else {
+                    print("❌ [GridRenderLayer] FAST LANE: Failed to create texture")
+                    return
+                }
+                
+                self.dataTexture = texture
+                self.uniforms.scale = scale.floatValue
+                self.uniforms.offset = offset.floatValue
+                self.uniforms.missingQuantized = missing.floatValue
+                self.uniforms.scaleType = Int32((scaleType == "sqrt") ? 1 : 0)
+                self.uniforms.textureSize = SIMD2<Float>(nx.floatValue, ny.floatValue)
+                
+                self.isVisible = true
+                NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+
+                self.updateInspectorCache(
+                    filePath: filePath,
+                    nx: nx.intValue,
+                    ny: ny.intValue,
+                    scale: scale.floatValue,
+                    offset: offset.floatValue,
+                    missing: missing.floatValue,
+                    scaleType: (scaleType == "sqrt") ? 1 : 0
+                )
+            }
+        }
+    }
+
+    @objc public func updateGeometry(corners: [String: Any], gridDef: [String: Any]) {
+        guard self.device != nil else {
+            print("⚠️ [GridRenderLayer] Device not ready yet, storing geometry for later")
+            pendingGeometryUpdate = (corners: corners, gridDef: gridDef)
+            return
+        }
+        
+        DispatchQueue.global(qos: .userInitiated).async {
+            
+            var vertices: [Float] = []
+            var indices: [UInt16] = []
+            
+            self.generateGeometryData(gridDef: gridDef, vertices: &vertices, indices: &indices)
+            
+            if vertices.isEmpty || indices.isEmpty {
+                print("❌ [GridRenderLayer] No geometry generated")
+                return
+            }
+            
+            self.indexCount = indices.count
+            
+            DispatchQueue.main.async {
+                self.vertexBuffer = self.device.makeBuffer(bytes: vertices, length: vertices.count * MemoryLayout<Float>.size, options: [])
+                self.indexBuffer = self.device.makeBuffer(bytes: indices, length: indices.count * MemoryLayout<UInt16>.size, options: [])
+
+                NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+            }
+        }
+    }
+
+    private func decompressZstd(data: Data) -> Data? {
+        let decompressedSize = data.withUnsafeBytes { ptr in
+            ZSTD_getFrameContentSize(ptr.baseAddress, data.count)
+        }
+        
+        guard Int64(bitPattern: decompressedSize) > 0 else {
+            print("❌ [GridRenderLayer] Could not determine decompressed size")
+            return nil
+        }
+        
+        var decompressedData = Data(count: Int(decompressedSize))
+        
+        let result = decompressedData.withUnsafeMutableBytes { decompressedPtr -> Int in
+            data.withUnsafeBytes { compressedPtr -> Int in
+                let returnValue = ZSTD_decompress(
+                    decompressedPtr.baseAddress,
+                    Int(decompressedSize),  
+                    compressedPtr.baseAddress,
+                    data.count
+                )
+                return Int(returnValue)
+            }
+        }
+
+        guard result > 0 && result == decompressedData.count else {
+            if result > 0 {
+                let size_t_result = size_t(result)
+                if let errorName = ZSTD_getErrorName(size_t_result) {
+                    let errorString = String(cString: errorName)
+                    print("❌ [GridRenderLayer] Zstd decompression failed: \(errorString)")
+                }
+            }
+            return nil
+        }
+        return decompressedData
+    }
+    
+    // MARK: - Private Helper Methods
+    
+    private func reconstructData(decompressedDeltas: Data) -> Data {
+        guard !decompressedDeltas.isEmpty else { return Data() }
+        var reconstructedData = Data(count: decompressedDeltas.count)
+        reconstructedData[0] = decompressedDeltas[0]
+        for i in 1..<decompressedDeltas.count {
+            reconstructedData[i] = UInt8(Int8(bitPattern: reconstructedData[i-1]) &+ Int8(bitPattern: decompressedDeltas[i]))
+        }
+        return reconstructedData
+    }
+    
+    private func transformData(finalData: Data) -> Data {
+        var transformedData = Data(count: finalData.count)
+        for i in 0..<finalData.count {
+            transformedData[i] = UInt8(Int16(Int8(bitPattern: finalData[i])) + 128)
+        }
+        return transformedData
+    }
+
+    private func isLCCType(gridDef: [String: Any]) -> Bool {
+        if let type = gridDef["type"] as? String {
+            return type == "lambert_conformal_conic"
+        }
+        return false
+    }
+
+    private func generateLCCGeometry(gridDef: [String: Any], vertices: inout [Float], indices: inout [UInt16]) {
+        guard let gridParams = gridDef["grid_params"] as? [String: Any],
+            let projParams = gridDef["proj_params"] as? [String: Any],
+            let nx = gridParams["nx"] as? Int,
+            let ny = gridParams["ny"] as? Int,
+            let dx = gridParams["dx"] as? Double,
+            let dy = gridParams["dy"] as? Double,
+            let x_origin = gridParams["x_origin"] as? Double,
+            let y_origin = gridParams["y_origin"] as? Double else {
+            return
+        }
+        
+        let subdivisions = 60
+        let TILE_SIZE: Double = 512.0
+        
+        let x_min = x_origin
+        let y_max = y_origin
+        let x_max = x_origin + Double(nx - 1) * dx
+        let y_min = y_origin + Double(ny - 1) * dy
+        
+        var vertexGrid: [[VertexInfo?]] = Array(repeating: Array(repeating: nil, count: subdivisions + 1), count: subdivisions + 1)
+        var validVertexCount: UInt16 = 0
+        
+        // Generate vertices
+        for row in 0...subdivisions {
+            for col in 0...subdivisions {
+                let t_x = Double(col) / Double(subdivisions)
+                let t_y = Double(row) / Double(subdivisions)
+                
+                let proj_x = x_min + t_x * (x_max - x_min)
+                let proj_y = y_max + t_y * (y_min - y_max)
+                
+                // Convert LCC projection coordinates to lat/lon
+                if let (lon, lat) = lccToLonLat(i: proj_x, j: proj_y, gridDef: gridDef) {
+                    // Convert lat/lon to Mercator
+                    let mercX_normalized = (lon + 180.0) / 360.0
+                    let clampedLat = max(-85.05112878, min(85.05112878, lat))
+                    let sinLatitude = sin(clampedLat * .pi / 180.0)
+                    let mercY_normalized = 0.5 - log((1 + sinLatitude) / (1 - sinLatitude)) / (4 * .pi)
+                    
+                    let mercX = mercX_normalized * TILE_SIZE
+                    let mercY = mercY_normalized * TILE_SIZE
+                    
+                    // Check for invalid values
+                    if !mercX.isFinite || !mercY.isFinite {
+                        vertexGrid[row][col] = nil
+                        continue
+                    }
+                    
+                    let tex_u = Float(t_x)
+                    let tex_v = Float(t_y)
+                    
+                    let vInfo = VertexInfo(
+                        mercX: Float(mercX),
+                        mercY: Float(mercY),
+                        texU: tex_u,
+                        texV: tex_v,
+                        index: validVertexCount
+                    )
+                    
+                    vertexGrid[row][col] = vInfo
+                    
+                    vertices.append(Float(mercX))
+                    vertices.append(Float(mercY))
+                    vertices.append(tex_u)
+                    vertices.append(tex_v)
+                    
+                    validVertexCount += 1
+                } else {
+                    vertexGrid[row][col] = nil
+                }
+            }
+        }
+        
+        if vertices.isEmpty {
+            print("❌ [LCC Geometry] No valid vertices generated")
+            return
+        }
+        
+        // Generate indices
+        for row in 0..<subdivisions {
+            for col in 0..<subdivisions {
+                guard let topLeft = vertexGrid[row][col],
+                    let topRight = vertexGrid[row][col + 1],
+                    let bottomLeft = vertexGrid[row + 1][col],
+                    let bottomRight = vertexGrid[row + 1][col + 1] else {
+                    continue
+                }
+                
+                indices.append(topLeft.index)
+                indices.append(bottomLeft.index)
+                indices.append(topRight.index)
+                
+                indices.append(topRight.index)
+                indices.append(bottomLeft.index)
+                indices.append(bottomRight.index)
+            }
+        }
+    }
+
+    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? 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
+        }
+
+        let π = Double.pi
+        let toRad = π / 180.0
+        let toDeg = 180.0 / π
+        
+        let lat1_rad = lat_1 * toRad
+        let lat2_rad = lat_2 * toRad
+        let lat0_rad = lat_0 * toRad
+        let lon0_rad = lon_0 * toRad
+        
+        let n: Double
+        if abs(lat_1 - lat_2) < 1e-10 {
+            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))
+        }
+        
+        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)
+        
+        let x = i
+        let y = j
+        
+        let rho = sqrt(x * x + (rho_0 - y) * (rho_0 - y))
+        if rho < 1e-10 {
+            return (lon: lon_0, lat: lat_0)
+        }
+        
+        let theta = atan2(x, rho_0 - y)
+        
+        let lon = lon0_rad + theta / n
+        let lat = 2.0 * atan(pow(r_earth * F / rho, 1.0 / n)) - π/2.0
+        
+        let lonDeg = lon * toDeg
+        let latDeg = lat * toDeg
+        
+        if !lonDeg.isFinite || !latDeg.isFinite {
+            return nil
+        }
+
+        return (lon: lonDeg, lat: latDeg)
+    }
+    
+    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
+        }
+
+        // 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
+            
+            for row in 0...subdivisions {
+                for col in 0...(subdivisions * 3) {
+                    let v_interp = Float(row) / Float(subdivisions)
+                    let u_interp = Float(col) / Float(subdivisions)
+                    let lon = -540.0 + Double(u_interp) * 1080.0
+                    let lat = -90.0 + Double(v_interp) * 180.0
+                    
+                    let merc = lonLatToMercator(lon: lon, lat: lat, tileSize: TILE_SIZE)
+                    vertices.append(contentsOf: [merc.x, merc.y])
+                    
+                    let tex_u = Float((lon + 180.0) / 360.0)
+                    let tex_v = 1.0 - v_interp
+                    vertices.append(contentsOf: [tex_u, tex_v])
+                }
+            }
+            
+            for row in 0..<subdivisions {
+                for col in 0..<(subdivisions * 3) {
+                    let tl = UInt16(row * verticesPerRow + col)
+                    let tr = tl + 1
+                    let bl = UInt16((row + 1) * verticesPerRow + col)
+                    let br = bl + 1
+                    indices.append(contentsOf: [tl, bl, tr, tr, bl, br])
+                }
+            }
+            return
+        }
+        
+        if isLCC {
+            generateLCCGeometry(gridDef: gridDef, vertices: &vertices, indices: &indices)
+            return
+        }
+        
+        let nx = gridParams["nx"] as? Int ?? 0
+        let ny = gridParams["ny"] as? Int ?? 0
+        let lon_first = gridParams["lon_first"] as? Double ?? 0.0
+        let lat_first = gridParams["lat_first"] as? Double ?? 90.0
+        let dx = gridParams["dx_degrees"] as? Double ?? 0.0
+        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
+
+        // Check if this is ECMWF and normalize longitudes
+        let isECMWF = isECMWFType(gridParams: gridParams)
+        var data_lon_first_180 = lon_first
+        var data_lon_last_180 = lon_last
+
+        if isECMWF {
+            // Convert ECMWF's 180 to -180 range to -180 to 180
+            data_lon_first_180 = lon_first >= 180 ? lon_first - 360 : lon_first
+            data_lon_last_180 = lon_last >= 180 ? lon_last - 360 : lon_last
+        } else {
+            // For GFS and other models
+            data_lon_first_180 = lon_first > 180 ? lon_first - 360 : lon_first
+            data_lon_last_180 = lon_last > 180 ? lon_last - 360 : lon_last
+        }
+
+        let data_lon_range = data_lon_last_180 - data_lon_first_180
+
+        let subdivisions_x = 120
+        let subdivisions_y = 60
+        let verticesPerRow = subdivisions_x + 1
+        let TILE_SIZE: Double = 512.0
+
+        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
+
+            for row in 0...subdivisions_y {
+                for col in 0...subdivisions_x {
+                    let v_interp = Float(row) / Float(subdivisions_y)
+                    let u_interp = Float(col) / Float(subdivisions_x)
+
+                    let vertex_lon = data_lon_first_180 + (Double(u_interp) * data_lon_range)
+                    let vertex_lat = lat_first + (Double(v_interp) * lat_span)
+
+                    let mercX_normalized = ((vertex_lon + lon_offset) + 180.0) / 360.0
+                    let clampedLat = max(-85.05112878, min(85.05112878, vertex_lat))
+                    let sinLatitude = sin(clampedLat * .pi / 180.0)
+                    let mercY_normalized = 0.5 - log((1 + sinLatitude) / (1 - sinLatitude)) / (4 * .pi)
+                    let mercX = mercX_normalized * TILE_SIZE
+                    let mercY = mercY_normalized * TILE_SIZE
+
+                    vertices.append(contentsOf: [Float(mercX), Float(mercY)])
+
+                    let tex_u = u_interp
+                    let tex_v = isSouthToNorth ? (1.0 - v_interp) : v_interp
+                    
+                    vertices.append(contentsOf: [tex_u, tex_v])
+                }
+            }
+
+            for row in 0..<UInt16(subdivisions_y) {
+                for col in 0..<UInt16(subdivisions_x) {
+                    let tl = vertexStartIndex + row * UInt16(verticesPerRow) + col
+                    let tr = tl + 1
+                    let bl = vertexStartIndex + (row + 1) * UInt16(verticesPerRow) + col
+                    let br = bl + 1
+
+                    if isSouthToNorth {
+                        indices.append(contentsOf: [tl, bl, tr, tr, bl, br])
+                    } else {
+                        indices.append(contentsOf: [tl, tr, bl, bl, tr, br])
+                    }
+                }
+            }
+        }
+    }
+    
+    private func isGFSType(gridParams: [String: Any]) -> Bool {
+        return (gridParams["lon_first"] as? Double) == 0.0 &&
+               abs((gridParams["lat_first"] as? Double) ?? -1) == 90.0
+    }
+
+    private func isECMWFType(gridParams: [String: Any]) -> Bool {
+        return (gridParams["lon_first"] as? Double) == 180.0 &&
+            (gridParams["lat_first"] as? Double) == 90.0
+    }
+    
+    private func lonLatToMercator(lon: Double, lat: Double, tileSize: Double) -> (x: Float, y: Float) {
+        let mercX_normalized = (lon + 180.0) / 360.0
+        let clampedLat = max(-85.05112878, min(85.05112878, lat))
+        let sinLatitude = sin(clampedLat * .pi / 180.0)
+        let mercY_normalized = 0.5 - log((1.0 + sinLatitude) / (1.0 - sinLatitude)) / (4.0 * .pi)
+        
+        return (x: Float(mercX_normalized * tileSize), y: Float(mercY_normalized * tileSize))
+    }
+    
+    // MARK: - Internal methods for CustomLayerHost (called by wrapper)
+    
+internal func internalRenderingWillStart(_ metalDevice: MTLDevice, colorPixelFormat: UInt, depthStencilPixelFormat: UInt) {
+    self.device = metalDevice
+    self.commandQueue = metalDevice.makeCommandQueue()
+    
+    let bundle = Bundle(for: GridRenderLayer.self)
+
+    // Determine if we're running on simulator or device
+    #if targetEnvironment(simulator)
+    let metallibName = "Shaders-simulator"
+    #else
+    let metallibName = "Shaders-device"
+    #endif
+
+    // Try to load pre-compiled metallib for the current platform
+    let defaultLibrary: MTLLibrary?
+    if let metallibUrl = bundle.url(forResource: metallibName, withExtension: "metallib"),
+    let library = try? metalDevice.makeLibrary(URL: metallibUrl) {
+        defaultLibrary = library
+    }
+    // Fall back to compiling from .metal source (for development with npm link)
+    else if let metalUrl = bundle.url(forResource: "Shaders", withExtension: "metal"),
+            let source = try? String(contentsOf: metalUrl),
+            let library = try? metalDevice.makeLibrary(source: source, options: nil) {
+        defaultLibrary = library
+    }
+    // Neither worked
+    else {
+        print("❌ [GridRenderLayer] Could not find or compile Metal shaders")
+        print("   Bundle path: \(bundle.bundlePath)")
+        return
+    }
+
+    guard let library = defaultLibrary else {
+        print("❌ [GridRenderLayer] Failed to create Metal library")
+        return
+    }
+    
+    let vertexFunction = library.makeFunction(name: "vertex_main")
+    let fragmentFunction = library.makeFunction(name: "fragment_main")
+
+    // Set up vertex descriptor
+    let vertexDescriptor = MTLVertexDescriptor()
+    vertexDescriptor.attributes[0].format = .float2  // position (x, y)
+    vertexDescriptor.attributes[0].offset = 0
+    vertexDescriptor.attributes[0].bufferIndex = 0
+
+    vertexDescriptor.attributes[1].format = .float2  // texCoord (u, v)
+    vertexDescriptor.attributes[1].offset = MemoryLayout<Float>.size * 2
+    vertexDescriptor.attributes[1].bufferIndex = 0
+
+    vertexDescriptor.layouts[0].stride = MemoryLayout<Float>.size * 4  // 2 floats for pos + 2 for texCoord
+    vertexDescriptor.layouts[0].stepFunction = .perVertex
+
+    let pipelineDescriptor = MTLRenderPipelineDescriptor()
+    pipelineDescriptor.vertexDescriptor = vertexDescriptor
+    pipelineDescriptor.vertexFunction = vertexFunction
+    pipelineDescriptor.fragmentFunction = fragmentFunction
+    
+    pipelineDescriptor.colorAttachments[0].pixelFormat = MTLPixelFormat(rawValue: colorPixelFormat) ?? .bgra8Unorm
+    pipelineDescriptor.depthAttachmentPixelFormat = MTLPixelFormat(rawValue: depthStencilPixelFormat) ?? .depth32Float_stencil8
+    pipelineDescriptor.stencilAttachmentPixelFormat = MTLPixelFormat(rawValue: depthStencilPixelFormat) ?? .depth32Float_stencil8
+
+    pipelineDescriptor.colorAttachments[0].isBlendingEnabled = true
+    pipelineDescriptor.colorAttachments[0].rgbBlendOperation = .add
+    pipelineDescriptor.colorAttachments[0].alphaBlendOperation = .add
+    pipelineDescriptor.colorAttachments[0].sourceRGBBlendFactor = .sourceAlpha
+    pipelineDescriptor.colorAttachments[0].sourceAlphaBlendFactor = .sourceAlpha
+    pipelineDescriptor.colorAttachments[0].destinationRGBBlendFactor = .oneMinusSourceAlpha
+    pipelineDescriptor.colorAttachments[0].destinationAlphaBlendFactor = .oneMinusSourceAlpha
+
+    do {
+        self.pipelineState = try metalDevice.makeRenderPipelineState(descriptor: pipelineDescriptor)
+    } catch {
+        print("❌ [GridRenderLayer] Failed to create pipeline state: \(error)")
+        return
+    }
+    
+    let dataSamplerDesc = MTLSamplerDescriptor()
+    dataSamplerDesc.minFilter = .nearest
+    dataSamplerDesc.magFilter = .nearest
+    self.dataSamplerState = metalDevice.makeSamplerState(descriptor: dataSamplerDesc)
+
+    let colormapSamplerDesc = MTLSamplerDescriptor()
+    colormapSamplerDesc.minFilter = .nearest
+    colormapSamplerDesc.magFilter = .nearest
+    colormapSamplerDesc.sAddressMode = .clampToEdge
+    self.colormapSamplerState = metalDevice.makeSamplerState(descriptor: colormapSamplerDesc)
+    
+    // Process any pending updates that came in before Metal was ready
+    if let pendingGeometry = pendingGeometryUpdate {
+        updateGeometry(corners: pendingGeometry.corners, gridDef: pendingGeometry.gridDef)
+        pendingGeometryUpdate = nil
+    }
+    
+    if let pendingColormap = pendingColormapUpdate {
+        updateColormapTexture(colormapAsBase64: pendingColormap)
+        pendingColormapUpdate = nil
+    }
+    
+    if let pendingData = pendingDataUpdate {
+        updateDataTexture(data: pendingData.data, nx: pendingData.nx, ny: pendingData.ny, 
+                        scale: pendingData.scale, offset: pendingData.offset, 
+                        missing: pendingData.missing, scaleType: pendingData.scaleType)
+        pendingDataUpdate = nil
+    }
+}
+    internal func internalRender(_ parameters: CustomLayerRenderParameters, mtlCommandBuffer: MTLCommandBuffer, mtlRenderPassDescriptor: MTLRenderPassDescriptor) {
+        guard isVisible,
+            let pipeline = pipelineState,
+            let vertices = vertexBuffer,
+            let indices = indexBuffer,
+            let dataTex = dataTexture,
+            let colormapTex = colormapTexture,
+            indexCount > 0,
+            let encoder = mtlCommandBuffer.makeRenderCommandEncoder(descriptor: mtlRenderPassDescriptor) else {
+
+            return
+        }
+        
+        let needsLinear = (uniforms.smoothing != 0)
+        if isDataSamplerLinear != needsLinear {
+            let samplerDesc = MTLSamplerDescriptor()
+            samplerDesc.minFilter = needsLinear ? .linear : .nearest
+            samplerDesc.magFilter = needsLinear ? .linear : .nearest
+            dataSamplerState = device.makeSamplerState(descriptor: samplerDesc)
+            isDataSamplerLinear = needsLinear
+        }
+        
+        // Apply zoom scale transformation
+        let zoom = parameters.zoom
+        let scale = Float(pow(2.0, zoom))
+
+        let matrixArray = parameters.projectionMatrix
+        var floatArray = matrixArray.map { $0.floatValue }
+
+        floatArray[0] *= scale   // X scale
+        floatArray[1] *= scale   // X rotation
+        floatArray[2] *= scale   // X Z-component
+        floatArray[3] *= scale   // X translation 
+        floatArray[4] *= scale   // Y rotation
+        floatArray[5] *= scale   // Y scale
+        floatArray[6] *= scale   // Y Z-component
+        floatArray[7] *= scale   // Y translation 
+        floatArray[8] *= scale   // Z X-component
+        floatArray[9] *= scale   // Z Y-component
+        floatArray[10] *= scale  // Z scale
+        floatArray[11] *= scale  // Z translation 
+
+        let mvp = matrix_float4x4(
+            SIMD4<Float>(floatArray[0], floatArray[1], floatArray[2], floatArray[3]),
+            SIMD4<Float>(floatArray[4], floatArray[5], floatArray[6], floatArray[7]),
+            SIMD4<Float>(floatArray[8], floatArray[9], floatArray[10], floatArray[11]),
+            SIMD4<Float>(floatArray[12], floatArray[13], floatArray[14], floatArray[15])
+        )
+        
+        // Add depth state
+        let depthStencilDescriptor = MTLDepthStencilDescriptor()
+        depthStencilDescriptor.depthCompareFunction = .always
+        depthStencilDescriptor.isDepthWriteEnabled = false
+        let depthStencilState = device.makeDepthStencilState(descriptor: depthStencilDescriptor)
+        
+        encoder.setRenderPipelineState(pipeline)
+        encoder.setDepthStencilState(depthStencilState!)
+        encoder.setVertexBuffer(vertices, offset: 0, index: 0)
+        encoder.setVertexBytes([mvp], length: MemoryLayout<matrix_float4x4>.size, index: 1)
+        
+        var mutableUniforms = uniforms
+        encoder.setFragmentBytes(&mutableUniforms, length: MemoryLayout<FragmentUniforms>.stride, index: 0)
+        encoder.setFragmentTexture(dataTex, index: 0)
+        encoder.setFragmentTexture(colormapTex, index: 1)
+        encoder.setFragmentSamplerState(dataSamplerState, index: 0)
+        encoder.setFragmentSamplerState(colormapSamplerState, index: 1)
+        
+        encoder.drawIndexedPrimitives(type: .triangle, indexCount: indexCount, indexType: .uint16, indexBuffer: indices, indexBufferOffset: 0)
+        
+        encoder.endEncoding()
+    }
+
+    deinit {
+        print("🔴 [GridRenderLayer] deinit called for layer: \(id)")
+        
+        // Clean up all resources
+        frameCache.removeAll()
+        vertexBuffer = nil
+        indexBuffer = nil
+        dataTexture = nil
+        colormapTexture = nil
+        device = nil
+        commandQueue = nil
+        pipelineState = nil
+        dataSamplerState = nil
+        colormapSamplerState = nil
+        
+        // Break the reference cycle
+        hostWrapper = nil
+    }
+
+    internal func internalRenderingWillEnd() {
+        vertexBuffer = nil
+        indexBuffer = nil
+        dataTexture = nil
+        colormapTexture = nil
+    }
+}
+
+extension GridRenderLayer {
+    // Override to prevent KVC crashes during cleanup
+    open override func value(forUndefinedKey key: String) -> Any? {
+        print("⚠️ [GridRenderLayer] Attempted to access undefined key: \(key)")
+        return nil
+    }
+    
+    open override func setValue(_ value: Any?, forUndefinedKey key: String) {
+        print("⚠️ [GridRenderLayer] Attempted to set undefined key: \(key)")
+        // Silently ignore instead of crashing
+    }
+}