react-native-onyx 3.0.119 → 3.0.121

package/dist/OnyxUtils.d.ts

@@ -122,16 +122,16 @@ declare function reportStorageQuota(error?: Error): Promise<void>;
  * The connection layer (createStore) owns connection/transport recovery; this operation layer owns
  * capacity recovery (eviction) so that a given failure is retried by exactly one layer:
  * - INVALID_DATA: logs an alert and throws (the same data will always fail).
- * - TRANSIENT / FATAL: the connection layer already retried (transient) or exhausted its heal budget
- *   and alerted (fatal). Retrying here would only re-amplify, so we skip the write quietly.
+ * - TRANSIENT / FATAL: the connection layer already retried (transient) or spent a heal attempt
+ *   (fatal). Retrying here would only re-amplify, so we skip the write quietly.
  * - CAPACITY: evicts the least recently accessed evictable key and retries, under a session-level
  *   circuit breaker (see lib/StorageCircuitBreaker.ts) that halts the loop once eviction stops making
  *   progress or failures storm — the per-operation budget alone cannot stop a session-wide storm.
  * - DISK_PRESSURE: the device disk itself is full (or the database files are unreadable), so neither
  *   retries nor in-DB eviction can free space — the write is dropped (cache stays authoritative) with
  *   a single throttled alert + quota snapshot per burst.
- * - UNAVAILABLE: the storage engine does not exist in this environment, so the storage layer has
- *   already degraded to the in-memory provider. No retry.
+ * - UNAVAILABLE: the storage engine does not exist in this environment or its heal budget ran out, so
+ *   the storage layer has already degraded to the in-memory provider. No retry.
  * - UNKNOWN: the provider couldn't classify it — log the full error shape (name + message +
  *   provider) once so it's visible, then bounded retry without eviction.
  */

package/dist/OnyxUtils.js

@@ -469,16 +469,16 @@ function reportStorageQuota(error) {
  * The connection layer (createStore) owns connection/transport recovery; this operation layer owns
  * capacity recovery (eviction) so that a given failure is retried by exactly one layer:
  * - INVALID_DATA: logs an alert and throws (the same data will always fail).
- * - TRANSIENT / FATAL: the connection layer already retried (transient) or exhausted its heal budget
- *   and alerted (fatal). Retrying here would only re-amplify, so we skip the write quietly.
+ * - TRANSIENT / FATAL: the connection layer already retried (transient) or spent a heal attempt
+ *   (fatal). Retrying here would only re-amplify, so we skip the write quietly.
  * - CAPACITY: evicts the least recently accessed evictable key and retries, under a session-level
  *   circuit breaker (see lib/StorageCircuitBreaker.ts) that halts the loop once eviction stops making
  *   progress or failures storm — the per-operation budget alone cannot stop a session-wide storm.
  * - DISK_PRESSURE: the device disk itself is full (or the database files are unreadable), so neither
  *   retries nor in-DB eviction can free space — the write is dropped (cache stays authoritative) with
  *   a single throttled alert + quota snapshot per burst.
- * - UNAVAILABLE: the storage engine does not exist in this environment, so the storage layer has
- *   already degraded to the in-memory provider. No retry.
+ * - UNAVAILABLE: the storage engine does not exist in this environment or its heal budget ran out, so
+ *   the storage layer has already degraded to the in-memory provider. No retry.
  * - UNKNOWN: the provider couldn't classify it — log the full error shape (name + message +
  *   provider) once so it's visible, then bounded retry without eviction.
  */
