react-native-litert-lm 0.2.1 → 0.3.0

package/scripts/stubs/cxx_bridge_stubs.cc

@@ -0,0 +1,224 @@
+/**
+ * cxx_bridge_stubs.cc
+ *
+ * Provides stub implementations for the Rust CXX bridge runtime.
+ *
+ * ARCHITECTURE NOTES:
+ * The CXX bridge generates two halves:
+ *   1. Rust .o files define C++ mangled wrappers (e.g., litert::lm::new_minijinja_template)
+ *      that call extern "C" shims (e.g., _litert$lm$cxxbridge1$new_minijinja_template)
+ *   2. Generated C++ code defines those extern "C" shims, which call the actual Rust FFI entry points
+ *
+ * Since we only have half #1 (the Rust .o), we provide stub extern "C" shims.
+ *
+ * CRITICAL: These stubs must NOT forward (via __asm__) to the C++ mangled functions
+ * in the Rust .o files. Those functions call RIGHT BACK to these extern "C" stubs,
+ * creating infinite recursion → stack overflow → SIGBUS.
+ *
+ * ALLOCATOR CONSISTENCY: All stubs use calloc/free. Since our stub creates the objects
+ * (not real Rust code), our drop/dealloc stubs using free() are perfectly consistent.
+ * If the real Rust code created the objects, there would be a mismatch, but it doesn't
+ * because these stubs intercept the calls before Rust can run.
+ */
+
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+
+// ============================================================================
+// Part 1: CXX Runtime Types
+// ============================================================================
+
+namespace rust {
+namespace cxxbridge1 {
+
+class String;
+
+class Str {
+public:
+  const char* ptr;
+  size_t len;
+  Str(const char* s);
+  Str(const String& s);
+  const char* data() const;
+  size_t size() const;
+  operator std::string() const;
+};
+
+class String {
+public:
+  struct Repr { char* ptr; size_t len; size_t cap; };
+  Repr repr_;
+  String(String&& o) noexcept;
+  String(const std::string& s);
+  ~String();
+  const char* data() const;
+  size_t size() const;
+  operator std::string() const;
+};
+
+Str::Str(const char* s) : ptr(s), len(s ? strlen(s) : 0) {}
+Str::Str(const String& s) : ptr(s.data()), len(s.size()) {}
+const char* Str::data() const { return ptr; }
+size_t Str::size() const { return len; }
+Str::operator std::string() const { return std::string(ptr, len); }
+
+String::String(String&& o) noexcept : repr_(o.repr_) { o.repr_ = {nullptr,0,0}; }
+String::String(const std::string& s) {
+  repr_.len = s.size();
+  repr_.cap = s.size() + 1;
+  repr_.ptr = static_cast<char*>(malloc(repr_.cap));
+  if (repr_.ptr) memcpy(repr_.ptr, s.c_str(), repr_.cap);
+}
+String::~String() { if (repr_.ptr) free(repr_.ptr); }
+const char* String::data() const { return repr_.ptr ? repr_.ptr : ""; }
+size_t String::size() const { return repr_.len; }
+String::operator std::string() const { return std::string(data(), size()); }
+
+template<typename T> class Vec {
+public:
+  T* data_; size_t len_; size_t cap_;
+  Vec();
+  const T* data() const;
+  size_t size() const;
+  void drop();
+};
+
+template<typename T> Vec<T>::Vec() : data_(nullptr), len_(0), cap_(0) {}
+template<typename T> const T* Vec<T>::data() const { return data_; }
+template<typename T> size_t Vec<T>::size() const { return len_; }
+template<typename T> void Vec<T>::drop() { if (data_) { free(data_); data_ = nullptr; } len_ = cap_ = 0; }
+
+template class Vec<String>;
+
+void sliceInit(void* s, const void* p, size_t l) {
+  auto* a = static_cast<const void**>(s);
+  a[0] = p; *reinterpret_cast<size_t*>(&a[1]) = l;
+}
+size_t sliceLen(const void* s) {
+  return *reinterpret_cast<const size_t*>(static_cast<const void* const*>(s)+1);
+}
+const void* slicePtr(const void* s) {
+  return static_cast<const void* const*>(s)[0];
+}
+
+}  // namespace cxxbridge1
+}  // namespace rust
+
+
+// ============================================================================
+// Part 2: extern "C" stubs
+//
+// All stubs use calloc/free for allocation. NO __asm__ forwarding to the C++
+// mangled Rust functions, which would create mutual recursion.
+// ============================================================================
+extern "C" {
+
+// --- rust_vec for JsonValue ---
+void* cxxbridge1$rust_vec$litert$lm$JsonValue$new() { return nullptr; }
+const void* cxxbridge1$rust_vec$litert$lm$JsonValue$data(const void*) { return nullptr; }
+size_t cxxbridge1$rust_vec$litert$lm$JsonValue$len(const void*) { return 0; }
+size_t cxxbridge1$rust_vec$litert$lm$JsonValue$capacity(const void*) { return 0; }
+void cxxbridge1$rust_vec$litert$lm$JsonValue$set_len(void*, size_t) {}
+void cxxbridge1$rust_vec$litert$lm$JsonValue$truncate(void*, size_t) {}
+void cxxbridge1$rust_vec$litert$lm$JsonValue$reserve_total(void*, size_t) {}
+void cxxbridge1$rust_vec$litert$lm$JsonValue$drop(void*) {}
+
+// --- Box<MinijinjaTemplate> ---
+// Allocate zeroed memory; consistent with free() in drop/dealloc.
+void* cxxbridge1$box$litert$lm$MinijinjaTemplate$alloc() {
+  return calloc(1, 64);
+}
+void cxxbridge1$box$litert$lm$MinijinjaTemplate$dealloc(void* p) {
+  if (p) free(p);
+}
+void cxxbridge1$box$litert$lm$MinijinjaTemplate$drop(void* p) {
+  if (p) free(p);
+}
+
+// --- Box<JsonValue> ---
+void* cxxbridge1$box$litert$lm$JsonValue$alloc() {
+  return calloc(1, 64);
+}
+void cxxbridge1$box$litert$lm$JsonValue$dealloc(void* p) {
+  if (p) free(p);
+}
+void cxxbridge1$box$litert$lm$JsonValue$drop(void* p) {
+  if (p) free(p);
+}
+
+// --- MinijinjaTemplate FFI shims ---
+// These are the Rust-side FFI entry points. The C++ mangled wrappers in the
+// Rust .o call INTO these. We must NOT forward back to those wrappers.
+size_t litert$lm$cxxbridge1$MinijinjaTemplate$operator$sizeof() { return 64; }
+size_t litert$lm$cxxbridge1$MinijinjaTemplate$operator$alignof() { return 8; }
+void litert$lm$cxxbridge1$MinijinjaTemplate$source(const void*, void* out) {
+  // Write an empty rust::cxxbridge1::String to out
+  if (out) memset(out, 0, 24);
+}
+void litert$lm$cxxbridge1$MinijinjaTemplate$apply(const void*, void* input, void* out) {
+  // Return an empty string result
+  if (out) memset(out, 0, 24);
+}
+void litert$lm$cxxbridge1$MinijinjaTemplate$clone_template(const void*, void* out) {
+  // Write a valid calloc'd pointer so drop() can safely free() it
+  if (out) {
+    void* cloned = calloc(1, 64);
+    memcpy(out, &cloned, sizeof(void*));
+  }
+}
+void litert$lm$cxxbridge1$MinijinjaTemplate$get_capabilities(const void*, void* out) {
+  if (out) memset(out, 0, 24);
+}
+void litert$lm$cxxbridge1$MinijinjaTemplate$get_error(const void*, void* out) {
+  if (out) memset(out, 0, 24);
+}
+
+// --- new_minijinja_template ---
+// Creates a Box<MinijinjaTemplate>. Writes a valid calloc'd pointer to `out`
+// so that later Box::drop() can free() it without issues.
+void litert$lm$cxxbridge1$new_minijinja_template(void* input, void* out) {
+  if (out) {
+    void* tmpl = calloc(1, 64);
+    memcpy(out, &tmpl, sizeof(void*));
+  }
+}
+
+// --- JsonValue FFI shims ---
+size_t litert$lm$cxxbridge1$JsonValue$operator$sizeof() { return 64; }
+size_t litert$lm$cxxbridge1$JsonValue$operator$alignof() { return 8; }
+void litert$lm$cxxbridge1$JsonValue$object_get(const void*, void*, void*) {}
+int litert$lm$cxxbridge1$JsonValue$is_null(const void*) { return 1; }
+int litert$lm$cxxbridge1$JsonValue$is_bool(const void*) { return 0; }
+int litert$lm$cxxbridge1$JsonValue$is_number(const void*) { return 0; }
+int litert$lm$cxxbridge1$JsonValue$is_string(const void*) { return 0; }
+int litert$lm$cxxbridge1$JsonValue$is_array(const void*) { return 0; }
+int litert$lm$cxxbridge1$JsonValue$is_object(const void*) { return 0; }
+int litert$lm$cxxbridge1$JsonValue$get_bool(const void*) { return 0; }
+double litert$lm$cxxbridge1$JsonValue$get_number(const void*) { return 0.0; }
+void litert$lm$cxxbridge1$JsonValue$get_string(const void*, void*) {}
+size_t litert$lm$cxxbridge1$JsonValue$array_len(const void*) { return 0; }
+void litert$lm$cxxbridge1$JsonValue$array_get(const void*, size_t, void*) {}
+int litert$lm$cxxbridge1$JsonValue$object_has_key(const void*, void*) { return 0; }
+void litert$lm$cxxbridge1$JsonValue$object_keys(const void*, void*) {}
+
+// --- Parser/template FFI shims ---
+void litert$lm$cxxbridge1$parse_fc_expression(void*, void*) {}
+void litert$lm$cxxbridge1$parse_json_expression(void*, void*) {}
+void litert$lm$cxxbridge1$parse_python_expression(void*, void*) {}
+
+// --- Tokenizers FFI stubs ---
+void* byte_level_bpe_tokenizers_new_from_str(void*, void*, void*) { return nullptr; }
+void* tokenizers_decode(void*, void*, size_t, int) { return nullptr; }
+void* tokenizers_encode(void*, void*, size_t) { return nullptr; }
+void* tokenizers_encode_batch(void*, void**, size_t, size_t) { return nullptr; }
+void tokenizers_free(void*) {}
+void tokenizers_free_encode_results(void*, size_t) {}
+void* tokenizers_get_decode_str(void*) { return nullptr; }
+int tokenizers_get_vocab_size(void*, int) { return 0; }
+void* tokenizers_id_to_token(void*, int) { return nullptr; }
+void* tokenizers_new_from_str(void*, size_t) { return nullptr; }
+int tokenizers_token_to_id(void*, void*, size_t) { return 0; }
+
+}  // extern "C"

