feat: add explicit type field to ResolvedReferencedAsset for asset loading

Adds an optional `type` field ('image' | 'font' | 'audio') to
ResolvedReferencedAsset so callers can declare asset types explicitly,
avoiding the deprecated extension/magic-byte inference fallback.

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

Author: mfazekas

ios/new/ExperimentalAssetLoader.swift

@@ -6,6 +6,19 @@ enum AssetType {
   case font
   case audio
 
+  /// Initialise from an explicit caller-provided string ("image" | "font" | "audio").
+  /// This is the preferred path — always use this when the value is available.
+  init?(fromExplicit string: String) {
+    switch string.lowercased() {
+    case "image": self = .image
+    case "font":  self = .font
+    case "audio": self = .audio
+    default:      return nil
+    }
+  }
+
+  /// Initialise by guessing from a file-name suffix.
+  /// Deprecated: provide `type` explicitly instead.
   init?(fromName name: String) {
     let lowercased = name.lowercased()
     if lowercased.hasSuffix(".png") || lowercased.hasSuffix(".jpg") || lowercased.hasSuffix(".jpeg") || lowercased.hasSuffix(".webp") {
@@ -47,13 +60,23 @@ final class ExperimentalAssetLoader {
       let data = try await loadAssetData(asset)
       guard !data.isEmpty else { return }
 
-      let assetType = AssetType(fromName: name) ?? inferAssetType(from: asset, data: data)
-      guard let assetType = assetType else {
-        RCTLogWarn("Could not determine asset type for: \(name)")
+      // Prefer an explicit type provided by the caller.
+      let resolvedType: AssetType?
+      if let explicit = asset.type, let explicitType = AssetType(fromExplicit: explicit) {
+        resolvedType = explicitType
+      } else {
+        // No explicit type — fall back to extension / magic-byte inference.
+        // Deprecated: set type on the asset entry to silence this warning.
+        RCTLogWarn("[Rive] No type provided for '\(name)'. Falling back to extension/magic-byte inference — " +
+          "set type: 'image' | 'font' | 'audio' on the asset to silence this warning.")
+        resolvedType = AssetType(fromName: name) ?? inferAssetType(from: asset, data: data)
+      }
+      guard let resolvedType else {
+        RCTLogWarn("[Rive] Could not determine asset type for: \(name)")
         return
       }
 
-      try await registerAsset(data: data, name: name, type: assetType, worker: worker)
+      try await registerAsset(data: data, name: name, type: resolvedType, worker: worker)
     } catch {
       RCTLogError("Failed to load asset '\(name)': \(error)")
     }

nitrogen/generated/android/c++/JResolvedReferencedAsset.hpp

@@ -1,7 +1,16 @@
-import type { ResolvedReferencedAsset } from '../specs/RiveFile.nitro';
+import type { ResolvedReferencedAsset, RiveAssetType } from '../specs/RiveFile.nitro';
 import type { RiveImage } from '../specs/RiveImage.nitro';
 
-export type ReferencedAssetSource = { source: number | { uri: string } };
+export type ReferencedAssetSource = {
+  source: number | { uri: string };
+  /**
+   * Explicitly declares the type of this asset.
+   * **Recommended** — the new Rive runtime does not expose asset type at load
+   * time, so omitting this will trigger a deprecation warning and fall back to
+   * extension / magic-byte inference.
+   */
+  type?: RiveAssetType;
+};
 
 export type ReferencedAsset = ReferencedAssetSource | RiveImage;
 

nitrogen/generated/android/kotlin/com/margelo/nitro/rive/ResolvedReferencedAsset.kt

@@ -40,27 +40,27 @@ function parsePossibleSources(asset: ReferencedAsset): ResolvedReferencedAsset {
     return { image: asset };
   }
 
-  const source = asset.source;
+  const { source, type } = asset;
 
   if (typeof source === 'number') {
     const resolvedAsset = Image.resolveAssetSource(source);
     if (resolvedAsset && resolvedAsset.uri) {
-      return { sourceAssetId: resolvedAsset.uri };
+      return { sourceAssetId: resolvedAsset.uri, type };
     } else {
       throw new Error('Invalid asset source provided.');
     }
   }
 
   const uri = (source as any).uri;
   if (typeof source === 'object' && uri) {
-    return { sourceUrl: uri };
+    return { sourceUrl: uri, type };
   }
 
   const fileName = (source as any).fileName;
   const path = (source as any).path;
 
   if (typeof source === 'object' && fileName) {
-    const result: ResolvedReferencedAsset = { sourceAsset: fileName };
+    const result: ResolvedReferencedAsset = { sourceAsset: fileName, type };
 
     if (path) {
       result.path = path;

nitrogen/generated/ios/swift/ResolvedReferencedAsset.swift

@@ -15,13 +15,26 @@ export interface RiveEnumDefinition {
   readonly values: string[];
 }
 
+/**
+ * Explicitly declares the type of a referenced asset.
+ * Providing this is **recommended** — the new Rive runtime no longer exposes
+ * the asset type at load time, so falling back to extension/magic-byte
+ * inference is deprecated and may be removed in a future release.
+ */
+export type RiveAssetType = 'image' | 'font' | 'audio';
+
 export type ResolvedReferencedAsset = {
   sourceUrl?: string;
   sourceAsset?: string;
   /** URL on iOS, URL or resource name on Android (from Image.resolveAssetSource) */
   sourceAssetId?: string;
   path?: string;
   image?: RiveImage;
+  /**
+   * Explicitly declares the type of this asset.
+   * Recommended — provide this instead of relying on extension/magic-byte inference.
+   */
+  type?: RiveAssetType;
 };
 
 export type ReferencedAssetsType = {