@dr33m/react-native-litert-lm 0.5.0

package/lib/__tests__/hooks.test.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Configure React act environment
+global.IS_REACT_ACT_ENVIRONMENT = true;
+const hooks_1 = require("../hooks");
+const react_native_nitro_modules_1 = require("../__mocks__/react-native-nitro-modules");
+const react_test_renderer_1 = __importDefault(require("react-test-renderer"));
+const react_1 = __importDefault(require("react"));
+// Mock react-native
+jest.mock('react-native', () => ({
+    Platform: {
+        OS: 'ios',
+        select: jest.fn((dict) => dict.ios),
+    },
+}));
+// Helper to render and test hooks using react-test-renderer
+function renderHook(callback, initialProps) {
+    let result = { current: null };
+    const TestComponent = ({ props }) => {
+        result.current = callback(props);
+        return null;
+    };
+    let renderer;
+    react_test_renderer_1.default.act(() => {
+        renderer = react_test_renderer_1.default.create(react_1.default.createElement(TestComponent, { props: initialProps }));
+    });
+    const rerender = (newProps) => {
+        react_test_renderer_1.default.act(() => {
+            renderer.update(react_1.default.createElement(TestComponent, { props: newProps }));
+        });
+    };
+    const unmount = () => {
+        react_test_renderer_1.default.act(() => {
+            renderer.unmount();
+        });
+    };
+    return { result, rerender, unmount };
+}
+describe('useModel React Hook Unit Tests', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should initialize with correct default state and call loadModel automatically when autoLoad is true', async () => {
+        let hookResult;
+        await react_test_renderer_1.default.act(async () => {
+            hookResult = renderHook(() => (0, hooks_1.useModel)('https://example.com/model.litertlm', { autoLoad: true }));
+        });
+        expect(hookResult.result.current.isReady).toBe(true);
+        expect(hookResult.result.current.isGenerating).toBe(false);
+        expect(hookResult.result.current.downloadProgress).toBe(1); // loadModel completed
+        expect(hookResult.result.current.error).toBeNull();
+        expect(react_native_nitro_modules_1.mockLiteRTLM.loadModel).toHaveBeenCalled();
+    });
+    it('should not call loadModel automatically when autoLoad is false', async () => {
+        let hookResult;
+        await react_test_renderer_1.default.act(async () => {
+            hookResult = renderHook(() => (0, hooks_1.useModel)('https://example.com/model.litertlm', { autoLoad: false }));
+        });
+        expect(hookResult.result.current.isReady).toBe(false);
+        expect(react_native_nitro_modules_1.mockLiteRTLM.loadModel).not.toHaveBeenCalled();
+        // Call load manually
+        await react_test_renderer_1.default.act(async () => {
+            await hookResult.result.current.load();
+        });
+        expect(hookResult.result.current.isReady).toBe(true);
+        expect(react_native_nitro_modules_1.mockLiteRTLM.loadModel).toHaveBeenCalled();
+    });
+    it('should handle model load failure gracefully', async () => {
+        react_native_nitro_modules_1.mockLiteRTLM.loadModel.mockRejectedValueOnce(new Error("Model load failed"));
+        let hookResult;
+        await react_test_renderer_1.default.act(async () => {
+            hookResult = renderHook(() => (0, hooks_1.useModel)('https://example.com/model.litertlm', { autoLoad: true }));
+        });
+        expect(hookResult.result.current.isReady).toBe(false);
+        expect(hookResult.result.current.error).toBe("Model load failed");
+    });
+    it('should generate text successfully and trigger memory summary update', async () => {
+        let hookResult;
+        await react_test_renderer_1.default.act(async () => {
+            hookResult = renderHook(() => (0, hooks_1.useModel)('https://example.com/model.litertlm', {
+                autoLoad: true,
+                enableMemoryTracking: true
+            }));
+        });
+        let response = "";
+        await react_test_renderer_1.default.act(async () => {
+            response = await hookResult.result.current.generate("Test prompt");
+        });
+        expect(response).toBe("Mock token");
+        expect(react_native_nitro_modules_1.mockLiteRTLM.execute).toHaveBeenCalledWith([{ type: "text", text: "Test prompt" }], undefined);
+        expect(hookResult.result.current.memorySummary).toBeDefined();
+    });
+    it('should reset conversation correctly', async () => {
+        let hookResult;
+        await react_test_renderer_1.default.act(async () => {
+            hookResult = renderHook(() => (0, hooks_1.useModel)('https://example.com/model.litertlm', { autoLoad: true }));
+        });
+        hookResult.result.current.reset();
+        expect(react_native_nitro_modules_1.mockLiteRTLM.resetConversation).toHaveBeenCalled();
+    });
+    it('should delete model file correctly', async () => {
+        let hookResult;
+        await react_test_renderer_1.default.act(async () => {
+            hookResult = renderHook(() => (0, hooks_1.useModel)('https://example.com/model.litertlm', { autoLoad: true }));
+        });
+        await react_test_renderer_1.default.act(async () => {
+            await hookResult.result.current.deleteModel();
+        });
+        expect(react_native_nitro_modules_1.mockLiteRTLM.deleteModel).toHaveBeenCalledWith('model.litertlm');
+        expect(hookResult.result.current.isReady).toBe(false);
+        expect(hookResult.result.current.downloadProgress).toBe(0);
+    });
+    it('should call close on unmount', async () => {
+        let hookResult;
+        await react_test_renderer_1.default.act(async () => {
+            hookResult = renderHook(() => (0, hooks_1.useModel)('https://example.com/model.litertlm', { autoLoad: false }));
+        });
+        hookResult.unmount();
+        expect(react_native_nitro_modules_1.mockLiteRTLM.close).toHaveBeenCalled();
+    });
+    it('should pass maxContextTokens and maxOutputTokens through to loadModel', async () => {
+        let hookResult;
+        await react_test_renderer_1.default.act(async () => {
+            hookResult = renderHook(() => (0, hooks_1.useModel)('https://example.com/model.litertlm', {
+                autoLoad: true,
+                maxContextTokens: 8192,
+                maxOutputTokens: 2048,
+            }));
+        });
+        expect(react_native_nitro_modules_1.mockLiteRTLM.loadModel).toHaveBeenCalled();
+        const callArgs = react_native_nitro_modules_1.mockLiteRTLM.loadModel.mock.calls[0];
+        const config = callArgs[1];
+        expect(config).toMatchObject({
+            maxContextTokens: 8192,
+            maxOutputTokens: 2048,
+        });
+    });
+    it('should pass legacy maxTokens through when new fields are not set', async () => {
+        let hookResult;
+        await react_test_renderer_1.default.act(async () => {
+            hookResult = renderHook(() => (0, hooks_1.useModel)('https://example.com/model.litertlm', {
+                autoLoad: true,
+                maxTokens: 512,
+            }));
+        });
+        expect(react_native_nitro_modules_1.mockLiteRTLM.loadModel).toHaveBeenCalled();
+        const callArgs = react_native_nitro_modules_1.mockLiteRTLM.loadModel.mock.calls[0];
+        const config = callArgs[1];
+        expect(config).toMatchObject({ maxTokens: 512 });
+        expect(config.maxContextTokens).toBeUndefined();
+        expect(config.maxOutputTokens).toBeUndefined();
+    });
+    it('should pass both new fields alongside legacy maxTokens when all are set', async () => {
+        let hookResult;
+        await react_test_renderer_1.default.act(async () => {
+            hookResult = renderHook(() => (0, hooks_1.useModel)('https://example.com/model.litertlm', {
+                autoLoad: true,
+                maxTokens: 512,
+                maxContextTokens: 4096,
+                maxOutputTokens: 1024,
+            }));
+        });
+        expect(react_native_nitro_modules_1.mockLiteRTLM.loadModel).toHaveBeenCalled();
+        const callArgs = react_native_nitro_modules_1.mockLiteRTLM.loadModel.mock.calls[0];
+        const config = callArgs[1];
+        expect(config).toMatchObject({
+            maxTokens: 512,
+            maxContextTokens: 4096,
+            maxOutputTokens: 1024,
+        });
+    });
+});

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

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