package/scripts/stubs/gemma_model_constraint_provider.cc

@@ -0,0 +1,46 @@
+// Copyright 2026 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+#include <cstdio>
+
+struct LiteRtLmGemmaModelConstraintProvider {
+    int dummy;
+};
+
+extern "C" {
+
+void* LiteRtLmGemmaModelConstraintProvider_Create(
+    const char* serialized_sp_model_proto, size_t serialized_sp_model_proto_len,
+    const int** stop_token_ids, const size_t* stop_token_lengths,
+    size_t num_stop_lists) {
+    fprintf(stderr, "\n[LiteRT-LM WARN] Gemma Constraint Provider is"
+                    " STUBBED/DISABLED.\n");
+    fprintf(stderr, "[LiteRT-LM WARN] Any requests for grammar-constrained"
+                    " decoding will be ignored or fail.\n\n");
+    // Return a dummy pointer so that engine creation doesn't fail!
+    return new LiteRtLmGemmaModelConstraintProvider{0};
+}
+
+void LiteRtLmGemmaModelConstraintProvider_Destroy(void* provider) {
+    if (provider) {
+        delete static_cast<LiteRtLmGemmaModelConstraintProvider*>(provider);
+    }
+}
+
+void* LiteRtLmGemmaModelConstraintProvider_CreateConstraintFromTools(
+    void* provider, void* tools, void* options) {
+    return nullptr;
+}
+}  // extern "C"

