@aguacerowx/react-native 0.0.36 → 0.0.38

package/ios/GridRenderLayer.swift

@@ -1,1004 +1,1107 @@
-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
-    }
-}
+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
+    }
+    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
+    }
+
+    // MARK: - Performance Helper
+    private func logPerf(_ msg: String) {
+        var taskInfo = mach_task_basic_info()
+        var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size)/4
+        let kerr: kern_return_t = withUnsafeMutablePointer(to: &taskInfo) {
+            $0.withMemoryRebound(to: integer_t.self, capacity: 1) {
+                task_info(mach_task_self_, task_flavor_t(MACH_TASK_BASIC_INFO), $0, &count)
+            }
+        }
+        let mem = (kerr == KERN_SUCCESS) ? Float(taskInfo.resident_size) / 1024.0 / 1024.0 : 0
+        print("⚡️ [PERF] [GridRenderLayer] \(msg) | RAM: \(String(format: "%.2f", mem)) MB")
+    }
+
+    @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: nil,
+            nx: inspectorCache.nx,
+            ny: inspectorCache.ny,
+            scale: scale.floatValue,
+            offset: offset.floatValue,
+            missing: missing.floatValue,
+            scaleType: scaleType.intValue
+        )
+    }
+
+    @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 reconstructAndTransformInPlace(data: inout Data) {
+        let count = data.count
+        if count == 0 { return }
+
+        // Get raw pointer to memory (Bypasses Swift Array bounds checking)
+        data.withUnsafeMutableBytes { rawBuffer in
+            guard let ptr = rawBuffer.baseAddress?.assumingMemoryBound(to: UInt8.self) else { return }
+            
+            // 1. Setup first byte
+            // Cast to Int8 to handle the delta logic, then back to UInt8 for storage
+            var runningValue: Int8 = Int8(bitPattern: ptr[0])
+            
+            // Transform first byte immediately: runningValue + 128
+            // We use &+ to allow overflow wrapping (which is exactly what we want for -128->0 mapping)
+            ptr[0] = UInt8(bitPattern: runningValue) &+ 128
+
+            // 2. Optimized Loop (One pass for everything)
+            for i in 1..<count {
+                let delta = Int8(bitPattern: ptr[i])
+                
+                // Reconstruction: Add delta to previous value
+                runningValue = runningValue &+ delta
+                
+                // Transformation: Add 128 to shift into UInt8 range for Texture
+                ptr[i] = UInt8(bitPattern: runningValue) &+ 128
+            }
+        }
+    }
+
+private func processRawData(fileData: Data) -> Data? {
+        let start = CFAbsoluteTimeGetCurrent()
+
+        // 1. Decompress
+        // This allocates the only buffer we will use.
+        let t1 = CFAbsoluteTimeGetCurrent()
+        guard var workingData = self.decompressZstd(data: fileData) else {
+            print("❌ [GridRenderLayer] Failed to decompress zstd data")
+            return nil
+        }
+        let t1_diff = (CFAbsoluteTimeGetCurrent() - t1) * 1000
+
+        // 2. Reconstruct AND Transform (In-Place)
+        // No new memory allocation here.
+        let t2 = CFAbsoluteTimeGetCurrent()
+        self.reconstructAndTransformInPlace(data: &workingData)
+        let t2_diff = (CFAbsoluteTimeGetCurrent() - t2) * 1000
+
+        // 3. (Legacy Timer Placeholder to match logs)
+        // Since we combined them, this is effectively instant now
+        let t3_diff = 0.0 
+        
+        let total = (CFAbsoluteTimeGetCurrent() - start) * 1000
+        
+        // Log CPU transformation metrics
+        // Expect Recon+Trans to drop from ~1000ms to ~10-20ms
+        logPerf("PROCESS RAW: Total \(String(format: "%.1f", total))ms (Zstd: \(String(format: "%.1f", t1_diff))ms, Recon+Trans: \(String(format: "%.1f", t2_diff))ms)")
+        
+        return workingData
+    }
+
+    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) {
+        self.inspectorCache.updateWithFilePath(
+            filePath: filePath,
+            nx: nx,
+            ny: ny,
+            scale: scale,
+            offset: offset,
+            missing: missing,
+            scaleType: scaleType
+        )
+    }
+
+    @objc(setActiveFrameWithCacheKey:)
+    public func setActiveFrame(cacheKey: String) {
+        logPerf("setActiveFrame requested: \(cacheKey)")
+        setActiveFrameInternal(cacheKey: cacheKey, isExternalRequest: true)
+    }
+
+     private func setActiveFrameInternal(cacheKey: String, isExternalRequest: Bool) {
+        if isExternalRequest {
+            lastRequestedCacheKey = cacheKey
+        } else {
+            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 }
+                if self.lastRequestedCacheKey != cacheKey { return }
+                
+                // ALWAYS load from disk. It is fast enough now (20ms).
+                // No caching needed.
+                let diskStart = CFAbsoluteTimeGetCurrent()
+                guard let fileData = try? Data(contentsOf: URL(fileURLWithPath: frame.filePath)) else {
+                    print("❌ [GridRenderLayer] Failed to load file: \(frame.filePath)")
+                    return
+                }
+                
+                // processRawData is now optimized (in-place) and takes ~20ms
+                guard let finalTextureBytes = self.processRawData(fileData: fileData) else {
+                    print("❌ [GridRenderLayer] Failed to process data for: \(cacheKey)")
+                    return
+                }
+                
+                // Final check before jumping to main thread
+                if self.lastRequestedCacheKey != cacheKey { return }
+                
+                DispatchQueue.main.async { [weak self] in
+                    // ... (Keep existing Main Thread texture upload logic) ...
+                    guard let self = self else { return }
+                    
+                    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)
+                    
+                    // Update inspector in background
+                     self.frameProcessingQueue.async { [weak self] in
+                        self?.updateInspectorCache(
+                            filePath: frame.filePath,
+                            reconstructedData: finalTextureBytes, // Pass the data we already processed!
+                            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]]) {
+        // logPerf("primeGpuCache called with \(frameInfo.count) items")
+        
+        // We do NOT need the frameProcessingQueue here anymore because we are just storing metadata.
+        // Doing this synchronously on the caller thread (which is a background thread from Manager) is fine and much faster.
+        
+        self.frameCacheQueue.async { [weak self] in
+            guard let self = self else { return }
+            
+            for (cacheKey, info) in frameInfo {
+                if self.frameCache[cacheKey] != nil { continue }
+                
+                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 { continue }
+                
+                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 <--- REMOVED
+                )
+                
+                self.frameCache[cacheKey] = metadata
+            }
+        }
+    }
+    
+    @objc public func updateDataTexture(data: String, nx: NSNumber, ny: NSNumber, scale: NSNumber, offset: NSNumber, missing: NSNumber, scaleType: String) {
+        let filePath = data
+        logPerf("updateDataTexture called for \(filePath)")
+        
+        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
+    }
+
+    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
+    }
+}