package/lib/__tests__/inferenceRouting.test.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const inferenceRouting_1 = require("../inferenceRouting");
+describe("inferenceRouting", () => {
+    it("routes sendMessage to a single text part", () => {
+        const route = (0, inferenceRouting_1.routeLegacyInference)("sendMessage", ["hello"]);
+        expect(route).toEqual({ parts: [(0, inferenceRouting_1.textPart)("hello")] });
+    });
+    it("routes sendMessageWithImageAsync with stream callback", () => {
+        const onToken = jest.fn();
+        const route = (0, inferenceRouting_1.routeLegacyInference)("sendMessageWithImageAsync", [
+            "describe",
+            "/img.jpg",
+            onToken,
+        ]);
+        expect(route).toEqual({
+            parts: [(0, inferenceRouting_1.textPart)("describe"), (0, inferenceRouting_1.imagePart)("/img.jpg")],
+            onToken,
+        });
+    });
+    it("returns null for unknown methods", () => {
+        expect((0, inferenceRouting_1.routeLegacyInference)("downloadModel", ["url", "file"])).toBeNull();
+    });
+    it("isLegacyInferenceMethod narrows known methods", () => {
+        expect((0, inferenceRouting_1.isLegacyInferenceMethod)("sendMessage")).toBe(true);
+        expect((0, inferenceRouting_1.isLegacyInferenceMethod)("close")).toBe(false);
+    });
+});

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

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