package/scripts/stubs/llguidance_stubs.c

@@ -0,0 +1,101 @@
+/**
+ * llguidance_stubs.c
+ *
+ * Stub implementations for the llguidance C API used by LiteRT-LM's
+ * constrained decoding subsystem (llg_constraint, llg_constraint_provider).
+ * The real implementation is a Rust library (llguidance) which is not
+ * available in the iOS Bazel build.
+ *
+ * These stubs return error/null values so that constrained decoding
+ * gracefully fails at runtime. Basic LLM inference is unaffected.
+ */
+
+#include <stddef.h>
+#include <stdint.h>
+
+/* Opaque types */
+typedef struct LlgTokenizer LlgTokenizer;
+typedef struct LlgConstraint LlgConstraint;
+typedef struct LlgConstraintInit LlgConstraintInit;
+
+/* llg_new_tokenizer: create a tokenizer handle */
+int llg_new_tokenizer(void* init, void** out_tokenizer) {
+    if (out_tokenizer) *out_tokenizer = NULL;
+    return -1; /* error */
+}
+
+/* llg_free_tokenizer: release tokenizer */
+void llg_free_tokenizer(void* tokenizer) {
+    (void)tokenizer;
+}
+
+/* llg_constraint_init_set_defaults: initialize constraint config */
+void llg_constraint_init_set_defaults(void* init, void* tokenizer) {
+    (void)init;
+    (void)tokenizer;
+}
+
+/* llg_new_constraint: create grammar constraint */
+void* llg_new_constraint(void* init, void* grammar) {
+    (void)init;
+    (void)grammar;
+    return NULL;
+}
+
+/* llg_new_constraint_json: create JSON schema constraint */
+void* llg_new_constraint_json(void* init, const char* json_schema) {
+    (void)init;
+    (void)json_schema;
+    return NULL;
+}
+
+/* llg_new_constraint_regex: create regex constraint */
+void* llg_new_constraint_regex(void* init, const char* regex) {
+    (void)init;
+    (void)regex;
+    return NULL;
+}
+
+/* llg_new_constraint_lark: create Lark grammar constraint */
+void* llg_new_constraint_lark(void* init, const char* lark_grammar) {
+    (void)init;
+    (void)lark_grammar;
+    return NULL;
+}
+
+/* llg_clone_constraint: duplicate a constraint */
+void* llg_clone_constraint(void* constraint) {
+    (void)constraint;
+    return NULL;
+}
+
+/* llg_compute_mask: compute next token mask */
+int llg_compute_mask(void* constraint, void* result) {
+    (void)constraint;
+    (void)result;
+    return -1; /* error */
+}
+
+/* llg_commit_token: commit selected token */
+int llg_commit_token(void* constraint, int32_t token) {
+    (void)constraint;
+    (void)token;
+    return -1; /* error */
+}
+
+/* llg_is_stopped: check if constraint reached accepting state */
+int llg_is_stopped(void* constraint) {
+    (void)constraint;
+    return 1; /* stopped (nothing to do) */
+}
+
+/* llg_get_error: get last error message */
+const char* llg_get_error(void* constraint) {
+    (void)constraint;
+    return "llguidance not available on iOS";
+}
+
+/* llg_free_constraint: release constraint */
+void llg_free_constraint(void* constraint) {
+    (void)constraint;
+}

