react-native-executorch 0.5.6 → 0.5.8

package/lib/utils/ResourceFetcher.js

@@ -0,0 +1,305 @@
+/**
+ * Resource Fetcher
+ *
+ * Provides an interface for downloading files (via `ResourceFetcher.fetch()`)
+ *
+ * Key functionality:
+ * - Download control: pause, resume, and cancel operations through:
+ *   - Single file: `.pauseFetching()`, `.resumeFetching()`, `.cancelFetching()`
+ * - Downloaded file management:
+ *   -  `.getFilesTotalSize()`, `.listDownloadedFiles()`, `.listDownloadedModels()`, `.deleteResources()`
+ *
+ * Remark: The pausing/resuming/canceling works only for fetching remote resources.
+ *
+ * Most exported functions accept:
+ * - Multiple `ResourceSource` arguments, (union type of string, number or object)
+ *
+ * Method `.fetch()` takes argument as callback that reports download progress.
+ * Method`.fetch()` returns array of paths to successfully saved files or null if the download was paused or cancelled  (then resume functions can return paths).
+ *
+ * Technical Implementation:
+ * - Maintains a `downloads` Map instance that tracks:
+ *   - Currently downloading resources
+ *   - Paused downloads
+ * - Successful downloads are automatically removed from the `downloads` Map
+ * - Uses the `ResourceSourceExtended` interface to enable pause/resume functionality:
+ *   - Wraps user-provided `ResourceSource` elements
+ *   - Implements linked list behavior via the `.next` attribute
+ *   - Automatically processes subsequent downloads when `.next` contains a valid resource
+ */
+import { cacheDirectory, createDownloadResumable, moveAsync, FileSystemSessionType, writeAsStringAsync, EncodingType, deleteAsync, readDirectoryAsync, } from 'expo-file-system';
+import { Asset } from 'expo-asset';
+import { RNEDirectory } from '../constants/directories';
+import { ResourceFetcherUtils, } from './ResourceFetcherUtils';
+export class ResourceFetcher {
+    static downloads = new Map(); //map of currently downloading (or paused) files, if the download was started by .fetch() method.
+    static async fetch(callback = () => { }, ...sources) {
+        if (sources.length === 0) {
+            throw new Error('Empty list given as an argument!');
+        }
+        const { results: info, totalLength } = await ResourceFetcherUtils.getFilesSizes(sources);
+        const head = {
+            source: info[0].source,
+            sourceType: info[0].type,
+            callback: info[0].type === 4 /* SourceType.REMOTE_FILE */
+                ? ResourceFetcherUtils.calculateDownloadProgress(totalLength, info[0].previousFilesTotalLength, info[0].length, callback)
+                : () => { },
+            results: [],
+        };
+        let node = head;
+        for (let idx = 1; idx < sources.length; idx++) {
+            node.next = {
+                source: info[idx].source,
+                sourceType: info[idx].type,
+                callback: info[idx].type === 4 /* SourceType.REMOTE_FILE */
+                    ? ResourceFetcherUtils.calculateDownloadProgress(totalLength, info[idx].previousFilesTotalLength, info[idx].length, callback)
+                    : () => { },
+                results: [],
+            };
+            node = node.next;
+        }
+        return this.singleFetch(head);
+    }
+    static async singleFetch(sourceExtended) {
+        const source = sourceExtended.source;
+        switch (sourceExtended.sourceType) {
+            case 0 /* SourceType.OBJECT */: {
+                return this.returnOrStartNext(sourceExtended, await this.handleObject(source));
+            }
+            case 1 /* SourceType.LOCAL_FILE */: {
+                return this.returnOrStartNext(sourceExtended, this.handleLocalFile(source));
+            }
+            case 2 /* SourceType.RELEASE_MODE_FILE */: {
+                return this.returnOrStartNext(sourceExtended, await this.handleReleaseModeFile(sourceExtended));
+            }
+            case 3 /* SourceType.DEV_MODE_FILE */: {
+                const result = await this.handleDevModeFile(sourceExtended);
+                if (result !== null) {
+                    return this.returnOrStartNext(sourceExtended, result);
+                }
+                return null;
+            }
+            default: {
+                //case SourceType.REMOTE_FILE
+                const result = await this.handleRemoteFile(sourceExtended);
+                if (result !== null) {
+                    return this.returnOrStartNext(sourceExtended, result);
+                }
+                return null;
+            }
+        }
+    }
+    //if any download ends successfully this function is called - it checks whether it should trigger next download or return list of paths.
+    static returnOrStartNext(sourceExtended, result) {
+        sourceExtended.results.push(result);
+        if (sourceExtended.next) {
+            const nextSource = sourceExtended.next;
+            nextSource.results.push(...sourceExtended.results);
+            return this.singleFetch(nextSource);
+        }
+        sourceExtended.callback(1);
+        return sourceExtended.results;
+    }
+    static async pause(source) {
+        const resource = this.downloads.get(source);
+        switch (resource.status) {
+            case 1 /* DownloadStatus.PAUSED */:
+                throw new Error("The file download is currently paused. Can't pause the download of the same file twice.");
+            default: {
+                resource.status = 1 /* DownloadStatus.PAUSED */;
+                await resource.downloadResumable.pauseAsync();
+            }
+        }
+    }
+    static async resume(source) {
+        const resource = this.downloads.get(source);
+        if (!resource.extendedInfo.fileUri ||
+            !resource.extendedInfo.cacheFileUri ||
+            !resource.extendedInfo.uri) {
+            throw new Error('Something went wrong. File uri info is not specified!');
+        }
+        switch (resource.status) {
+            case 0 /* DownloadStatus.ONGOING */:
+                throw new Error("The file download is currently ongoing. Can't resume the ongoing download.");
+            default: {
+                resource.status = 0 /* DownloadStatus.ONGOING */;
+                const result = await resource.downloadResumable.resumeAsync();
+                if (!this.downloads.has(source) ||
+                    this.downloads.get(source).status === 1 /* DownloadStatus.PAUSED */) {
+                    //if canceled or paused after earlier resuming.
+                    return null;
+                }
+                if (!result ||
+                    (result.status !== 200 /* HTTP_CODE.OK */ &&
+                        result.status !== 206 /* HTTP_CODE.PARTIAL_CONTENT */)) {
+                    throw new Error(`Failed to fetch resource from '${resource.extendedInfo.uri}'`);
+                }
+                await moveAsync({
+                    from: resource.extendedInfo.cacheFileUri,
+                    to: resource.extendedInfo.fileUri,
+                });
+                this.downloads.delete(source);
+                ResourceFetcherUtils.triggerHuggingFaceDownloadCounter(resource.extendedInfo.uri);
+                return this.returnOrStartNext(resource.extendedInfo, ResourceFetcherUtils.removeFilePrefix(resource.extendedInfo.fileUri));
+            }
+        }
+    }
+    static async cancel(source) {
+        const resource = this.downloads.get(source);
+        await resource.downloadResumable.cancelAsync();
+        this.downloads.delete(source);
+    }
+    static async pauseFetching(...sources) {
+        const source = this.findActive(sources);
+        await this.pause(source);
+    }
+    static async resumeFetching(...sources) {
+        const source = this.findActive(sources);
+        await this.resume(source);
+    }
+    static async cancelFetching(...sources) {
+        const source = this.findActive(sources);
+        await this.cancel(source);
+    }
+    static findActive(sources) {
+        for (const source of sources) {
+            if (this.downloads.has(source)) {
+                return source;
+            }
+        }
+        throw new Error('None of given sources are currently during downloading process.');
+    }
+    static async listDownloadedFiles() {
+        const files = await readDirectoryAsync(RNEDirectory);
+        return files.map((file) => `${RNEDirectory}${file}`);
+    }
+    static async listDownloadedModels() {
+        const files = await this.listDownloadedFiles();
+        return files.filter((file) => file.endsWith('.pte'));
+    }
+    static async deleteResources(...sources) {
+        for (const source of sources) {
+            const filename = ResourceFetcherUtils.getFilenameFromUri(source);
+            const fileUri = `${RNEDirectory}${filename}`;
+            if (await ResourceFetcherUtils.checkFileExists(fileUri)) {
+                await deleteAsync(fileUri);
+            }
+        }
+    }
+    static async getFilesTotalSize(...sources) {
+        return (await ResourceFetcherUtils.getFilesSizes(sources)).totalLength;
+    }
+    static async handleObject(source) {
+        if (typeof source !== 'object') {
+            throw new Error('Source is expected to be object!');
+        }
+        const jsonString = JSON.stringify(source);
+        const digest = ResourceFetcherUtils.hashObject(jsonString);
+        const filename = `${digest}.json`;
+        const path = `${RNEDirectory}${filename}`;
+        if (await ResourceFetcherUtils.checkFileExists(path)) {
+            return ResourceFetcherUtils.removeFilePrefix(path);
+        }
+        await ResourceFetcherUtils.createDirectoryIfNoExists();
+        await writeAsStringAsync(path, jsonString, {
+            encoding: EncodingType.UTF8,
+        });
+        return ResourceFetcherUtils.removeFilePrefix(path);
+    }
+    static handleLocalFile(source) {
+        if (typeof source !== 'string') {
+            throw new Error('Source is expected to be string.');
+        }
+        return ResourceFetcherUtils.removeFilePrefix(source);
+    }
+    static async handleReleaseModeFile(sourceExtended) {
+        const source = sourceExtended.source;
+        if (typeof source !== 'number') {
+            throw new Error('Source is expected to be string.');
+        }
+        const asset = Asset.fromModule(source);
+        const uri = asset.uri;
+        const filename = ResourceFetcherUtils.getFilenameFromUri(uri);
+        const fileUri = `${RNEDirectory}${filename}`;
+        const fileUriWithType = `${fileUri}.${asset.type}`;
+        if (await ResourceFetcherUtils.checkFileExists(fileUri)) {
+            return ResourceFetcherUtils.removeFilePrefix(fileUri);
+        }
+        await ResourceFetcherUtils.createDirectoryIfNoExists();
+        await asset.downloadAsync();
+        if (!asset.localUri) {
+            throw new Error(`Asset local URI is not available for ${source}`);
+        }
+        await moveAsync({ from: asset.localUri, to: fileUriWithType });
+        return ResourceFetcherUtils.removeFilePrefix(fileUriWithType);
+    }
+    static async handleDevModeFile(sourceExtended) {
+        const source = sourceExtended.source;
+        if (typeof source !== 'number') {
+            throw new Error('Source is expected to be a number.');
+        }
+        sourceExtended.uri = Asset.fromModule(source).uri;
+        return await this.handleRemoteFile(sourceExtended);
+    }
+    static async handleRemoteFile(sourceExtended) {
+        const source = sourceExtended.source;
+        if (typeof source === 'object') {
+            throw new Error('Source is expected to be a string or a number.');
+        }
+        if (this.downloads.has(source)) {
+            const resource = this.downloads.get(source);
+            if (resource.status === 1 /* DownloadStatus.PAUSED */) {
+                // if the download is paused, `fetch` is treated like `resume`
+                this.resume(source);
+            }
+            // if the download is ongoing, throw error.
+            throw new Error('Already downloading this file.');
+        }
+        if (typeof source === 'number' && !sourceExtended.uri) {
+            throw new Error('Source Uri is expected to be available here.');
+        }
+        if (typeof source === 'string') {
+            sourceExtended.uri = source;
+        }
+        const uri = sourceExtended.uri;
+        const filename = ResourceFetcherUtils.getFilenameFromUri(uri);
+        sourceExtended.fileUri = `${RNEDirectory}${filename}`;
+        sourceExtended.cacheFileUri = `${cacheDirectory}${filename}`;
+        if (await ResourceFetcherUtils.checkFileExists(sourceExtended.fileUri)) {
+            return ResourceFetcherUtils.removeFilePrefix(sourceExtended.fileUri);
+        }
+        await ResourceFetcherUtils.createDirectoryIfNoExists();
+        const downloadResumable = createDownloadResumable(uri, sourceExtended.cacheFileUri, { sessionType: FileSystemSessionType.BACKGROUND }, ({ totalBytesWritten, totalBytesExpectedToWrite }) => {
+            if (totalBytesExpectedToWrite === -1) {
+                // If totalBytesExpectedToWrite is -1, it means the server does not provide content length.
+                sourceExtended.callback(0);
+                return;
+            }
+            sourceExtended.callback(totalBytesWritten / totalBytesExpectedToWrite);
+        });
+        //create value for the this.download Map
+        const downloadResource = {
+            downloadResumable: downloadResumable,
+            status: 0 /* DownloadStatus.ONGOING */,
+            extendedInfo: sourceExtended,
+        };
+        //add key-value pair to map
+        this.downloads.set(source, downloadResource);
+        const result = await downloadResumable.downloadAsync();
+        if (!this.downloads.has(source) ||
+            this.downloads.get(source).status === 1 /* DownloadStatus.PAUSED */) {
+            // if canceled or paused during the download
+            return null;
+        }
+        if (!result || result.status !== 200 /* HTTP_CODE.OK */) {
+            throw new Error(`Failed to fetch resource from '${source}'`);
+        }
+        await moveAsync({
+            from: sourceExtended.cacheFileUri,
+            to: sourceExtended.fileUri,
+        });
+        this.downloads.delete(source);
+        ResourceFetcherUtils.triggerHuggingFaceDownloadCounter(uri);
+        return ResourceFetcherUtils.removeFilePrefix(sourceExtended.fileUri);
+    }
+}

