@dr33m/react-native-litert-lm 0.5.0

package/ios/HybridModelStore.swift

@@ -0,0 +1,206 @@
+//
+//  HybridModelStore.swift
+//  react-native-litert-lm
+//
+//  Created by Antigravity on 2026-06-04.
+//  Copyright © 2026 Margelo. All rights reserved.
+//
+
+import Foundation
+import NitroModules
+
+public class HybridModelStore: HybridModelStoreSpec_base, HybridModelStoreSpec_protocol {
+    
+    private let queue = DispatchQueue(label: "dev.litert.modelstore", qos: .utility)
+    
+    private var modelsDirectory: String {
+        let cachesDir = NSSearchPathForDirectoriesInDomains(.cachesDirectory, .userDomainMask, true).first ?? NSTemporaryDirectory()
+        return (cachesDir as NSString).appendingPathComponent("litert_models")
+    }
+    
+    private func sanitizeFileName(_ fileName: String) throws {
+        if fileName.contains("..") || fileName.contains("/") || fileName.contains("\\") {
+            throw NSError(
+                domain: "LiteRTLM.ModelStore",
+                code: 400,
+                userInfo: [NSLocalizedDescriptionKey: "Invalid filename: path traversal or directory separators are not allowed."]
+            )
+        }
+    }
+    
+    public func isCached(fileName: String) throws -> Bool {
+        try sanitizeFileName(fileName)
+        let filePath = (modelsDirectory as NSString).appendingPathComponent(fileName)
+        let fileManager = FileManager.default
+        if fileManager.fileExists(atPath: filePath) {
+            let attrs = try? fileManager.attributesOfItem(atPath: filePath)
+            if let fileSize = attrs?[.size] as? UInt64, fileSize > 0 {
+                return true
+            }
+        }
+        return false
+    }
+    
+    public func getFilePath(fileName: String) throws -> String {
+        try sanitizeFileName(fileName)
+        return (modelsDirectory as NSString).appendingPathComponent(fileName)
+    }
+    
+    public func listCachedFiles() throws -> [ModelFile] {
+        let fileManager = FileManager.default
+        let dir = modelsDirectory
+        
+        guard fileManager.fileExists(atPath: dir) else {
+            return []
+        }
+        
+        let contents = try fileManager.contentsOfDirectory(atPath: dir)
+        var files: [ModelFile] = []
+        
+        for name in contents {
+            if name.hasSuffix(".tmp") { continue }
+            let path = (dir as NSString).appendingPathComponent(name)
+            var isDir: ObjCBool = false
+            if fileManager.fileExists(atPath: path, isDirectory: &isDir), !isDir.boolValue {
+                let attrs = try? fileManager.attributesOfItem(atPath: path)
+                let size = (attrs?[.size] as? UInt64) ?? 0
+                let modDate = (attrs?[.modificationDate] as? Date) ?? Date()
+                
+                files.append(ModelFile(
+                    fileName: name,
+                    absolutePath: path,
+                    sizeBytes: Double(size),
+                    lastModifiedMs: modDate.timeIntervalSince1970 * 1000.0
+                ))
+            }
+        }
+        return files
+    }
+    
+    public func deleteFile(fileName: String) throws {
+        try sanitizeFileName(fileName)
+        let filePath = (modelsDirectory as NSString).appendingPathComponent(fileName)
+        let fileManager = FileManager.default
+        if fileManager.fileExists(atPath: filePath) {
+            try fileManager.removeItem(atPath: filePath)
+        }
+    }
+    
+    public func downloadFile(
+        url: String,
+        fileName: String,
+        headersJson: String,
+        onProgress: @escaping (_ progress: Double) -> Void
+    ) throws -> Promise<String> {
+        let promise = Promise<String>()
+        
+        queue.async {
+            do {
+                try self.sanitizeFileName(fileName)
+                let destPath = (self.modelsDirectory as NSString).appendingPathComponent(fileName)
+                let fileManager = FileManager.default
+                
+                if !fileManager.fileExists(atPath: self.modelsDirectory) {
+                    try fileManager.createDirectory(atPath: self.modelsDirectory, withIntermediateDirectories: true, attributes: nil)
+                }
+                
+                // Fast cache check
+                if fileManager.fileExists(atPath: destPath) {
+                    let attrs = try fileManager.attributesOfItem(atPath: destPath)
+                    if let fileSize = attrs[.size] as? UInt64, fileSize > 0 {
+                        onProgress(1.0)
+                        promise.resolve(withResult: destPath)
+                        return
+                    }
+                }
+                
+                guard let downloadUrl = URL(string: url), downloadUrl.scheme?.lowercased() == "https" else {
+                    promise.reject(withError: NSError(domain: "LiteRTLM.ModelStore", code: 400, userInfo: [NSLocalizedDescriptionKey: "Invalid download URL: HTTPS is required for security."]))
+                    return
+                }
+                
+                onProgress(0.0)
+                
+                // Parse headers JSON
+                var customHeaders: [String: String] = [:]
+                if !headersJson.isEmpty {
+                    if let data = headersJson.data(using: .utf8),
+                       let parsed = try? JSONSerialization.jsonObject(with: data, options: []) as? [String: String] {
+                        customHeaders = parsed
+                    }
+                }
+                
+                let sessionConfig = URLSessionConfiguration.default
+                sessionConfig.timeoutIntervalForRequest = 30
+                sessionConfig.timeoutIntervalForResource = 3600
+                
+                let session = URLSession(configuration: sessionConfig)
+                var progressHandler: NSKeyValueObservation?
+                
+                var request = URLRequest(url: downloadUrl)
+                for (key, value) in customHeaders {
+                    request.addValue(value, forHTTPHeaderField: key)
+                }
+                
+                let tempDestFile = (self.modelsDirectory as NSString).appendingPathComponent("\(fileName).tmp")
+                
+                let task = session.downloadTask(with: request) { location, response, error in
+                    progressHandler?.invalidate()
+                    
+                    if let error = error {
+                        promise.reject(withError: error)
+                        return
+                    }
+                    
+                    if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode >= 400 {
+                        promise.reject(withError: NSError(domain: "LiteRTLM.ModelStore", code: httpResponse.statusCode, userInfo: [NSLocalizedDescriptionKey: "HTTP \(httpResponse.statusCode)"]))
+                        return
+                    }
+                    
+                    guard let location = location else {
+                        promise.reject(withError: NSError(domain: "LiteRTLM.ModelStore", code: 500, userInfo: [NSLocalizedDescriptionKey: "No download location found."]))
+                        return
+                    }
+                    
+                    do {
+                        // Rename/move atomically via temp file helper
+                        if fileManager.fileExists(atPath: tempDestFile) {
+                            try fileManager.removeItem(atPath: tempDestFile)
+                        }
+                        try fileManager.moveItem(at: location, to: URL(fileURLWithPath: tempDestFile))
+                        
+                        if fileManager.fileExists(atPath: destPath) {
+                            try fileManager.removeItem(atPath: destPath)
+                        }
+                        try fileManager.moveItem(at: URL(fileURLWithPath: tempDestFile), to: URL(fileURLWithPath: destPath))
+                        
+                        onProgress(1.0)
+                        promise.resolve(withResult: destPath)
+                    } catch {
+                        promise.reject(withError: error)
+                    }
+                }
+                
+                var lastUpdate = Date()
+                progressHandler = task.observe(\.countOfBytesReceived, options: [.new]) { task, _ in
+                    let expected = task.countOfBytesExpectedToReceive
+                    if expected > 0 {
+                        let now = Date()
+                        if now.timeIntervalSince(lastUpdate) > 0.1 {
+                            let progress = Double(task.countOfBytesReceived) / Double(expected)
+                            onProgress(progress)
+                            lastUpdate = now
+                        }
+                    }
+                }
+                
+                task.resume()
+                session.finishTasksAndInvalidate()
+            } catch {
+                promise.reject(withError: error)
+            }
+        }
+        
+        return promise
+    }
+}