package/src/hooks.ts

@@ -1,51 +1,122 @@
-import { useState, useEffect, useRef, useCallback } from "react";
-import { LiteRTLM, LLMConfig } from "./index";
+import { useState, useEffect, useRef, useCallback, useMemo } from "react";
+import { LLMConfig } from "./index";
 import { createLLM } from "./modelFactory";
+import type { LiteRTLMInstance } from "./modelFactory";
+import type { MemoryTracker, MemoryTrackerSummary } from "./memoryTracker";
 
 export interface UseModelConfig extends LLMConfig {
   autoLoad?: boolean;
+  /**
+   * Enable memory tracking using native ArrayBuffers (v0.35+).
+   * When enabled, memory usage is tracked after each inference call
+   * using `NitroModules.createNativeArrayBuffer()` for zero-copy storage.
+   * @default false
+   */
+  enableMemoryTracking?: boolean;
+  /**
+   * Maximum number of memory snapshots to store.
+   * Each snapshot uses 32 bytes of native memory.
+   * @default 256
+   */
+  maxMemorySnapshots?: number;
 }
 
 export interface UseModelResult {
-  model: LiteRTLM | null;
+  model: LiteRTLMInstance | null;
   isReady: boolean;
   isGenerating: boolean;
   downloadProgress: number;
   error: string | null;
   generate: (prompt: string) => Promise<string>;
   reset: () => void;
-  deleteModel: (fileName: string) => Promise<void>;
+  /**
+   * Delete the model file. If no fileName is provided, derives it from
+   * the URL/path passed to useModel.
+   */
+  deleteModel: (fileName?: string) => Promise<void>;
   load: () => Promise<void>;
+  /**
+   * Memory tracker instance (available when enableMemoryTracking is true).
+   * Uses native ArrayBuffers allocated via `NitroModules.createNativeArrayBuffer()`
+   * for efficient, zero-copy memory usage tracking.
+   */
+  memoryTracker: MemoryTracker | null;
+  /**
+   * Current memory tracking summary (null if tracking is disabled).
+   * Updates automatically after each inference call.
+   */
+  memorySummary: MemoryTrackerSummary | null;
+}
+
+/**
+ * Extract a filename from a URL or file path.
+ */
+function extractFileName(pathOrUrl: string): string {
+  return pathOrUrl.split("/").pop() || "model.bin";
 }
 
 export function useModel(
   pathOrUrl: string,
   config?: UseModelConfig,
 ): UseModelResult {
-  const modelRef = useRef<LiteRTLM | null>(null);
+  const modelRef = useRef<LiteRTLMInstance | null>(null);
   const [isReady, setIsReady] = useState(false);
   const [isGenerating, setIsGenerating] = useState(false);
   const [downloadProgress, setDownloadProgress] = useState(0);
   const [error, setError] = useState<string | null>(null);
+  const [memorySummary, setMemorySummary] = useState<MemoryTrackerSummary | null>(null);
 
-  // Extract autoLoad (default true)
+  // Destructure config into primitive values for stable dependency arrays.
+  // This prevents infinite re-render loops when consumers pass inline config
+  // objects (e.g. useModel(url, { backend: 'cpu' })) without useMemo.
   const autoLoad = config?.autoLoad ?? true;
+  const enableMemoryTracking = config?.enableMemoryTracking ?? false;
+  const maxMemorySnapshots = config?.maxMemorySnapshots ?? 256;
+  const backend = config?.backend;
+  const systemPrompt = config?.systemPrompt;
+  const maxTokens = config?.maxTokens;
+  const temperature = config?.temperature;
+  const topK = config?.topK;
+  const topP = config?.topP;
+
+  // Build a stable config object from the destructured primitives
+  const nativeConfig = useMemo<LLMConfig>(
+    () => ({
+      ...(backend !== undefined && { backend }),
+      ...(systemPrompt !== undefined && { systemPrompt }),
+      ...(maxTokens !== undefined && { maxTokens }),
+      ...(temperature !== undefined && { temperature }),
+      ...(topK !== undefined && { topK }),
+      ...(topP !== undefined && { topP }),
+    }),
+    [backend, systemPrompt, maxTokens, temperature, topK, topP],
+  );
+
+  /**
+   * Refresh memory summary from the tracker's native buffer.
+   */
+  const refreshMemorySummary = useCallback(() => {
+    if (modelRef.current?.memoryTracker) {
+      setMemorySummary(modelRef.current.memoryTracker.getSummary());
+    }
+  }, []);
 
   // Initialize the model instance
   useEffect(() => {
-    modelRef.current = createLLM();
-    let isMounted = true;
+    modelRef.current = createLLM({
+      enableMemoryTracking,
+      maxMemorySnapshots,
+    });
 
     // Cleanup on unmount
     return () => {
-      isMounted = false;
       try {
         modelRef.current?.close();
       } catch (e) {
         console.warn("Failed to close model", e);
       }
     };
-  }, []);
+  }, [enableMemoryTracking, maxMemorySnapshots]);
 
   const load = useCallback(async () => {
     setIsReady(false);
@@ -53,36 +124,24 @@ export function useModel(
     setDownloadProgress(0);
 
     try {
-      let modelPath = pathOrUrl;
-
-      // Handle URL download manually to capture progress
-      if (pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://")) {
-        const fileName = pathOrUrl.split("/").pop() || "model.bin";
-
-        if (modelRef.current) {
-          modelPath = await modelRef.current.downloadModel(
-            pathOrUrl,
-            fileName,
-            (progress) => {
-              setDownloadProgress(progress);
-            },
-          );
-        }
-      }
-
       if (modelRef.current) {
-        // Create a clean config object for native loadModel (excluding autoLoad)
-        const nativeConfig: LLMConfig = { ...config };
-        delete (nativeConfig as any).autoLoad;
-
-        await modelRef.current.loadModel(modelPath, nativeConfig);
+        // Delegate URL handling + download to the factory's loadModel,
+        // passing our progress setter as the callback (eliminates
+        // duplicate download logic that was previously in this hook).
+        await modelRef.current.loadModel(
+          pathOrUrl,
+          nativeConfig,
+          (progress) => {
+            setDownloadProgress(progress);
+          },
+        );
         setIsReady(true);
       }
     } catch (e: any) {
       setError(e.message || "Failed to load model");
       console.error(e);
     }
-  }, [pathOrUrl, config]);
+  }, [pathOrUrl, nativeConfig]);
 
   useEffect(() => {
     if (autoLoad) {
@@ -106,6 +165,7 @@ export function useModel(
               (token: string, done: boolean) => {
                 fullResponse += token;
                 if (done) {
+                  refreshMemorySummary();
                   resolve(fullResponse);
                 }
               },
@@ -121,7 +181,7 @@ export function useModel(
         setIsGenerating(false);
       }
     },
-    [isReady],
+    [isReady, refreshMemorySummary],
   );
 
   const reset = useCallback(() => {
@@ -130,13 +190,17 @@ export function useModel(
     }
   }, []);
 
-  const deleteModel = useCallback(async (fileName: string): Promise<void> => {
-    if (modelRef.current) {
-      await modelRef.current.deleteModel(fileName);
-      setIsReady(false);
-      setDownloadProgress(0);
-    }
-  }, []);
+  const deleteModel = useCallback(
+    async (fileName?: string): Promise<void> => {
+      if (modelRef.current) {
+        const resolvedName = fileName ?? extractFileName(pathOrUrl);
+        await modelRef.current.deleteModel(resolvedName);
+        setIsReady(false);
+        setDownloadProgress(0);
+      }
+    },
+    [pathOrUrl],
+  );
 
   return {
     model: modelRef.current,
@@ -148,5 +212,7 @@ export function useModel(
     reset,
     deleteModel,
     load,
+    memoryTracker: modelRef.current?.memoryTracker ?? null,
+    memorySummary,
   };
 }

package/src/index.ts

@@ -7,6 +7,7 @@ import type {
   Backend,
   Role,
   GenerationStats,
+  MemoryUsage,
 } from "./specs/LiteRTLM.nitro";
 
 export type {
@@ -16,6 +17,7 @@ export type {
   Backend,
   Role,
   GenerationStats,
+  MemoryUsage,
 } from "./specs/LiteRTLM.nitro";
 
 // Re-export template utilities
@@ -26,6 +28,15 @@ export {
   applyLlamaTemplate,
 } from "./templates";
 
+// Re-export memory tracking utilities (uses NitroModules.createNativeArrayBuffer v0.35+)
+export type {
+  MemorySnapshot,
+  MemoryTracker,
+  MemoryTrackerSummary,
+} from "./memoryTracker";
+export { createMemoryTracker, createNativeBuffer } from "./memoryTracker";
+
+export type { LiteRTLMInstance } from "./modelFactory";
 export * from "./hooks";
 
 /**
@@ -121,14 +132,10 @@ export function checkBackendSupport(backend: Backend): string | undefined {
       return "NPU backend requires compatible hardware (Qualcomm Hexagon, MediaTek APU, etc.). Will fall back to GPU if unavailable.";
     }
     if (Platform.OS === "ios") {
-      return "NPU/CoreML is not yet supported on iOS. LiteRT-LM iOS support is pending.";
+      return "NPU (Neural Engine) is not yet supported on iOS. Use 'gpu' (Metal) or 'cpu' instead.";
     }
   }
 
-  if (Platform.OS === "ios" && backend !== "cpu") {
-    return "LiteRT-LM iOS is not yet released. Only CPU backend may work via fallback.";
-  }
-
   return undefined;
 }
 
@@ -151,7 +158,7 @@ export function checkBackendSupport(backend: Backend): string | undefined {
  */
 export function checkMultimodalSupport(): string | undefined {
   if (Platform.OS === "ios") {
-    return "Multimodal (image/audio) is not yet supported on iOS. LiteRT-LM iOS SDK is pending.";
+    return "Multimodal (image/audio) is experimental on iOS. Vision and audio executors may not be available in the current build.";
   }
   return undefined;
 }