package/lib/__tests__/memoryTracker.test.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const memoryTracker_1 = require("../memoryTracker");
+const react_native_nitro_modules_1 = require("react-native-nitro-modules");
+describe('MemoryTracker Unit Tests', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should allocate correct native-backed ArrayBuffer size on initialization', () => {
+        const tracker = (0, memoryTracker_1.createMemoryTracker)(10);
+        expect(react_native_nitro_modules_1.NitroModules.createNativeArrayBuffer).toHaveBeenCalledWith(10 * 4 * 8); // 10 snapshots * 4 fields * 8 bytes/Float64
+        expect(tracker.getCapacity()).toBe(10);
+        expect(tracker.getSnapshotCount()).toBe(0);
+    });
+    it('should record snapshots correctly and retrieve them', () => {
+        const tracker = (0, memoryTracker_1.createMemoryTracker)(5);
+        const snapshot1 = {
+            timestamp: 1000,
+            nativeHeapBytes: 100,
+            residentBytes: 200,
+            availableMemoryBytes: 500,
+        };
+        expect(tracker.record(snapshot1)).toBe(true);
+        expect(tracker.getSnapshotCount()).toBe(1);
+        expect(tracker.getLatestSnapshot()).toEqual(snapshot1);
+        const snapshots = tracker.getSnapshots();
+        expect(snapshots).toHaveLength(1);
+        expect(snapshots[0]).toEqual(snapshot1);
+    });
+    it('should reject new snapshots and return false when capacity is reached', () => {
+        const tracker = (0, memoryTracker_1.createMemoryTracker)(2);
+        expect(tracker.record({ timestamp: 1, nativeHeapBytes: 10, residentBytes: 20, availableMemoryBytes: 50 })).toBe(true);
+        expect(tracker.record({ timestamp: 2, nativeHeapBytes: 20, residentBytes: 30, availableMemoryBytes: 40 })).toBe(true);
+        expect(tracker.record({ timestamp: 3, nativeHeapBytes: 30, residentBytes: 40, availableMemoryBytes: 30 })).toBe(false);
+        expect(tracker.getSnapshotCount()).toBe(2);
+    });
+    it('should calculate correct peak resident memory size', () => {
+        const tracker = (0, memoryTracker_1.createMemoryTracker)(5);
+        tracker.record({ timestamp: 1, nativeHeapBytes: 100, residentBytes: 150, availableMemoryBytes: 1000 });
+        tracker.record({ timestamp: 2, nativeHeapBytes: 120, residentBytes: 300, availableMemoryBytes: 1000 });
+        tracker.record({ timestamp: 3, nativeHeapBytes: 110, residentBytes: 200, availableMemoryBytes: 1000 });
+        expect(tracker.getPeakMemory()).toBe(300);
+    });
+    it('should calculate accurate memory summary statistics', () => {
+        const tracker = (0, memoryTracker_1.createMemoryTracker)(5);
+        tracker.record({ timestamp: 1, nativeHeapBytes: 50, residentBytes: 100, availableMemoryBytes: 1000 });
+        tracker.record({ timestamp: 2, nativeHeapBytes: 150, residentBytes: 300, availableMemoryBytes: 800 });
+        tracker.record({ timestamp: 3, nativeHeapBytes: 100, residentBytes: 200, availableMemoryBytes: 900 });
+        const summary = tracker.getSummary();
+        expect(summary.snapshotCount).toBe(3);
+        expect(summary.peakResidentBytes).toBe(300);
+        expect(summary.averageResidentBytes).toBe(200); // (100 + 300 + 200) / 3
+        expect(summary.currentResidentBytes).toBe(200);
+        expect(summary.peakNativeHeapBytes).toBe(150);
+        expect(summary.currentNativeHeapBytes).toBe(100);
+        expect(summary.residentDeltaBytes).toBe(100); // currentRss(200) - firstRss(100)
+        expect(summary.trackerBufferSizeBytes).toBe(5 * 4 * 8);
+    });
+    it('should preserve buffer but reset internal state when reset() is called', () => {
+        const tracker = (0, memoryTracker_1.createMemoryTracker)(5);
+        tracker.record({ timestamp: 1, nativeHeapBytes: 50, residentBytes: 100, availableMemoryBytes: 1000 });
+        expect(tracker.getSnapshotCount()).toBe(1);
+        tracker.reset();
+        expect(tracker.getSnapshotCount()).toBe(0);
+        expect(tracker.getLatestSnapshot()).toBeUndefined();
+        expect(tracker.getSnapshots()).toEqual([]);
+    });
+    it('should allow standalone native ArrayBuffer allocation via createNativeBuffer', () => {
+        const size = 128;
+        const buffer = (0, memoryTracker_1.createNativeBuffer)(size);
+        expect(react_native_nitro_modules_1.NitroModules.createNativeArrayBuffer).toHaveBeenCalledWith(size);
+        expect(buffer.byteLength).toBe(size);
+    });
+});

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

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