package/lib/utils/ResourceFetcherUtils.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @internal
+ */
+import { DownloadResumable } from 'expo-file-system';
+import { ResourceSource } from '../types/common';
+export declare const enum HTTP_CODE {
+    OK = 200,
+    PARTIAL_CONTENT = 206
+}
+export declare const enum DownloadStatus {
+    ONGOING = 0,
+    PAUSED = 1
+}
+export declare const enum SourceType {
+    OBJECT = 0,
+    LOCAL_FILE = 1,
+    RELEASE_MODE_FILE = 2,
+    DEV_MODE_FILE = 3,
+    REMOTE_FILE = 4
+}
+export interface ResourceSourceExtended {
+    source: ResourceSource;
+    sourceType: SourceType;
+    callback?: (downloadProgress: number) => void;
+    results: string[];
+    uri?: string;
+    fileUri?: string;
+    cacheFileUri?: string;
+    next?: ResourceSourceExtended;
+}
+export interface DownloadResource {
+    downloadResumable: DownloadResumable;
+    status: DownloadStatus;
+    extendedInfo: ResourceSourceExtended;
+}
+export declare namespace ResourceFetcherUtils {
+    function getType(source: ResourceSource): SourceType;
+    function getFilesSizes(sources: ResourceSource[]): Promise<{
+        results: {
+            source: ResourceSource;
+            type: SourceType;
+            length: number;
+            previousFilesTotalLength: number;
+        }[];
+        totalLength: number;
+    }>;
+    function removeFilePrefix(uri: string): string;
+    function hashObject(jsonString: string): string;
+    function calculateDownloadProgress(totalLength: number, previousFilesTotalLength: number, currentFileLength: number, setProgress: (downloadProgress: number) => void): (progress: number) => void;
+    function triggerHuggingFaceDownloadCounter(uri: string): Promise<void>;
+    function createDirectoryIfNoExists(): Promise<void>;
+    function checkFileExists(fileUri: string): Promise<boolean>;
+    function getFilenameFromUri(uri: string): string;
+}