package/ios/MultimodalPart+Factories.swift

@@ -0,0 +1,22 @@
+//
+//  MultimodalPart+Factories.swift
+//  react-native-litert-lm
+//
+//  Mirrors src/inferenceRouting.ts — keep shapes in sync for native direct hybrid access.
+//
+
+import NitroModules
+
+extension MultimodalPart {
+    static func textPart(_ text: String) -> MultimodalPart {
+        MultimodalPart(type: .text, text: text, path: nil, imageBuffer: nil, audioBuffer: nil)
+    }
+
+    static func imagePart(_ path: String) -> MultimodalPart {
+        MultimodalPart(type: .image, text: nil, path: path, imageBuffer: nil, audioBuffer: nil)
+    }
+
+    static func audioPart(_ path: String) -> MultimodalPart {
+        MultimodalPart(type: .audio, text: nil, path: path, imageBuffer: nil, audioBuffer: nil)
+    }
+}

package/ios/Tests/HybridLiteRTLMTests.swift

@@ -0,0 +1,187 @@
+import XCTest
+@testable import LiteRTLM
+
+class HybridLiteRTLMTests: XCTestCase {
+    var bridge: HybridLiteRTLM!
+
+    override func setUp() {
+        super.setUp()
+        bridge = HybridLiteRTLM()
+    }
+
+    override func tearDown() {
+        try? bridge.close()
+        bridge = nil
+        super.tearDown()
+    }
+
+    func testPathTraversalRejection() async throws {
+        let traversals = ["../../etc/passwd", "/absolute/path/file", "subdir\\..\\file", "..", "../", "..\\"]
+        for traversal in traversals {
+            do {
+                let promise = try bridge.deleteModel(fileName: traversal)
+                _ = try await promise.await()
+                XCTFail("Should have failed for traversal: \(traversal)")
+            } catch {
+                let nsError = error as NSError
+                XCTAssertEqual(nsError.domain, "LiteRTLM")
+                XCTAssertEqual(nsError.code, 400)
+                XCTAssertTrue(nsError.localizedDescription.contains("path traversal") || nsError.localizedDescription.contains("directory separators"))
+            }
+        }
+    }
+
+    func testNonHTTPSDownloadRejection() async throws {
+        do {
+            let promise = try bridge.downloadModel(url: "http://insecure-domain.com/model.bin", fileName: "model.bin", onProgress: nil)
+            _ = try await promise.await()
+            XCTFail("Should have blocked insecure HTTP downloads")
+        } catch {
+            let nsError = error as NSError
+            XCTAssertEqual(nsError.domain, "LiteRTLM")
+            XCTAssertEqual(nsError.code, 400)
+            XCTAssertTrue(nsError.localizedDescription.contains("HTTPS is required"))
+        }
+    }
+
+    func testMemoryTelemetry() {
+        XCTAssertNoThrow(try bridge.getMemoryUsage())
+        if let mem = try? bridge.getMemoryUsage() {
+            XCTAssertGreaterThanOrEqual(mem.nativeHeapBytes, 0.0)
+            XCTAssertGreaterThanOrEqual(mem.residentBytes, 0.0)
+            XCTAssertGreaterThanOrEqual(mem.availableMemoryBytes, 0.0)
+        }
+    }
+
+    func testSendMessageAsyncRejectsWithoutModel() async throws {
+        do {
+            let promise = try bridge.sendMessageAsync(message: "hello") { _, _ in }
+            _ = try await promise.await()
+            XCTFail("Should have failed without model")
+        } catch {
+            let nsError = error as NSError
+            XCTAssertEqual(nsError.domain, "LiteRTLM")
+            XCTAssertEqual(nsError.code, 400)
+        }
+    }
+
+    func testSendMessageWithImageAsyncRejectsWithoutModel() async throws {
+        do {
+            let promise = try bridge.sendMessageWithImageAsync(message: "hello", imagePath: "/tmp/image.jpg") { _, _ in }
+            _ = try await promise.await()
+            XCTFail("Should have failed without model")
+        } catch {
+            let nsError = error as NSError
+            XCTAssertEqual(nsError.domain, "LiteRTLM")
+            XCTAssertEqual(nsError.code, 400)
+        }
+    }
+
+    func testSendMessageWithAudioAsyncRejectsWithoutModel() async throws {
+        do {
+            let promise = try bridge.sendMessageWithAudioAsync(message: "hello", audioPath: "/tmp/audio.wav") { _, _ in }
+            _ = try await promise.await()
+            XCTFail("Should have failed without model")
+        } catch {
+            let nsError = error as NSError
+            XCTAssertEqual(nsError.domain, "LiteRTLM")
+            XCTAssertEqual(nsError.code, 400)
+        }
+    }
+
+    func testSendMessageWithImageAsyncRejectsFileNotFound() async throws {
+        do {
+            let promise = try bridge.sendMessageWithImageAsync(message: "hello", imagePath: "/nonexistent/image.jpg") { _, _ in }
+            _ = try await promise.await()
+            XCTFail("Should have failed without model")
+        } catch {
+            let nsError = error as NSError
+            XCTAssertEqual(nsError.domain, "LiteRTLM")
+        }
+    }
+
+    func testSendMessageWithAudioAsyncRejectsFileNotFound() async throws {
+        do {
+            let promise = try bridge.sendMessageWithAudioAsync(message: "hello", audioPath: "/nonexistent/audio.wav") { _, _ in }
+            _ = try await promise.await()
+            XCTFail("Should have failed without model")
+        } catch {
+            let nsError = error as NSError
+            XCTAssertEqual(nsError.domain, "LiteRTLM")
+        }
+    }
+
+    func testInitialStats() {
+        XCTAssertNoThrow(try bridge.getStats())
+        if let stats = try? bridge.getStats() {
+            XCTAssertEqual(stats.promptTokens, 0.0)
+            XCTAssertEqual(stats.completionTokens, 0.0)
+            XCTAssertEqual(stats.totalTokens, 0.0)
+            XCTAssertEqual(stats.timeToFirstToken, 0.0)
+            XCTAssertEqual(stats.totalTime, 0.0)
+            XCTAssertEqual(stats.tokensPerSecond, 0.0)
+        }
+    }
+
+    func testDeleteModelCleanupLogic() async throws {
+        bridge.loadedModelPath = "/path/to/my_loaded_model.litertlm"
+
+        let promise1 = try bridge.deleteModel(fileName: "other_model.litertlm")
+        _ = try await promise1.await()
+        XCTAssertEqual(bridge.loadedModelPath, "/path/to/my_loaded_model.litertlm")
+
+        let promise2 = try bridge.deleteModel(fileName: "my_loaded_model.litertlm")
+        _ = try await promise2.await()
+        XCTAssertNil(bridge.loadedModelPath)
+    }
+
+    func testExecutePathPrecedenceOverBuffer() async throws {
+        let pathPart = MultimodalPart(
+            type: .image,
+            text: nil,
+            path: "/nonexistent/precedence_test_image.jpg",
+            imageBuffer: nil,
+            audioBuffer: nil
+        )
+        
+        do {
+            let promise = try bridge.execute(parts: [pathPart], onToken: nil)
+            _ = try await promise.await()
+            XCTFail("Should have failed")
+        } catch {
+            let nsError = error as NSError
+            XCTAssertTrue(nsError.localizedDescription.contains("file not found: /nonexistent/precedence_test_image.jpg"))
+        }
+    }
+
+    func testExecuteTempFileCleanupOnError() async throws {
+        let dummyData = Data([0, 1, 2, 3])
+        let buffer = ArrayBuffer(dummyData)
+        
+        let bufferPart = MultimodalPart(
+            type: .image,
+            text: nil,
+            path: nil,
+            imageBuffer: buffer,
+            audioBuffer: nil
+        )
+        
+        let invalidPathPart = MultimodalPart(
+            type: .image,
+            text: nil,
+            path: "/nonexistent/invalid_file_cleanup_test.jpg",
+            imageBuffer: nil,
+            audioBuffer: nil
+        )
+        
+        do {
+            let promise = try bridge.execute(parts: [bufferPart, invalidPathPart], onToken: nil)
+            _ = try await promise.await()
+            XCTFail("Should have failed")
+        } catch {
+            let tempDirAfter = try FileManager.default.contentsOfDirectory(atPath: NSTemporaryDirectory())
+            let leakedFiles = tempDirAfter.filter { $0.contains("litert_buf_") }
+            XCTAssertEqual(leakedFiles.count, 0)
+        }
+    }
+}