@@ -752,6 +752,9 @@ function initializeWithDefaultKeyStates() {
     })
         .catch((error) => {
         Logger.logAlert(`Failed to load data from storage during init. The app will boot with default key states only. Error: ${error}`);
+        if (storage_1.default.classifyError(error) === errors_1.StorageErrorClass.FATAL) {
+            storage_1.default.degradeToMemoryOnly(error);
+        }
         // Populate the key index so getAllKeys() returns correct results for default keys.
         // Without this, subscribers that check getAllKeys() would see an empty set even
         // though we have default values in cache.

package/dist/storage/__mocks__/index.d.ts

@@ -12,6 +12,7 @@ declare const StorageMock: {
     getStorageProvider: jest.Mock<import("../providers/types").default<{
         [x: string]: unknown;
     }>, [], any>;
+    degradeToMemoryOnly: jest.Mock<any, any, any>;
     getItem: jest.Mock<Promise<unknown>, [key: any], any>;
     multiGet: jest.Mock<Promise<import("../providers/types").StorageKeyValuePair[]>, [keys: import("../providers/types").StorageKeyList], any>;
     setItem: jest.Mock<Promise<void>, [key: any, value: unknown], any>;

package/dist/storage/__mocks__/index.js

@@ -53,6 +53,7 @@ const StorageMock = {
     init,
     classifyError: jest.fn(classifyError),
     getStorageProvider: jest.fn(() => MemoryOnlyProvider_1.default),
+    degradeToMemoryOnly: jest.fn(),
     getItem: jest.fn(MemoryOnlyProvider_1.default.getItem),
     multiGet: jest.fn(MemoryOnlyProvider_1.default.multiGet),
     setItem: jest.fn(MemoryOnlyProvider_1.default.setItem),

package/dist/storage/errors.d.ts

@@ -22,12 +22,12 @@ declare const StorageErrorClass: {
     readonly DISK_PRESSURE: "diskPressure";
     /** Non-serializable payload. Never retriable — the same data will always fail. */
     readonly INVALID_DATA: "invalidData";
-    /** Backing-store corruption. Owner: connection layer — budgeted heal, then give up. */
+    /** Backing-store corruption. Owner: connection layer — budgeted heal, then rethrow as UNAVAILABLE. */
     readonly FATAL: "fatal";
     /** The storage engine itself does not exist in this environment (for example `indexedDB` is an
-     *  undeclared global in Chrome for iOS private tabs and in Lockdown Mode). Never retriable — the
-     *  engine cannot appear mid-session. Owner: the storage layer — degrade
-     *  to the in-memory provider. */
+     *  undeclared global in Chrome for iOS private tabs and in Lockdown Mode), or a FATAL heal budget
+     *  ran out. Never retriable — the engine cannot recover mid-session. Owner: the storage layer —
+     *  degrade to the in-memory provider. */
     readonly UNAVAILABLE: "unavailable";
     /** Unmatched by the active provider. Owner: operation layer — bounded retry, and log the shape so
      *  recurring cases can be promoted into one of the classes above. */

package/dist/storage/errors.js

@@ -26,12 +26,12 @@ const StorageErrorClass = {
     DISK_PRESSURE: 'diskPressure',
     /** Non-serializable payload. Never retriable — the same data will always fail. */
     INVALID_DATA: 'invalidData',
-    /** Backing-store corruption. Owner: connection layer — budgeted heal, then give up. */
+    /** Backing-store corruption. Owner: connection layer — budgeted heal, then rethrow as UNAVAILABLE. */
     FATAL: 'fatal',
     /** The storage engine itself does not exist in this environment (for example `indexedDB` is an
-     *  undeclared global in Chrome for iOS private tabs and in Lockdown Mode). Never retriable — the
-     *  engine cannot appear mid-session. Owner: the storage layer — degrade
-     *  to the in-memory provider. */
+     *  undeclared global in Chrome for iOS private tabs and in Lockdown Mode), or a FATAL heal budget
+     *  ran out. Never retriable — the engine cannot recover mid-session. Owner: the storage layer —
+     *  degrade to the in-memory provider. */
     UNAVAILABLE: 'unavailable',
     /** Unmatched by the active provider. Owner: operation layer — bounded retry, and log the shape so
      *  recurring cases can be promoted into one of the classes above. */

package/dist/storage/index.d.ts

@@ -1,6 +1,7 @@
 import type StorageProvider from './providers/types';
 type Storage = {
     getStorageProvider: () => StorageProvider<unknown>;
+    degradeToMemoryOnly: (error: unknown) => void;
 } & Omit<StorageProvider<unknown>, 'name' | 'store'>;
 declare const storage: Storage;
 export default storage;

package/dist/storage/index.js

@@ -56,6 +56,9 @@ const initPromise = new Promise((resolve) => {
  * Degrade performance by removing the storage provider and only using cache
  */
 function degradePerformance(error) {
+    if (provider === MemoryOnlyProvider_1.default) {
+        return;
+    }
     let causeMessage = '';
     if (error.cause instanceof Error) {
         causeMessage = error.cause.message;
@@ -95,6 +98,7 @@ const storage = {
     getStorageProvider() {
         return provider;
     },
+    degradeToMemoryOnly: (error) => degradePerformance(error instanceof Error ? error : new Error(String(error))),
     /**
      * Classifies a write error using the platform provider's own classifier. Synchronous and pure —
      * never wrapped in tryOrDegradePerformance.
@@ -212,7 +216,12 @@ const storage = {
         if (!InstanceSync_1.default.shouldBeUsed)
             return;
         shouldKeepInstancesSync = true;
-        InstanceSync_1.default.init(onStorageKeysChanged, this);
+        InstanceSync_1.default.init((pairs) => {
+            if (provider === MemoryOnlyProvider_1.default) {
+                return;
+            }
+            onStorageKeysChanged(pairs);
+        }, this);
     },
 };
 exports.default = storage;

package/dist/storage/providers/IDBKeyValProvider/classifyError.js

@@ -1,7 +1,40 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 const errors_1 = require("../../errors");
-const isIndexedDBAvailable_1 = require("./isIndexedDBAvailable");
+const errorMessages_1 = __importStar(require("./errorMessages"));
 /**
  * Classifies an IndexedDB write failure into the shared storage taxonomy (lib/storage/errors.ts).
  * Matching is done on the lowercased error name and message. This is the IndexedDB engine's own
@@ -10,7 +43,11 @@ const isIndexedDBAvailable_1 = require("./isIndexedDBAvailable");
 function classifyIDBError(error) {
     const { name, message } = (0, errors_1.getErrorParts)(error);
     // The engine is absent, not broken e.g. private tabs and Lockdown Mode on WebKit.
-    if (message.includes("can't find variable: indexeddb") || message.includes('indexeddb is not defined') || message.includes(isIndexedDBAvailable_1.INDEXED_DB_UNAVAILABLE_MESSAGE.toLowerCase())) {
+    if (message.includes("can't find variable: indexeddb") || message.includes('indexeddb is not defined') || message.includes(errorMessages_1.default.UNAVAILABLE.toLowerCase())) {
+        return errors_1.StorageErrorClass.UNAVAILABLE;
+    }
+    // Reopen budget spent on FATAL errors, so the store is treated as gone for the rest of the session.
+    if (name === errorMessages_1.IDBErrorName.HEAL_EXHAUSTED.toLowerCase()) {
         return errors_1.StorageErrorClass.UNAVAILABLE;
     }
     // Non-serializable data passed to IDBObjectStore.put — retrying is futile.

package/dist/storage/providers/IDBKeyValProvider/createStore.js

@@ -40,7 +40,8 @@ const IDB = __importStar(require("idb-keyval"));
 const Logger = __importStar(require("../../../Logger"));
 const errors_1 = require("../../errors");
 const classifyError_1 = __importDefault(require("./classifyError"));
-const isIndexedDBAvailable_1 = __importStar(require("./isIndexedDBAvailable"));
+const errorMessages_1 = __importStar(require("./errorMessages"));
+const isIndexedDBAvailable_1 = __importDefault(require("./isIndexedDBAvailable"));
 const HEAL_ATTEMPTS_MAX = 3;
 // This is a copy of the createStore function from idb-keyval, we need a custom implementation
 // because we need to create the database manually in order to ensure that the store exists before we use it.
@@ -90,7 +91,7 @@ function createStore(dbName, storeName) {
         if (dbp)
             return dbp;
         if (!(0, isIndexedDBAvailable_1.default)()) {
-            return Promise.reject(new Error(isIndexedDBAvailable_1.INDEXED_DB_UNAVAILABLE_MESSAGE));
+            return Promise.reject(new Error(errorMessages_1.default.UNAVAILABLE));
         }
         const request = indexedDB.open(dbName);
         request.onupgradeneeded = () => request.result.createObjectStore(storeName);
@@ -218,12 +219,17 @@ function createStore(dbName, storeName) {
             });
         }
         if (errorClass === errors_1.StorageErrorClass.FATAL) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
             Logger.logAlert('IDB heal: backing store error — heal budget exhausted, giving up', {
                 dbName,
                 storeName,
+                errorMessage,
             });
+            const healExhaustedError = new Error(`${errorMessages_1.default.HEAL_EXHAUSTED}: ${errorMessage}`, { cause: error });
+            healExhaustedError.name = errorMessages_1.IDBErrorName.HEAL_EXHAUSTED;
+            throw healExhaustedError;
         }
-        else if (errorClass === errors_1.StorageErrorClass.UNKNOWN) {
+        if (errorClass === errors_1.StorageErrorClass.UNKNOWN) {
             // UNKNOWN — unexpected at this layer; record it so it's visible. CAPACITY is the
             // expected propagation path (the operation layer owns its logging, and suppresses it
             // entirely once the circuit breaker is open), so we do NOT log it here — doing so was a

package/dist/storage/providers/IDBKeyValProvider/errorMessages.d.ts

@@ -0,0 +1,11 @@
+/** Messages of errors thrown by the IndexedDB provider itself. `classifyIDBError` maps `UNAVAILABLE` to `StorageErrorClass.UNAVAILABLE`. */
+declare const IDBErrorMessage: {
+    readonly UNAVAILABLE: "IndexedDB is not available in this environment";
+    readonly HEAL_EXHAUSTED: "IndexedDB heal budget exhausted";
+};
+/** Names of errors thrown by the IndexedDB provider itself. `classifyIDBError` maps `HEAL_EXHAUSTED` to `StorageErrorClass.UNAVAILABLE`. */
+declare const IDBErrorName: {
+    readonly HEAL_EXHAUSTED: "IDBHealExhaustedError";
+};
+export default IDBErrorMessage;
+export { IDBErrorName };

package/dist/storage/providers/IDBKeyValProvider/errorMessages.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDBErrorName = void 0;
+/** Messages of errors thrown by the IndexedDB provider itself. `classifyIDBError` maps `UNAVAILABLE` to `StorageErrorClass.UNAVAILABLE`. */
+const IDBErrorMessage = {
+    UNAVAILABLE: 'IndexedDB is not available in this environment',
+    HEAL_EXHAUSTED: 'IndexedDB heal budget exhausted',
+};
+/** Names of errors thrown by the IndexedDB provider itself. `classifyIDBError` maps `HEAL_EXHAUSTED` to `StorageErrorClass.UNAVAILABLE`. */
+const IDBErrorName = {
+    HEAL_EXHAUSTED: 'IDBHealExhaustedError',
+};
+exports.IDBErrorName = IDBErrorName;
+exports.default = IDBErrorMessage;

package/dist/storage/providers/IDBKeyValProvider/index.js

@@ -40,7 +40,8 @@ const IDB = __importStar(require("idb-keyval"));
 const utils_1 = __importDefault(require("../../../utils"));
 const createStore_1 = __importDefault(require("./createStore"));
 const classifyError_1 = __importDefault(require("./classifyError"));
-const isIndexedDBAvailable_1 = __importStar(require("./isIndexedDBAvailable"));
+const errorMessages_1 = __importDefault(require("./errorMessages"));
+const isIndexedDBAvailable_1 = __importDefault(require("./isIndexedDBAvailable"));
 const DB_NAME = 'OnyxDB';
 const STORE_NAME = 'keyvaluepairs';
 /**
@@ -71,7 +72,7 @@ const provider = {
      */
     init() {
         if (!(0, isIndexedDBAvailable_1.default)()) {
-            throw new Error(`IDBKeyVal store could not be created: ${isIndexedDBAvailable_1.INDEXED_DB_UNAVAILABLE_MESSAGE}`);
+            throw new Error(`IDBKeyVal store could not be created: ${errorMessages_1.default.UNAVAILABLE}`);
         }
         const newIdbKeyValStore = (0, createStore_1.default)(DB_NAME, STORE_NAME);
         if (newIdbKeyValStore == null) {

package/dist/storage/providers/IDBKeyValProvider/isIndexedDBAvailable.d.ts

@@ -1,9 +1,6 @@
-/** Matched by `classifyIDBError` so a guarded failure classifies as UNAVAILABLE like an unguarded one. */
-declare const INDEXED_DB_UNAVAILABLE_MESSAGE = "indexedDB is not available in this environment";
 /**
  * `typeof` instead of `indexedDB === undefined`: on WebKit the global is undeclared in private tabs and
  * Lockdown Mode, so reading it throws a `ReferenceError` instead of evaluating to `undefined`.
  */
 declare function isIndexedDBAvailable(): boolean;
 export default isIndexedDBAvailable;
-export { INDEXED_DB_UNAVAILABLE_MESSAGE };

package/dist/storage/providers/IDBKeyValProvider/isIndexedDBAvailable.js

@@ -1,9 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.INDEXED_DB_UNAVAILABLE_MESSAGE = void 0;
-/** Matched by `classifyIDBError` so a guarded failure classifies as UNAVAILABLE like an unguarded one. */
-const INDEXED_DB_UNAVAILABLE_MESSAGE = 'indexedDB is not available in this environment';
-exports.INDEXED_DB_UNAVAILABLE_MESSAGE = INDEXED_DB_UNAVAILABLE_MESSAGE;
 /**
  * `typeof` instead of `indexedDB === undefined`: on WebKit the global is undeclared in private tabs and
  * Lockdown Mode, so reading it throws a `ReferenceError` instead of evaluating to `undefined`.

package/dist/storage/providers/SQLiteProvider.js

@@ -1,10 +1,44 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const react_native_nitro_sqlite_1 = require("react-native-nitro-sqlite");
 const react_native_device_info_1 = require("react-native-device-info");
+const Logger = __importStar(require("../../Logger"));
 const utils_1 = __importDefault(require("../../utils"));
 const classifySQLiteError_1 = __importDefault(require("./classifySQLiteError"));
 const DB_NAME = 'OnyxDB';
@@ -14,6 +48,28 @@ const COMPILE_OPTIONS = {
 };
 /** SQLite's maximum number of bound parameters per statement, read once from PRAGMA compile_options in init(). */
 let sqliteMaxVariableNumber = SQLITE_MAX_VARIABLE_NUMBER;
+let readStore;
+let getItemStatement;
+let setItemStatement;
+let removeItemStatement;
+let pendingWrite = Promise.resolve();
+let pendingWriteCount = 0;
+function trackWrite(operation) {
+    // All writes use the same NitroSQLite connection queue and finish in call order.
+    // A failed write still releases later reads; its caller receives the rejection.
+    pendingWriteCount++;
+    pendingWrite = operation.then(() => {
+        pendingWriteCount--;
+    }, () => {
+        pendingWriteCount--;
+    });
+    return operation;
+}
+function readAfterPendingWrites(read) {
+    // Capture the writes already queued when the read was requested. New writes can run
+    // alongside this read on the separate connection once those writes have committed.
+    return pendingWriteCount === 0 ? read() : pendingWrite.then(read);
+}
 /**
  * Returns the value of a compile option from the rows returned by `PRAGMA compile_options`.
  * For flag-only options (e.g. `ENABLE_FTS3`), returns an empty string when the option is present.
@@ -61,13 +117,16 @@ const provider = {
      */
     name: 'SQLiteProvider',
     /**
-     * Classifies a SQLite write failure into the shared storage taxonomy.
+     * Classifies a SQLite failure into the shared storage taxonomy.
      */
     classifyError: classifySQLiteError_1.default,
     /**
      * Initializes the storage provider
      */
     init() {
+        if (provider.store) {
+            return;
+        }
         provider.store = (0, react_native_nitro_sqlite_1.open)({ name: DB_NAME });
         provider.store.execute('CREATE TABLE IF NOT EXISTS keyvaluepairs (record_key TEXT NOT NULL PRIMARY KEY , valueJSON JSON NOT NULL) WITHOUT ROWID;');
         // All of the 3 pragmas below were suggested by SQLite team.
@@ -80,12 +139,45 @@ const provider = {
         // stores it in a global variable, that is going to be used during runtime.
         const maxVariableNumber = Number(getCompileOptionValue(compileOptionsResult, COMPILE_OPTIONS.MAX_VARIABLE_NUMBER));
         sqliteMaxVariableNumber = maxVariableNumber > 0 ? maxVariableNumber : SQLITE_MAX_VARIABLE_NUMBER;
+        setItemStatement = provider.store.prepare('REPLACE INTO keyvaluepairs (record_key, valueJSON) VALUES (?, ?);');
+        removeItemStatement = provider.store.prepare('DELETE FROM keyvaluepairs WHERE record_key = ?;');
+        let independentReader;
+        try {
+            // WAL lets the read-only handle read committed data while the writer is active.
+            independentReader = (0, react_native_nitro_sqlite_1.open)({ name: DB_NAME, connection: 'independent', readOnly: true });
+            // Cache size is connection-local. WAL is shared, and synchronous only controls writes.
+            independentReader.execute('PRAGMA CACHE_SIZE=-8000;');
+            // Reads are not retried by Onyx; allow temporary WAL locks to clear.
+            independentReader.execute('PRAGMA busy_timeout=2000;');
+            getItemStatement = independentReader.prepare('SELECT record_key, valueJSON FROM keyvaluepairs WHERE record_key = ?;');
+            readStore = independentReader;
+        }
+        catch (error) {
+            // SQLite can report failures on first use, so protect all reader setup.
+            Logger.logInfo('SQLite independent reader unavailable, reading through the writer.', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            try {
+                independentReader === null || independentReader === void 0 ? void 0 : independentReader.close();
+            }
+            catch (cleanupError) {
+                // Reader cleanup must not prevent the writer from serving reads.
+                Logger.logInfo('SQLite independent reader cleanup failed.', {
+                    error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError),
+                });
+            }
+            readStore = provider.store;
+            getItemStatement = provider.store.prepare('SELECT record_key, valueJSON FROM keyvaluepairs WHERE record_key = ?;');
+        }
+        pendingWrite = Promise.resolve();
+        pendingWriteCount = 0;
     },
     getItem(key) {
-        if (!provider.store) {
+        const statement = getItemStatement;
+        if (!statement) {
             throw new Error('Store is not initialized!');
         }
-        return provider.store.executeAsync('SELECT record_key, valueJSON FROM keyvaluepairs WHERE record_key = ?;', [key]).then(({ rows }) => {
+        return readAfterPendingWrites(() => statement.executeAsync([key])).then(({ rows }) => {
             if (!rows || (rows === null || rows === void 0 ? void 0 : rows.length) === 0) {
                 return null;
             }
@@ -97,21 +189,27 @@ const provider = {
         });
     },
     multiGet(keys) {
-        if (!provider.store) {
+        if (!readStore) {
             throw new Error('Store is not initialized!');
         }
         if (keys.length === 0) {
             return Promise.resolve([]);
         }
         const keyChunks = utils_1.default.chunkArray(keys, sqliteMaxVariableNumber);
-        return Promise.all(keyChunks.map((keyChunk) => {
-            if (!provider.store) {
-                throw new Error('Store is not initialized!');
+        const reader = readStore;
+        const commands = keyChunks.map((keyChunk) => ({
+            query: `SELECT record_key, valueJSON FROM keyvaluepairs WHERE record_key IN (${keyChunk.map(() => '?').join(',')});`,
+            params: keyChunk,
+        }));
+        const readChunks = () => {
+            if (commands.length === 1) {
+                const { query, params } = commands[0];
+                return reader.executeAsync(query, params).then((result) => [result]);
             }
-            const placeholders = keyChunk.map(() => '?').join(',');
-            const command = `SELECT record_key, valueJSON FROM keyvaluepairs WHERE record_key IN (${placeholders});`;
-            return provider.store.executeAsync(command, keyChunk);
-        })).then((results) => {
+            // Keep all chunks on one snapshot even if the writer commits between queries.
+            return reader.transaction((tx) => Promise.all(commands.map(({ query, params }) => tx.executeAsync(query, params))));
+        };
+        return readAfterPendingWrites(readChunks).then((results) => {
             const result = results.flatMap(({ rows }) => { var _a; 
             // eslint-disable-next-line no-underscore-dangle
             return (_a = rows === null || rows === void 0 ? void 0 : rows._array.map((row) => [row.record_key, JSON.parse(row.valueJSON)])) !== null && _a !== void 0 ? _a : []; });
@@ -119,10 +217,10 @@ const provider = {
         });
     },
     setItem(key, value) {
-        if (!provider.store) {
+        if (!setItemStatement) {
             throw new Error('Store is not initialized!');
         }
-        return provider.store.executeAsync('REPLACE INTO keyvaluepairs (record_key, valueJSON) VALUES (?, ?);', [key, JSON.stringify(value)]).then(() => undefined);
+        return trackWrite(setItemStatement.executeAsync([key, JSON.stringify(value)]).then(() => undefined));
     },
     multiSet(pairs) {
         if (!provider.store) {
@@ -133,7 +231,7 @@ const provider = {
         if (utils_1.default.isEmptyObject(params)) {
             return Promise.resolve();
         }
-        return provider.store.executeBatchAsync([{ query, params }]).then(() => undefined);
+        return trackWrite(provider.store.executeBatchAsync([{ query, params }]).then(() => undefined));
     },
     multiMerge(pairs) {
         if (!provider.store) {
@@ -173,31 +271,31 @@ const provider = {
         if (replaceQueryArguments.length > 0) {
             commands.push({ query: replaceQuery, params: replaceQueryArguments });
         }
-        return provider.store.executeBatchAsync(commands).then(() => undefined);
+        return trackWrite(provider.store.executeBatchAsync(commands).then(() => undefined));
     },
     mergeItem(key, change, replaceNullPatches) {
         // Since Onyx already merged the existing value with the changes, we can just set the value directly.
         return provider.multiMerge([[key, change, replaceNullPatches]]);
     },
     getAllKeys() {
-        if (!provider.store) {
+        if (!readStore) {
             throw new Error('Store is not initialized!');
         }
-        return provider.store.executeAsync('SELECT record_key FROM keyvaluepairs;').then(({ rows }) => {
+        const reader = readStore;
+        return readAfterPendingWrites(() => reader.executeAsync('SELECT record_key FROM keyvaluepairs;')).then(({ rows }) => {
             // eslint-disable-next-line no-underscore-dangle
             const result = rows === null || rows === void 0 ? void 0 : rows._array.map((row) => row.record_key);
             return (result !== null && result !== void 0 ? result : []);
         });
     },
     getAll() {
-        if (!provider.store) {
+        if (!readStore) {
             throw new Error('Store is not initialized!');
         }
         // Aggregate the whole table into a single JSON string in SQLite so we only run JSON.parse
         // once, instead of returning every row and parsing each one individually in JavaScript.
-        return provider.store
-            .executeAsync('SELECT json_group_array(json_array(record_key, json(valueJSON))) AS aggregated FROM keyvaluepairs;')
-            .then(({ rows }) => {
+        const reader = readStore;
+        return readAfterPendingWrites(() => reader.executeAsync('SELECT json_group_array(json_array(record_key, json(valueJSON))) AS aggregated FROM keyvaluepairs;')).then(({ rows }) => {
             var _a;
             const aggregated = (_a = rows === null || rows === void 0 ? void 0 : rows.item(0)) === null || _a === void 0 ? void 0 : _a.aggregated;
             if (aggregated == null) {
@@ -207,10 +305,10 @@ const provider = {
         });
     },
     removeItem(key) {
-        if (!provider.store) {
+        if (!removeItemStatement) {
             throw new Error('Store is not initialized!');
         }
-        return provider.store.executeAsync('DELETE FROM keyvaluepairs WHERE record_key = ?;', [key]).then(() => undefined);
+        return trackWrite(removeItemStatement.executeAsync([key]).then(() => undefined));
     },
     removeItems(keys) {
         if (!provider.store) {
@@ -226,19 +324,24 @@ const provider = {
         };
         if (keyChunks.length === 1) {
             const keyChunk = keyChunks[0];
-            return provider.store.executeAsync(buildDeleteQuery(keyChunk), keyChunk).then(() => undefined);
+            return trackWrite(provider.store.executeAsync(buildDeleteQuery(keyChunk), keyChunk).then(() => undefined));
         }
-        const commands = keyChunks.map((keyChunk) => ({
-            query: buildDeleteQuery(keyChunk),
-            params: keyChunk,
-        }));
-        return provider.store.executeBatchAsync(commands).then(() => undefined);
+        const firstChunk = keyChunks[0];
+        const lastChunk = keyChunks[keyChunks.length - 1];
+        const hasSmallerLastChunk = lastChunk.length < firstChunk.length;
+        // NitroSQLite reuses one prepared statement for each grouped parameter set.
+        // Only the final partial chunk needs a different number of placeholders.
+        const commands = [{ query: buildDeleteQuery(firstChunk), params: hasSmallerLastChunk ? keyChunks.slice(0, -1) : keyChunks }];
+        if (hasSmallerLastChunk) {
+            commands.push({ query: buildDeleteQuery(lastChunk), params: lastChunk });
+        }
+        return trackWrite(provider.store.executeBatchAsync(commands).then(() => undefined));
     },
     clear() {
         if (!provider.store) {
             throw new Error('Store is not initialized!');
         }
-        return provider.store.executeAsync('DELETE FROM keyvaluepairs;', []).then(() => undefined);
+        return trackWrite(provider.store.executeAsync('DELETE FROM keyvaluepairs;', []).then(() => undefined));
     },
     getDatabaseSize() {
         if (!provider.store) {

package/dist/storage/providers/classifySQLiteError.d.ts

@@ -1,10 +1,10 @@
 import type { ValueOf } from 'type-fest';
 import { StorageErrorClass } from '../errors';
 /**
- * Classifies a SQLite write failure into the shared storage taxonomy (lib/storage/errors.ts).
+ * Classifies a SQLite failure into the shared storage taxonomy (lib/storage/errors.ts).
  * This is the SQLite engine's own dialect — it is NOT shared with other engines. It lives in a
- * standalone module (no `react-native-nitro-sqlite` import) so it can be reused without pulling in
- * native dependencies.
+ * standalone module that uses NitroSQLite's native-free errors export without initializing the
+ * native module.
  *
  * SQLite surfaces fewer distinct write-failure shapes than IndexedDB. As telemetry from the UNKNOWN
  * bucket (see OnyxUtils.retryOperation) reveals recurring native errors, add matchers here.

package/dist/storage/providers/classifySQLiteError.js

@@ -1,24 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const errors_1 = require("../errors");
+const errors_1 = require("react-native-nitro-sqlite/errors");
+const errors_2 = require("../errors");
 /**
- * Classifies a SQLite write failure into the shared storage taxonomy (lib/storage/errors.ts).
+ * Classifies a SQLite failure into the shared storage taxonomy (lib/storage/errors.ts).
  * This is the SQLite engine's own dialect — it is NOT shared with other engines. It lives in a
- * standalone module (no `react-native-nitro-sqlite` import) so it can be reused without pulling in
- * native dependencies.
+ * standalone module that uses NitroSQLite's native-free errors export without initializing the
+ * native module.
  *
  * SQLite surfaces fewer distinct write-failure shapes than IndexedDB. As telemetry from the UNKNOWN
  * bucket (see OnyxUtils.retryOperation) reveals recurring native errors, add matchers here.
  */
 function classifySQLiteError(error) {
-    const { message } = (0, errors_1.getErrorParts)(error);
+    // If the database cannot open, initialization must fall back to memory storage.
+    if (isDatabaseOpenError(error)) {
+        return errors_2.StorageErrorClass.UNAVAILABLE;
+    }
+    const { message } = (0, errors_2.getErrorParts)(error);
     // Device disk full.
     if (message.includes('database or disk is full')) {
-        return errors_1.StorageErrorClass.CAPACITY;
+        return errors_2.StorageErrorClass.CAPACITY;
     }
     if (message.includes('disk i/o error') || message.includes('unable to open database file')) {
-        return errors_1.StorageErrorClass.DISK_PRESSURE;
+        return errors_2.StorageErrorClass.DISK_PRESSURE;
     }
-    return errors_1.StorageErrorClass.UNKNOWN;
+    return errors_2.StorageErrorClass.UNKNOWN;
+}
+function isDatabaseOpenError(error) {
+    return typeof error === 'object' && error !== null && 'type' in error && error.type === errors_1.NitroSQLiteExceptionType.DatabaseCannotBeOpened;
 }
 exports.default = classifySQLiteError;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "3.0.119",
+  "version": "3.0.121",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",
@@ -75,7 +75,7 @@
     "@typescript-eslint/eslint-plugin": "^8.51.0",
     "@typescript-eslint/parser": "^8.51.0",
     "@vercel/ncc": "0.38.1",
-    "better-sqlite3": "^12.10.0",
+    "better-sqlite3": "^12.11.1",
     "date-fns": "^4.1.0",
     "eslint": "^9.39.2",
     "eslint-config-expensify": "2.0.108",
@@ -97,7 +97,7 @@
     "react-native": "0.76.3",
     "react-native-device-info": "^10.3.0",
     "react-native-nitro-modules": "^0.35.0",
-    "react-native-nitro-sqlite": "^9.6.0",
+    "react-native-nitro-sqlite": "10.2.0",
     "react-test-renderer": "18.2.0",
     "reassure": "1.4.0",
     "ts-node": "^10.9.2",
@@ -110,7 +110,7 @@
     "react-native": ">=0.75.0",
     "react-native-device-info": "^10.3.0",
     "react-native-nitro-modules": ">=0.35.0",
-    "react-native-nitro-sqlite": "^9.6.0"
+    "react-native-nitro-sqlite": "^10.2.0"
   },
   "peerDependenciesMeta": {
     "idb-keyval": {