package/lib/__tests__/modelFactory.test.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const modelFactory_1 = require("../modelFactory");
+const react_native_nitro_modules_1 = require("../__mocks__/react-native-nitro-modules");
+describe('modelFactory Security & Proxy Unit Tests', () => {
+    let llm;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        llm = (0, modelFactory_1.createLLM)({ enableMemoryTracking: true });
+    });
+    it('should block insecure HTTP downloads', async () => {
+        await expect(llm.loadModel('http://example.com/model.litertlm'))
+            .rejects.toThrow('Insecure HTTP URLs are not allowed for model downloads');
+    });
+    it('should allow secure HTTPS downloads and strip query parameters', async () => {
+        await llm.loadModel('https://example.com/model.litertlm?token=123');
+        expect(react_native_nitro_modules_1.mockLiteRTLM.downloadModel).toHaveBeenCalledWith('https://example.com/model.litertlm?token=123', 'model.litertlm', expect.any(Function));
+        expect(react_native_nitro_modules_1.mockLiteRTLM.loadModel).toHaveBeenCalledWith('/mock/path/model.litertlm', undefined);
+    });
+    it('should throw an error for invalid model URL', async () => {
+        await expect(llm.loadModel('https://example.com/'))
+            .rejects.toThrow('Invalid model URL: https://example.com/');
+    });
+    it('should successfully proxy sendMessage and record memory metrics', async () => {
+        const response = await llm.sendMessage("Test prompt");
+        expect(response).toBe("Mock token");
+        expect(react_native_nitro_modules_1.mockLiteRTLM.execute).toHaveBeenCalledWith([{ type: "text", text: "Test prompt" }], undefined);
+        expect(react_native_nitro_modules_1.mockLiteRTLM.getMemoryUsage).toHaveBeenCalled();
+        expect(llm.memoryTracker?.getSnapshotCount()).toBe(1); // sendMessage records one
+    });
+    it('should successfully proxy resetConversation and record memory metrics', async () => {
+        await llm.resetConversation();
+        expect(react_native_nitro_modules_1.mockLiteRTLM.resetConversation).toHaveBeenCalled();
+        expect(react_native_nitro_modules_1.mockLiteRTLM.getMemoryUsage).toHaveBeenCalled();
+    });
+    it('should successfully proxy sendMessageAsync and record memory metrics when done', async () => {
+        const onToken = jest.fn();
+        await llm.sendMessageAsync("Async prompt", onToken);
+        expect(onToken).toHaveBeenCalledWith("Mock ", false);
+        expect(onToken).toHaveBeenCalledWith("token", true);
+        expect(react_native_nitro_modules_1.mockLiteRTLM.execute).toHaveBeenCalledWith([{ type: "text", text: "Async prompt" }], expect.any(Function));
+        expect(react_native_nitro_modules_1.mockLiteRTLM.getMemoryUsage).toHaveBeenCalled();
+    });
+    it('should successfully proxy sendMessageWithImageAsync and record memory metrics when done', async () => {
+        const onToken = jest.fn();
+        await llm.sendMessageWithImageAsync("Vision prompt", "/path/to/image.jpg", onToken);
+        expect(onToken).toHaveBeenCalledWith("Mock vision ", false);
+        expect(onToken).toHaveBeenCalledWith("token", true);
+        expect(react_native_nitro_modules_1.mockLiteRTLM.execute).toHaveBeenCalledWith([
+            { type: "text", text: "Vision prompt" },
+            { type: "image", path: "/path/to/image.jpg" },
+        ], expect.any(Function));
+        expect(react_native_nitro_modules_1.mockLiteRTLM.getMemoryUsage).toHaveBeenCalled();
+    });
+    it('should successfully proxy sendMessageWithAudioAsync and record memory metrics when done', async () => {
+        const onToken = jest.fn();
+        await llm.sendMessageWithAudioAsync("Audio prompt", "/path/to/audio.wav", onToken);
+        expect(onToken).toHaveBeenCalledWith("Mock audio ", false);
+        expect(onToken).toHaveBeenCalledWith("token", true);
+        expect(react_native_nitro_modules_1.mockLiteRTLM.execute).toHaveBeenCalledWith([
+            { type: "text", text: "Audio prompt" },
+            { type: "audio", path: "/path/to/audio.wav" },
+        ], expect.any(Function));
+        expect(react_native_nitro_modules_1.mockLiteRTLM.getMemoryUsage).toHaveBeenCalled();
+    });
+    it('should successfully access memoryTracker and getSnapshots when memory tracking is enabled', () => {
+        expect(llm.memoryTracker).toBeDefined();
+        expect(llm.memoryTracker?.getCapacity()).toBe(256);
+    });
+    it('should not initialize memoryTracker when enableMemoryTracking option is false', () => {
+        const untrackedLLM = (0, modelFactory_1.createLLM)({ enableMemoryTracking: false });
+        expect(untrackedLLM.memoryTracker).toBeUndefined();
+    });
+    it('should forward maxContextTokens and maxOutputTokens config to native loadModel', async () => {
+        const config = {
+            backend: 'cpu',
+            maxContextTokens: 8192,
+            maxOutputTokens: 2048,
+        };
+        await llm.loadModel('/local/path/model.litertlm', config);
+        expect(react_native_nitro_modules_1.mockLiteRTLM.loadModel).toHaveBeenCalledWith('/local/path/model.litertlm', config);
+    });
+    it('should forward legacy maxTokens config to native loadModel for backward compat', async () => {
+        const config = {
+            backend: 'cpu',
+            maxTokens: 512,
+        };
+        await llm.loadModel('/local/path/model.litertlm', config);
+        expect(react_native_nitro_modules_1.mockLiteRTLM.loadModel).toHaveBeenCalledWith('/local/path/model.litertlm', config);
+    });
+    it('should forward execute call exactly to native execute', async () => {
+        const parts = [
+            { type: 'image', path: '/path/to/image.jpg', imageBuffer: new ArrayBuffer(10) }
+        ];
+        await llm.execute(parts);
+        expect(react_native_nitro_modules_1.mockLiteRTLM.execute).toHaveBeenCalledWith(parts, undefined);
+    });
+    it('should strip file:// prefix from paths in execute parts before forwarding to native execute', async () => {
+        const parts = [
+            { type: 'image', path: 'file:///path/to/image.jpg', imageBuffer: new ArrayBuffer(10) }
+        ];
+        await llm.execute(parts);
+        expect(react_native_nitro_modules_1.mockLiteRTLM.execute).toHaveBeenCalledWith([
+            { type: 'image', path: '/path/to/image.jpg', imageBuffer: expect.any(ArrayBuffer) }
+        ], undefined);
+    });
+});

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

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