package/lib/__mocks__/react-native-nitro-modules.d.ts

@@ -0,0 +1,81 @@
+import type { MultimodalPart } from "../specs/LiteRTLM.nitro";
+export declare const mockLiteRTLM: {
+    isReady: jest.Mock<boolean, [], any>;
+    loadModel: jest.Mock<any, any, any>;
+    execute: jest.Mock<Promise<string>, [parts: MultimodalPart[], onToken?: ((token: string, done: boolean) => void) | undefined], any>;
+    sendMessage: jest.Mock<Promise<string>, [message: string], any>;
+    sendMessageWithImage: jest.Mock<Promise<string>, [message: string, imagePath: string], any>;
+    downloadModel: jest.Mock<Promise<string>, [url: string, fileName: string, onProgress?: ((progress: number) => void) | undefined], any>;
+    deleteModel: jest.Mock<any, any, any>;
+    sendMessageWithAudio: jest.Mock<Promise<string>, [message: string, audioPath: string], any>;
+    sendMultimodalMessage: jest.Mock<Promise<string>, [parts: MultimodalPart[]], any>;
+    sendMessageAsync: jest.Mock<Promise<void>, [msg: string, onToken: (token: string, done: boolean) => void], any>;
+    sendMessageWithImageAsync: jest.Mock<Promise<void>, [msg: string, imagePath: string, onToken: (token: string, done: boolean) => void], any>;
+    sendMessageWithAudioAsync: jest.Mock<Promise<void>, [msg: string, audioPath: string, onToken: (token: string, done: boolean) => void], any>;
+    getHistory: jest.Mock<never[], [], any>;
+    resetConversation: jest.Mock<any, any, any>;
+    getStats: jest.Mock<{
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+        timeToFirstToken: number;
+        totalTime: number;
+        tokensPerSecond: number;
+    }, [], any>;
+    countTokens: jest.Mock<number, [], any>;
+    getMemoryUsage: jest.Mock<{
+        nativeHeapBytes: number;
+        residentBytes: number;
+        availableMemoryBytes: number;
+        isLowMemory: boolean;
+    }, [], any>;
+    close: jest.Mock<any, any, any>;
+};
+export declare const mockModelStore: {
+    isCached: jest.Mock<boolean, [fileName: string], any>;
+    getFilePath: jest.Mock<string, [fileName: string], any>;
+    listCachedFiles: jest.Mock<never[], [], any>;
+    deleteFile: jest.Mock<any, [fileName: string], any>;
+    downloadFile: jest.Mock<Promise<string>, [url: string, fileName: string, headersJson: string, onProgress: (progress: number) => void], any>;
+};
+export declare const NitroModules: {
+    createHybridObject: jest.Mock<{
+        isReady: jest.Mock<boolean, [], any>;
+        loadModel: jest.Mock<any, any, any>;
+        execute: jest.Mock<Promise<string>, [parts: MultimodalPart[], onToken?: ((token: string, done: boolean) => void) | undefined], any>;
+        sendMessage: jest.Mock<Promise<string>, [message: string], any>;
+        sendMessageWithImage: jest.Mock<Promise<string>, [message: string, imagePath: string], any>;
+        downloadModel: jest.Mock<Promise<string>, [url: string, fileName: string, onProgress?: ((progress: number) => void) | undefined], any>;
+        deleteModel: jest.Mock<any, any, any>;
+        sendMessageWithAudio: jest.Mock<Promise<string>, [message: string, audioPath: string], any>;
+        sendMultimodalMessage: jest.Mock<Promise<string>, [parts: MultimodalPart[]], any>;
+        sendMessageAsync: jest.Mock<Promise<void>, [msg: string, onToken: (token: string, done: boolean) => void], any>;
+        sendMessageWithImageAsync: jest.Mock<Promise<void>, [msg: string, imagePath: string, onToken: (token: string, done: boolean) => void], any>;
+        sendMessageWithAudioAsync: jest.Mock<Promise<void>, [msg: string, audioPath: string, onToken: (token: string, done: boolean) => void], any>;
+        getHistory: jest.Mock<never[], [], any>;
+        resetConversation: jest.Mock<any, any, any>;
+        getStats: jest.Mock<{
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+            timeToFirstToken: number;
+            totalTime: number;
+            tokensPerSecond: number;
+        }, [], any>;
+        countTokens: jest.Mock<number, [], any>;
+        getMemoryUsage: jest.Mock<{
+            nativeHeapBytes: number;
+            residentBytes: number;
+            availableMemoryBytes: number;
+            isLowMemory: boolean;
+        }, [], any>;
+        close: jest.Mock<any, any, any>;
+    } | {
+        isCached: jest.Mock<boolean, [fileName: string], any>;
+        getFilePath: jest.Mock<string, [fileName: string], any>;
+        listCachedFiles: jest.Mock<never[], [], any>;
+        deleteFile: jest.Mock<any, [fileName: string], any>;
+        downloadFile: jest.Mock<Promise<string>, [url: string, fileName: string, headersJson: string, onProgress: (progress: number) => void], any>;
+    }, [name: string], any>;
+    createNativeArrayBuffer: jest.Mock<ArrayBuffer, [size: number], any>;
+};