package/lib/utils/ResourceFetcherUtils.js

@@ -0,0 +1,127 @@
+/**
+ * @internal
+ */
+import { getInfoAsync, makeDirectoryAsync, } from 'expo-file-system';
+import { RNEDirectory } from '../constants/directories';
+import { Asset } from 'expo-asset';
+import { Logger } from '../common/Logger';
+export var ResourceFetcherUtils;
+(function (ResourceFetcherUtils) {
+    function getType(source) {
+        if (typeof source === 'object') {
+            return 0 /* SourceType.OBJECT */;
+        }
+        else if (typeof source === 'number') {
+            const uri = Asset.fromModule(source).uri;
+            if (!uri.includes('://')) {
+                return 2 /* SourceType.RELEASE_MODE_FILE */;
+            }
+            return 3 /* SourceType.DEV_MODE_FILE */;
+        }
+        else {
+            // typeof source == 'string'
+            if (source.startsWith('file://')) {
+                return 1 /* SourceType.LOCAL_FILE */;
+            }
+            return 4 /* SourceType.REMOTE_FILE */;
+        }
+    }
+    ResourceFetcherUtils.getType = getType;
+    async function getFilesSizes(sources) {
+        const results = [];
+        let totalLength = 0;
+        let previousFilesTotalLength = 0;
+        for (const source of sources) {
+            const type = await ResourceFetcherUtils.getType(source);
+            let length = 0;
+            if (type === 4 /* SourceType.REMOTE_FILE */ && typeof source === 'string') {
+                try {
+                    const response = await fetch(source, { method: 'HEAD' });
+                    if (!response.ok) {
+                        Logger.warn(`Failed to fetch HEAD for ${source}: ${response.status}`);
+                        continue;
+                    }
+                    const contentLength = response.headers.get('content-length');
+                    if (!contentLength) {
+                        Logger.warn(`No content-length header for ${source}`);
+                    }
+                    length = contentLength ? parseInt(contentLength, 10) : 0;
+                    previousFilesTotalLength = totalLength;
+                    totalLength += length;
+                }
+                catch (error) {
+                    Logger.warn(`Error fetching HEAD for ${source}:`, error);
+                    continue;
+                }
+            }
+            results.push({ source, type, length, previousFilesTotalLength });
+        }
+        return { results, totalLength };
+    }
+    ResourceFetcherUtils.getFilesSizes = getFilesSizes;
+    function removeFilePrefix(uri) {
+        return uri.startsWith('file://') ? uri.slice(7) : uri;
+    }
+    ResourceFetcherUtils.removeFilePrefix = removeFilePrefix;
+    function hashObject(jsonString) {
+        let hash = 0;
+        for (let i = 0; i < jsonString.length; i++) {
+            // eslint-disable-next-line no-bitwise
+            hash = (hash << 5) - hash + jsonString.charCodeAt(i);
+            // eslint-disable-next-line no-bitwise
+            hash |= 0;
+        }
+        // eslint-disable-next-line no-bitwise
+        return (hash >>> 0).toString();
+    }
+    ResourceFetcherUtils.hashObject = hashObject;
+    function calculateDownloadProgress(totalLength, previousFilesTotalLength, currentFileLength, setProgress) {
+        return (progress) => {
+            if (progress === 1 &&
+                previousFilesTotalLength === totalLength - currentFileLength) {
+                setProgress(1);
+                return;
+            }
+            // Avoid division by zero
+            if (totalLength === 0) {
+                setProgress(0);
+                return;
+            }
+            const baseProgress = previousFilesTotalLength / totalLength;
+            const scaledProgress = progress * (currentFileLength / totalLength);
+            const updatedProgress = baseProgress + scaledProgress;
+            setProgress(updatedProgress);
+        };
+    }
+    ResourceFetcherUtils.calculateDownloadProgress = calculateDownloadProgress;
+    /*
+     * Increments the Hugging Face download counter if the URI points to a Software Mansion Hugging Face repo.
+     * More information: https://huggingface.co/docs/hub/models-download-stats
+     */
+    async function triggerHuggingFaceDownloadCounter(uri) {
+        const url = new URL(uri);
+        if (url.host === 'huggingface.co' &&
+            url.pathname.startsWith('/software-mansion/')) {
+            const baseUrl = `${url.protocol}//${url.host}${url.pathname.split('resolve')[0]}`;
+            fetch(`${baseUrl}resolve/main/config.json`, { method: 'HEAD' });
+        }
+    }
+    ResourceFetcherUtils.triggerHuggingFaceDownloadCounter = triggerHuggingFaceDownloadCounter;
+    async function createDirectoryIfNoExists() {
+        if (!(await checkFileExists(RNEDirectory))) {
+            await makeDirectoryAsync(RNEDirectory, { intermediates: true });
+        }
+    }
+    ResourceFetcherUtils.createDirectoryIfNoExists = createDirectoryIfNoExists;
+    async function checkFileExists(fileUri) {
+        const fileInfo = await getInfoAsync(fileUri);
+        return fileInfo.exists;
+    }
+    ResourceFetcherUtils.checkFileExists = checkFileExists;
+    function getFilenameFromUri(uri) {
+        let cleanUri = uri.replace(/^https?:\/\//, '');
+        cleanUri = cleanUri.split('#')?.[0] ?? cleanUri;
+        return cleanUri.replace(/[^a-zA-Z0-9._-]/g, '_');
+    }
+    ResourceFetcherUtils.getFilenameFromUri = getFilenameFromUri;
+})(ResourceFetcherUtils || (ResourceFetcherUtils = {}));

package/lib/utils/llm.d.ts

@@ -0,0 +1,6 @@
+import { ToolCall } from '../types/llm';
+import { Schema } from 'jsonschema';
+import * as zCore from 'zod/v4/core';
+export declare const parseToolCall: (message: string) => ToolCall[];
+export declare const getStructuredOutputPrompt: <T extends zCore.$ZodType>(responseSchema: T | Schema) => string;
+export declare const fixAndValidateStructuredOutput: <T extends zCore.$ZodType>(output: string, responseSchema: T | Schema) => zCore.output<T>;

package/lib/utils/llm.js

@@ -0,0 +1,72 @@
+import * as z from 'zod/v4';
+import { Validator } from 'jsonschema';
+import { jsonrepair } from 'jsonrepair';
+import { DEFAULT_STRUCTURED_OUTPUT_PROMPT } from '../constants/llmDefaults';
+import * as zCore from 'zod/v4/core';
+import { Logger } from '../common/Logger';
+export const parseToolCall = (message) => {
+    try {
+        const unparsedToolCalls = message.match('\\[(.|\\s)*\\]');
+        if (!unparsedToolCalls) {
+            throw Error('Regex did not match array.');
+        }
+        const parsedMessage = JSON.parse(unparsedToolCalls[0]);
+        const results = [];
+        for (const tool of parsedMessage) {
+            if ('name' in tool &&
+                typeof tool.name === 'string' &&
+                'arguments' in tool &&
+                tool.arguments !== null &&
+                typeof tool.arguments === 'object') {
+                results.push({
+                    toolName: tool.name,
+                    arguments: tool.arguments,
+                });
+            }
+        }
+        return results;
+    }
+    catch (e) {
+        Logger.error(e);
+        return [];
+    }
+};
+const filterObjectKeys = (obj, keysToRemove) => {
+    const entries = Object.entries(obj);
+    const filteredEntries = entries.filter(([key, _]) => !keysToRemove.includes(key));
+    return Object.fromEntries(filteredEntries);
+};
+export const getStructuredOutputPrompt = (responseSchema) => {
+    const schemaObject = responseSchema instanceof zCore.$ZodType
+        ? filterObjectKeys(z.toJSONSchema(responseSchema), [
+            '$schema',
+            'additionalProperties',
+        ])
+        : responseSchema;
+    const schemaString = JSON.stringify(schemaObject);
+    return DEFAULT_STRUCTURED_OUTPUT_PROMPT(schemaString);
+};
+const extractBetweenBrackets = (text) => {
+    const startIndex = text.search(/[\\{\\[]/); // First occurrence of either { or [
+    const openingBracket = text[startIndex];
+    const closingBracket = openingBracket === '{' ? '}' : ']';
+    if (!openingBracket)
+        throw Error("Couldn't find JSON in text");
+    return text.slice(text.indexOf(openingBracket), text.lastIndexOf(closingBracket) + 1);
+};
+// this is a bit hacky typing
+export const fixAndValidateStructuredOutput = (output, responseSchema) => {
+    const extractedOutput = extractBetweenBrackets(output);
+    const repairedOutput = jsonrepair(extractedOutput);
+    const outputJSON = JSON.parse(repairedOutput);
+    if (responseSchema instanceof zCore.$ZodType) {
+        return z.parse(responseSchema, outputJSON);
+    }
+    else {
+        const validator = new Validator();
+        validator.validate(outputJSON, responseSchema, {
+            throwAll: true,
+        });
+        return outputJSON;
+    }
+};

package/lib/utils/stt.js

@@ -0,0 +1,21 @@
+export const longCommonInfPref = (seq1, seq2, hammingDistThreshold) => {
+    let maxInd = 0;
+    let maxLength = 0;
+    for (let i = 0; i < seq1.length; i++) {
+        let j = 0;
+        let hammingDist = 0;
+        while (j < seq2.length &&
+            i + j < seq1.length &&
+            (seq1[i + j] === seq2[j] || hammingDist < hammingDistThreshold)) {
+            if (seq1[i + j] !== seq2[j]) {
+                hammingDist++;
+            }
+            j++;
+        }
+        if (j >= maxLength) {
+            maxLength = j;
+            maxInd = i;
+        }
+    }
+    return maxInd;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-executorch",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "description": "An easy way to run AI models in React Native with ExecuTorch",
   "source": "./src/index.ts",
   "main": "./lib/module/index.js",
@@ -17,6 +17,8 @@
     "*.podspec",
     "third-party/include",
     "third-party",
+    "!third-party/ios/ExecutorchLib",
+    "!third-party/ios/libs/executorch",
     "!ios/build",
     "!android/build",
     "!android/gradle",