fix: iOS production builds fail to load bundled .riv assets (#12)

* fix: iOS production asset loading

Fixes production build issue where iOS bundled assets fail to load.

**Problem:**
On iOS, `resolveAssetSource()` returns file:// URLs for bundled
assets: `file:///path/to/app/assets/rive/rewards_source.riv`

The previous implementation tried to extract the filename and load
it as a bundle resource, which only worked in debug builds. In
production, assets are packaged as actual files in the app bundle,
not as named resources accessible via `Bundle.main.path(forResource:)`.

**Previous approach (broken in production):**
```typescript
// Extract "rewards_source" from file URL
const match = assetURI.match(/file:\/\/(.*\/)+(.*)\.riv/);
return RiveFileFactory.fromResource(match[2], loadCdn);
// ❌ Failed: "Could not find Rive file: rewards_source.riv"
```

**New approach (works in debug and production):**
```typescript
// Load directly from file:// URL
return RiveFileFactory.fromFileURL(assetURI, loadCdn);
// ✅ Reads file directly from disk
```

**Implementation:**
- Added `fromFileURL` to `RiveFile.nitro.ts` spec
- Implemented `fromFileURL` in iOS (`HybridRiveFileFactory.swift`)
  - Validates file:// URL scheme
  - Loads data directly from file path using `Data(contentsOf:)`
  - Runs on background thread
- Implemented `fromFileURL` in Android (`HybridRiveFileFactory.kt`)
  - Matches iOS validation behavior
  - Converts URI to path using `java.net.URI`
  - Loads on `Dispatchers.IO` background thread
- Updated `fromSource()` to use `fromFileURL()` for file:// URLs
- Regenerated Nitrogen boilerplate

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Update src/core/RiveFile.ts

Co-authored-by: Gordon <pggordonhayes@gmail.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Gordon <pggordonhayes@gmail.com>

Author: 3 people

android/src/main/java/com/margelo/nitro/rive/HybridRiveFileFactory.kt

@@ -9,6 +9,8 @@ import com.margelo.nitro.core.Promise
 import com.margelo.nitro.NitroModules
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
+import java.io.File as JavaFile
+import java.net.URI
 import java.net.URL
 
 @Keep
@@ -33,6 +35,31 @@ class HybridRiveFileFactory : HybridRiveFileFactorySpec() {
     }
   }
 
+  override fun fromFileURL(fileURL: String, loadCdn: Boolean): Promise<HybridRiveFileSpec> {
+    if (!fileURL.startsWith("file://")) {
+      throw Error("fromFileURL: URL must be a file URL: $fileURL")
+    }
+
+    return Promise.async {
+      try {
+        val uri = URI(fileURL)
+        val path = uri.path ?: throw Error("fromFileURL: Invalid URL: $fileURL")
+
+        val riveFile = withContext(Dispatchers.IO) {
+          val file = JavaFile(path)
+          val riveData = file.readBytes()
+          File(riveData)
+        }
+
+        val hybridRiveFile = HybridRiveFile()
+        hybridRiveFile.riveFile = riveFile
+        hybridRiveFile
+      } catch (e: Exception) {
+        throw Error("Failed to load Rive file: ${e.message}")
+      }
+    }
+  }
+
   @SuppressLint("DiscouragedApi")
   override fun fromResource(resource: String, loadCdn: Boolean): Promise<HybridRiveFileSpec> {
     return Promise.async {

ios/HybridRiveFileFactory.swift

@@ -38,6 +38,45 @@ class HybridRiveFileFactory: HybridRiveFileFactorySpec {
     }
   }
 
+  func fromFileURL(fileURL: String, loadCdn: Bool) throws -> Promise<(any HybridRiveFileSpec)> {
+    guard let url = URL(string:fileURL) else {
+      throw RuntimeError.error(withMessage: "fromFileURL: Invalid URL: \(fileURL)")
+    }
+    
+    guard url.isFileURL else {
+      throw RuntimeError.error(withMessage: "fromFileURL: URL must be a file URL: \(fileURL)")
+    }
+    
+    return Promise.async {
+      do {
+        let riveFile = try await withCheckedThrowingContinuation { continuation in
+          DispatchQueue.global(qos: .userInitiated).async {
+            do {
+              let data = try Data(contentsOf: url)
+              
+              let riveFile = try RiveFile(data: data, loadCdn: loadCdn)
+              DispatchQueue.main.async {
+                continuation.resume(returning: riveFile)
+              }
+            } catch {
+              DispatchQueue.main.async {
+                continuation.resume(throwing: error)
+              }
+            }
+          }
+        }
+        
+        let hybridRiveFile = HybridRiveFile()
+        hybridRiveFile.riveFile = riveFile
+        return hybridRiveFile
+      } catch let error as NSError {
+        throw RuntimeError.error(withMessage: "Failed to load Rive file: \(error.localizedDescription)")
+      } catch {
+        throw RuntimeError.error(withMessage: "Unknown error occurred while loading Rive file")
+      }
+    }
+  }
+  
   func fromResource(resource: String, loadCdn: Bool) throws -> Promise<(any HybridRiveFileSpec)> {
     guard let _ = Bundle.main.path(forResource: resource, ofType: "riv") else {
       throw RuntimeError.error(withMessage: "Could not find Rive file: \(resource).riv")