package/lib/__mocks__/react-native-nitro-modules.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NitroModules = exports.mockModelStore = exports.mockLiteRTLM = void 0;
+function streamMockTokens(parts, onToken) {
+    const hasImage = parts.some((p) => p.type === "image");
+    const hasAudio = parts.some((p) => p.type === "audio");
+    if (hasImage) {
+        onToken("Mock vision ", false);
+        onToken("token", true);
+    }
+    else if (hasAudio) {
+        onToken("Mock audio ", false);
+        onToken("token", true);
+    }
+    else {
+        onToken("Mock ", false);
+        onToken("token", true);
+    }
+}
+function mockExecuteResponse(parts) {
+    const hasImage = parts.some((p) => p.type === "image");
+    const hasAudio = parts.some((p) => p.type === "audio");
+    return hasImage
+        ? "Mock vision token"
+        : hasAudio
+            ? "Mock audio token"
+            : "Mock token";
+}
+const mockExecute = jest.fn((parts, onToken) => {
+    if (onToken) {
+        streamMockTokens(parts, onToken);
+    }
+    return Promise.resolve(mockExecuteResponse(parts));
+});
+exports.mockLiteRTLM = {
+    isReady: jest.fn(() => false),
+    loadModel: jest.fn().mockResolvedValue(undefined),
+    execute: mockExecute,
+    sendMessage: jest.fn((message) => mockExecute([{ type: "text", text: message }])),
+    sendMessageWithImage: jest.fn((message, imagePath) => mockExecute([
+        { type: "text", text: message },
+        { type: "image", path: imagePath },
+    ])),
+    downloadModel: jest.fn(async (url, fileName, onProgress) => {
+        onProgress?.(1.0);
+        return "/mock/path/model.litertlm";
+    }),
+    deleteModel: jest.fn().mockResolvedValue(undefined),
+    sendMessageWithAudio: jest.fn((message, audioPath) => mockExecute([
+        { type: "text", text: message },
+        { type: "audio", path: audioPath },
+    ])),
+    sendMultimodalMessage: jest.fn((parts) => mockExecute(parts)),
+    sendMessageAsync: jest.fn((msg, onToken) => mockExecute([{ type: "text", text: msg }], onToken).then(() => { })),
+    sendMessageWithImageAsync: jest.fn((msg, imagePath, onToken) => mockExecute([{ type: "text", text: msg }, { type: "image", path: imagePath }], onToken).then(() => { })),
+    sendMessageWithAudioAsync: jest.fn((msg, audioPath, onToken) => mockExecute([{ type: "text", text: msg }, { type: "audio", path: audioPath }], onToken).then(() => { })),
+    getHistory: jest.fn(() => []),
+    resetConversation: jest.fn(),
+    getStats: jest.fn(() => ({
+        promptTokens: 10,
+        completionTokens: 20,
+        totalTokens: 30,
+        timeToFirstToken: 5,
+        totalTime: 50,
+        tokensPerSecond: 400,
+    })),
+    countTokens: jest.fn(() => -1),
+    getMemoryUsage: jest.fn(() => ({
+        nativeHeapBytes: 1000000,
+        residentBytes: 2000000,
+        availableMemoryBytes: 4000000,
+        isLowMemory: false,
+    })),
+    close: jest.fn(),
+};
+exports.mockModelStore = {
+    isCached: jest.fn((fileName) => false),
+    getFilePath: jest.fn((fileName) => `/mock/path/${fileName}`),
+    listCachedFiles: jest.fn(() => []),
+    deleteFile: jest.fn((fileName) => {
+        return exports.mockLiteRTLM.deleteModel(fileName);
+    }),
+    downloadFile: jest.fn(async (url, fileName, headersJson, onProgress) => exports.mockLiteRTLM.downloadModel(url, fileName, onProgress)),
+};
+exports.NitroModules = {
+    createHybridObject: jest.fn((name) => {
+        if (name === "LiteRTLM") {
+            return exports.mockLiteRTLM;
+        }
+        if (name === "ModelStore") {
+            return exports.mockModelStore;
+        }
+        throw new Error(`Mock not implemented for hybrid object: ${name}`);
+    }),
+    createNativeArrayBuffer: jest.fn((size) => {
+        return new ArrayBuffer(size);
+    }),
+};

package/lib/__tests__/hooks.test.d.ts

@@ -0,0 +1 @@
+export {};