package/lib/__tests__/modelPath.test.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const modelPath_1 = require("../modelPath");
+describe("modelPath", () => {
+    it("strips query strings from URLs", () => {
+        expect((0, modelPath_1.extractFileName)("https://example.com/model.litertlm?token=abc")).toBe("model.litertlm");
+    });
+    it("resolveModelFileName uses basename for paths and URLs", () => {
+        expect((0, modelPath_1.resolveModelFileName)("/data/models/foo.litertlm")).toBe("foo.litertlm");
+        expect((0, modelPath_1.resolveModelFileName)("bare-name.bin")).toBe("bare-name.bin");
+    });
+});

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

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

package/lib/__tests__/modelRegistry.test.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const modelRegistry_1 = require("../modelRegistry");
+const react_native_nitro_modules_1 = require("../__mocks__/react-native-nitro-modules");
+describe('ModelRegistry Unit Tests', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('isCached should query native store correctly', () => {
+        react_native_nitro_modules_1.mockModelStore.isCached.mockReturnValueOnce(true);
+        const result = modelRegistry_1.ModelRegistry.isCached('https://example.com/test-model.litertlm');
+        expect(react_native_nitro_modules_1.mockModelStore.isCached).toHaveBeenCalledWith('test-model.litertlm');
+        expect(result).toBe(true);
+    });
+    it('getFilePath should return cached path', () => {
+        react_native_nitro_modules_1.mockModelStore.getFilePath.mockReturnValueOnce('/caches/test.bin');
+        const path = modelRegistry_1.ModelRegistry.getFilePath('test.bin');
+        expect(react_native_nitro_modules_1.mockModelStore.getFilePath).toHaveBeenCalledWith('test.bin');
+        expect(path).toBe('/caches/test.bin');
+    });
+    it('listCachedFiles should delegate to native', () => {
+        const mockFiles = [
+            {
+                fileName: 'model.bin',
+                absolutePath: '/caches/model.bin',
+                sizeBytes: 1000,
+                lastModifiedMs: 12345,
+            },
+        ];
+        react_native_nitro_modules_1.mockModelStore.listCachedFiles.mockReturnValueOnce(mockFiles);
+        const files = modelRegistry_1.ModelRegistry.listCachedFiles();
+        expect(react_native_nitro_modules_1.mockModelStore.listCachedFiles).toHaveBeenCalled();
+        expect(files).toEqual(mockFiles);
+    });
+    it('deleteFile should delegate delete to native', () => {
+        modelRegistry_1.ModelRegistry.deleteFile('https://example.com/model.bin?q=1');
+        expect(react_native_nitro_modules_1.mockModelStore.deleteFile).toHaveBeenCalledWith('model.bin');
+    });
+    it('resolveModel should throw error on HTTP urls', async () => {
+        await expect(modelRegistry_1.ModelRegistry.resolveModel('http://example.com/model.bin'))
+            .rejects.toThrow('Insecure HTTP URLs are not allowed for model downloads');
+    });
+    it('resolveModel should download HTTPS urls', async () => {
+        react_native_nitro_modules_1.mockModelStore.downloadFile.mockResolvedValueOnce('/downloaded/model.bin');
+        const path = await modelRegistry_1.ModelRegistry.resolveModel('https://example.com/model.bin', {
+            headers: { Authorization: 'Bearer test' },
+        });
+        expect(react_native_nitro_modules_1.mockModelStore.downloadFile).toHaveBeenCalledWith('https://example.com/model.bin', 'model.bin', JSON.stringify({ Authorization: 'Bearer test' }), expect.any(Function));
+        expect(path).toBe('/downloaded/model.bin');
+    });
+    it('resolveModel should return local paths directly', async () => {
+        const path = await modelRegistry_1.ModelRegistry.resolveModel('/local/path/model.bin');
+        expect(react_native_nitro_modules_1.mockModelStore.downloadFile).not.toHaveBeenCalled();
+        expect(path).toBe('/local/path/model.bin');
+    });
+    it('resolveModel should strip file:// prefix from local paths', async () => {
+        const path = await modelRegistry_1.ModelRegistry.resolveModel('file:///local/path/model.bin');
+        expect(react_native_nitro_modules_1.mockModelStore.downloadFile).not.toHaveBeenCalled();
+        expect(path).toBe('/local/path/model.bin');
+    });
+});

package/lib/hooks.d.ts

@@ -0,0 +1,46 @@
+import { LLMConfig } from "./index";
+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: LiteRTLMInstance | null;
+    isReady: boolean;
+    isGenerating: boolean;
+    downloadProgress: number;
+    error: string | null;
+    generate: (prompt: string) => Promise<import("./specs/LiteRTLM.nitro").ExecuteResult>;
+    reset: () => 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;
+}
+export declare function useModel(pathOrUrl: string, config?: UseModelConfig): UseModelResult;