@aguacerowx/react-native 0.0.37 → 0.0.39

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

@@ -1,1137 +0,0 @@
-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 var lastRequestedCacheKey: 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
-        var processedData: Data? // Cache the final transformed bytes
-    }
-    private var frameCache: [String: FrameMetadata] = [:]
-    private let frameCacheQueue = DispatchQueue(label: "com.aguacero.frame-cache-queue")
-    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() {
-        print("ℹ️ [GridRenderLayer] clearGpuCache called")
-        frameProcessingQueue.async { [weak self] in
-            guard let self = self else { return }
-            self.frameCacheQueue.async {
-                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, reconstructedData: Data?, 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
-        
-        let finalReconstructedData: Data
-        if let data = reconstructedData {
-            finalReconstructedData = data
-        } else {
-            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
-            }
-            finalReconstructedData = self.reconstructData(decompressedDeltas: decompressedDeltas)
-        }
-        
-        self.inspectorCache.update(
-            data: finalReconstructedData,
-            nx: nx,
-            ny: ny,
-            scale: scale,
-            offset: offset,
-            missing: missing,
-            scaleType: scaleType
-        )
-    }
-
-    @objc(setActiveFrameWithCacheKey:)
-    public func setActiveFrame(cacheKey: String) {
-        setActiveFrameInternal(cacheKey: cacheKey, isExternalRequest: true)
-    }
-
-    private func setActiveFrameInternal(cacheKey: String, isExternalRequest: Bool) {
-        if isExternalRequest {
-            lastRequestedCacheKey = cacheKey
-        } else {
-            // If it's an internal retry (from primeGpuCache), 
-            // only proceed if it's still the frame the user wants.
-            if lastRequestedCacheKey != cacheKey {
-                return
-            }
-        }
-        
-        var frameResult: FrameMetadata?
-        frameCacheQueue.sync {
-            frameResult = frameCache[cacheKey]
-        }
-
-        if let frame = frameResult {
-            frameProcessingQueue.async { [weak self] in
-                guard let self = self else { return }
-                
-                // Check if this frame is still the one we want
-                if self.lastRequestedCacheKey != cacheKey { return }
-                
-                let finalTextureBytes: Data
-                if let cachedData = frame.processedData {
-                    finalTextureBytes = cachedData
-                } else {
-                    guard let fileData = try? Data(contentsOf: URL(fileURLWithPath: frame.filePath)),
-                          let processed = self.processRawData(fileData: fileData)
-                    else {
-                        print("❌ [GridRenderLayer] Failed to load/process data for: \(cacheKey)")
-                        return
-                    }
-                    finalTextureBytes = processed
-                    self.frameCacheQueue.async {
-                        self.frameCache[cacheKey]?.processedData = finalTextureBytes
-                    }
-                }
-                
-                // Final check before jumping to main thread
-                if self.lastRequestedCacheKey != cacheKey { return }
-                
-                DispatchQueue.main.async { [weak self] in
-                    guard let self = self else { return }
-                    
-                    // Final check on main thread
-                    if self.lastRequestedCacheKey != cacheKey { 
-                        return 
-                    }
-                    
-                    let nx = Int(frame.nx)
-                    let ny = Int(frame.ny)
-                    
-                    if let existingTexture = self.dataTexture,
-                       existingTexture.width == nx,
-                       existingTexture.height == ny {
-                        existingTexture.replace(
-                            region: MTLRegionMake2D(0, 0, nx, ny),
-                            mipmapLevel: 0,
-                            withBytes: (finalTextureBytes as NSData).bytes,
-                            bytesPerRow: nx
-                        )
-                    } else {
-                        guard let texture = self.createTextureFromBytes(bytes: finalTextureBytes, nx: nx, ny: 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)
-                    
-                    self.frameProcessingQueue.async { [weak self] in
-                        self?.updateInspectorCache(
-                            filePath: frame.filePath,
-                            reconstructedData: nil,
-                            nx: nx,
-                            ny: ny,
-                            scale: frame.scale,
-                            offset: frame.offset,
-                            missing: frame.missing,
-                            scaleType: frame.scaleType
-                        )
-                    }
-                }
-            }
-        } else {
-            if isExternalRequest {
-                self.pendingActiveFrameKey = cacheKey
-            }
-        }
-    }
-
-    @objc(primeGpuCacheWithFrameInfo:)
-    public func primeGpuCache(frameInfo: [String: [String: Any]]) {
-        print("ℹ️ [GridRenderLayer] primeGpuCache called with \(frameInfo.count) items")
-        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()
-                }
-
-                let alreadyExists: Bool = self.frameCacheQueue.sync {
-                    return self.frameCache[cacheKey] != nil
-                }
-                if alreadyExists {
-                    print("ℹ️ [GridRenderLayer] Frame already cached: \(cacheKey)")
-                    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. Info keys: \(info.keys)")
-                    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,
-                    processedData: nil
-                )
-                
-                // Add to cache immediately so setActiveFrame can see it
-                self.frameCacheQueue.async {
-                    self.frameCache[cacheKey] = metadata
-                    print("ℹ️ [GridRenderLayer] Primed cache key: \(cacheKey)")
-                }
-                
-                // PERFORMANCE: Pre-process the data in the background
-                if let fileData = try? Data(contentsOf: URL(fileURLWithPath: filePath)) {
-                    if let processedData = self.processRawData(fileData: fileData) {
-                        self.frameCacheQueue.async {
-                            self.frameCache[cacheKey]?.processedData = processedData
-                        }
-                    }
-                }
-                
-                DispatchQueue.main.async {
-                    if let pendingKey = self.pendingActiveFrameKey, pendingKey == cacheKey {
-                        if self.lastRequestedCacheKey == cacheKey {
-                            print("ℹ️ [GridRenderLayer] Applying pending frame: \(cacheKey)")
-                            self.setActiveFrameInternal(cacheKey: pendingKey, isExternalRequest: false)
-                        }
-                        // Clear pending key if it matches what we just processed
-                        if self.pendingActiveFrameKey == cacheKey {
-                            self.pendingActiveFrameKey = nil
-                        }
-                    }
-                }
-            }
-        }
-    }
-    
-    @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 else { return }
-                
-                let nxInt = nx.intValue
-                let nyInt = ny.intValue
-
-                // REUSE TEXTURE if dimensions match
-                if let existingTexture = self.dataTexture,
-                   existingTexture.width == nxInt,
-                   existingTexture.height == nyInt {
-                    existingTexture.replace(
-                        region: MTLRegionMake2D(0, 0, nxInt, nyInt),
-                        mipmapLevel: 0,
-                        withBytes: (finalTextureBytes as NSData).bytes,
-                        bytesPerRow: nxInt
-                    )
-                } else {
-                    // Create new texture only if needed
-                    guard let texture = self.createTextureFromBytes(bytes: finalTextureBytes, nx: nxInt, ny: nyInt) 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,
-                    reconstructedData: nil,
-                    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
-    var defaultLibrary: MTLLibrary?
-    
-    // 1. Look in the main bundle level
-    if let metallibUrl = bundle.url(forResource: metallibName, withExtension: "metallib") {
-        print("ℹ️ [GridRenderLayer] Found pre-compiled shaders at: \(metallibUrl.lastPathComponent)")
-        defaultLibrary = try? metalDevice.makeLibrary(URL: metallibUrl)
-    }
-    
-    // 2. Fall back to compiled-shaders subdirectory
-    if defaultLibrary == nil {
-        if let metallibUrl = bundle.url(forResource: metallibName, withExtension: "metallib", subdirectory: "compiled-shaders") {
-            print("ℹ️ [GridRenderLayer] Found pre-compiled shaders in subdirectory: \(metallibUrl.lastPathComponent)")
-            defaultLibrary = try? metalDevice.makeLibrary(URL: metallibUrl)
-        }
-    }
-
-    // 3. Fall back to compiling from .metal source (for development with npm link)
-    if defaultLibrary == nil {
-        if let metalUrl = bundle.url(forResource: "Shaders", withExtension: "metal") {
-            print("⚠️ [GridRenderLayer] Pre-compiled shaders not found. Compiling from source: \(metalUrl.lastPathComponent)")
-            if let source = try? String(contentsOf: metalUrl),
-               let library = try? metalDevice.makeLibrary(source: source, options: nil) {
-                defaultLibrary = library
-            }
-        }
-    }
-
-    // Neither worked
-    if defaultLibrary == nil {
-        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
-        frameCacheQueue.sync {
-            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() {
-        // DO NOT clear these here, otherwise the layer disappears during map transitions/resizing
-        // 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
-    }
-}