react-native-nitro-storage 0.1.4 → 0.3.0

package/README.md

@@ -1,93 +1,63 @@
-# react-native-nitro-storage 🗄️
+# react-native-nitro-storage
 
-> **The fastest, most complete storage solution for React Native.** Replace Zustand, MMKV, AsyncStorage, and Expo Secure Store with one lightning-fast, type-safe library.
+Synchronous storage for React Native with a unified API for memory, disk, and secure data.
 
-[![npm version](https://img.shields.io/npm/v/react-native-nitro-storage?style=flat-square)](https://www.npmjs.com/package/react-native-nitro-storage)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
-[![Nitro Modules](https://img.shields.io/badge/Powered%20by-Nitro%20Modules-blueviolet?style=flat-square)](https://nitro.margelo.com)
+## Requirements
 
-**react-native-nitro-storage** unifies **Memory** (global state), **Disk** (persistence), and **Secure** (keychain) storage into a single, blazing-fast C++ library built with [Nitro Modules](https://nitro.margelo.com). All operations are **100% synchronous** via JSI—no promises, no bridge, no lag.
+- `react-native >= 0.75.0`
+- `react-native-nitro-modules >= 0.33.9`
+- `react >= 18.2.0`
 
-<p align="center">
-  <img src="./readme/ios.png" alt="iOS Benchmark" height="640" />
-  <img src="./readme/android.png" alt="Android Benchmark" height="640" />
-</p>
-
-<p align="center">
-  <em>Real-world performance: 1,000 operations in milliseconds</em>
-</p>
-
----
-
-## ⚡ Why Nitro Storage?
-
-### **One Library, Three Storage Types**
-
-Stop juggling multiple packages. Get memory state, disk persistence, and secure storage in one unified API.
-
-### **Truly Synchronous**
-
-Every operation—read, write, delete—executes instantly. No `await`, no `.then()`, no bridge overhead.
-
-### **Jotai-Style Atoms**
-
-Familiar, elegant API with `createStorageItem` and `useStorage`. Works inside and outside React components.
-
-### **Production-Ready**
-
-Thread-safe C++ core, comprehensive test coverage, and battle-tested on iOS, Android, and **Web**.
-
-### **Web Support**
-
-Fully functional on the web via `localStorage` and `sessionStorage`. All hooks and storage atoms are fully reactive across all platforms.
-
----
-
-## 📦 Installation
+## Installation
 
 ```bash
-npm install react-native-nitro-storage react-native-nitro-modules
-# or
-yarn add react-native-nitro-storage react-native-nitro-modules
-# or
 bun add react-native-nitro-storage react-native-nitro-modules
 ```
 
-### For Expo Projects
+### Expo
 
 ```bash
-npx expo install react-native-nitro-storage react-native-nitro-modules
+bunx expo install react-native-nitro-storage react-native-nitro-modules
 ```
 
-Add the plugin to your `app.json` or `app.config.js`:
+`app.json`:
 
 ```json
 {
   "expo": {
-    "plugins": ["react-native-nitro-storage"]
+    "plugins": [
+      [
+        "react-native-nitro-storage",
+        {
+          "faceIDPermission": "Allow $(PRODUCT_NAME) to use Face ID for secure authentication",
+          "addBiometricPermissions": false
+        }
+      ]
+    ]
   }
 }
 ```
 
-Then run:
+Notes:
+
+- If `faceIDPermission` is omitted, the plugin sets a default only when `NSFaceIDUsageDescription` is missing.
+- Android biometric permissions are opt-in via `addBiometricPermissions: true`.
+
+Then:
 
 ```bash
-npx expo prebuild
+bunx expo prebuild
 ```
 
-The config plugin automatically handles Android initialization. No manual setup required!
-
-### For Bare React Native Projects
+### Bare React Native
 
-**iOS:**
+iOS:
 
 ```bash
 cd ios && pod install
 ```
 
-**Android:**
-
-Add initialization to your `MainApplication.kt` (or `.java`):
+Android (`MainApplication.kt`):
 
 ```kotlin
 import com.nitrostorage.AndroidStorageAdapter
@@ -100,435 +70,394 @@ class MainApplication : Application() {
 }
 ```
 
----
-
-## 🚀 Quick Start
+## Quick Start
 
-```typescript
-import {
-  createStorageItem,
-  useStorage,
-  StorageScope,
-} from "react-native-nitro-storage";
+```ts
+import { createStorageItem, StorageScope, useStorage } from "react-native-nitro-storage";
 
-// Create a storage atom
-const counterAtom = createStorageItem({
+const counterItem = createStorageItem({
   key: "counter",
   scope: StorageScope.Memory,
   defaultValue: 0,
 });
 
-// Use in React
-function Counter() {
-  const [count, setCount] = useStorage(counterAtom);
+export function Counter() {
+  const [count, setCount] = useStorage(counterItem);
 
   return (
-    <View>
-      <Text>{count}</Text>
-      <Button title="+" onPress={() => setCount(count + 1)} />
-    </View>
+    <Button
+      title={`Count: ${count}`}
+      onPress={() => setCount((prev) => prev + 1)}
+    />
   );
 }
-
-// Use outside React
-counterAtom.set(42);
-const value = counterAtom.get(); // 42, instantly
 ```
 
----
-
-## 💾 Storage Scopes
-
-### **Memory Storage**
-
-_Replaces: Zustand, Jotai, Redux_
-
-Fast, in-memory state. **Now Pure JS** - can store complex objects, functions, and React nodes!
-
-```typescript
-// Store a function
-const callbackAtom = createStorageItem({
-  key: "on-click",
-  scope: StorageScope.Memory,
-  defaultValue: () => console.log("Clicked!"),
-});
-
-// Store a React Component
-const modalAtom = createStorageItem({
-  key: "active-modal",
-  scope: StorageScope.Memory,
-  defaultValue: <View />,
-});
+## What Is Exported
+
+- `StorageScope`
+- `storage`
+- `createStorageItem`
+- `useStorage`
+- `useStorageSelector`
+- `useSetStorage`
+- `getBatch`
+- `setBatch`
+- `removeBatch`
+- `registerMigration`
+- `migrateToLatest`
+- `runTransaction`
+- `migrateFromMMKV`
+
+Exported types:
+
+- `Storage`
+- `StorageItemConfig<T>`
+- `StorageItem<T>`
+- `StorageBatchSetItem<T>`
+- `Validator<T>`
+- `ExpirationConfig`
+- `MigrationContext`
+- `Migration`
+- `TransactionContext`
+- `MMKVLike`
+
+## API Reference
+
+### `StorageScope`
+
+```ts
+enum StorageScope {
+  Memory = 0,
+  Disk = 1,
+  Secure = 2,
+}
 ```
 
-**Performance:** < 0.001ms per operation (Zero JSI overhead)
-
-### **Disk Storage**
-
-_Replaces: MMKV, AsyncStorage_
-
-Persisted to disk. Survives app restarts.
-
-```typescript
-const settingsAtom = createStorageItem({
-  key: "app-settings",
-  scope: StorageScope.Disk,
-  defaultValue: { theme: "dark", notifications: true },
-});
+### `Storage` (low-level native/web adapter type)
+
+```ts
+type Storage = {
+  set(key: string, value: string, scope: number): void;
+  get(key: string, scope: number): string | undefined;
+  remove(key: string, scope: number): void;
+  clear(scope: number): void;
+  setBatch(keys: string[], values: string[], scope: number): void;
+  getBatch(keys: string[], scope: number): (string | undefined)[];
+  removeBatch(keys: string[], scope: number): void;
+  addOnChange(
+    scope: number,
+    callback: (key: string, value: string | undefined) => void
+  ): () => void;
+};
 ```
 
-**Performance:** ~1-2ms per operation  
-**Storage:** UserDefaults (iOS), SharedPreferences (Android)
-
-### **Secure Storage**
-
-_Replaces: Expo Secure Store, react-native-keychain_
-
-Encrypted storage for sensitive data like auth tokens.
-
-```typescript
-const tokenAtom = createStorageItem<string | undefined>({
-  key: "auth-token",
-  scope: StorageScope.Secure,
-});
+Notes:
+
+- Exported for typing/integration use cases.
+- Most app code should use `createStorageItem` + hooks instead of this low-level API.
+
+### `StorageItemConfig<T>`
+
+```ts
+type StorageItemConfig<T> = {
+  key: string;
+  scope: StorageScope;
+  defaultValue?: T;
+  serialize?: (value: T) => string;
+  deserialize?: (value: string) => T;
+  validate?: Validator<T>;
+  onValidationError?: (invalidValue: unknown) => T;
+  expiration?: ExpirationConfig;
+  readCache?: boolean;
+  coalesceSecureWrites?: boolean;
+};
 ```
 
-**Performance:** ~2-5ms per operation  
-**Encryption:** Keychain (iOS), EncryptedSharedPreferences with AES256-GCM (Android)
+### `StorageItem<T>`
 
----
+```ts
+type StorageItem<T> = {
+  get: () => T;
+  set: (value: T | ((prev: T) => T)) => void;
+  delete: () => void;
+  subscribe: (callback: () => void) => () => void;
+  serialize: (value: T) => string;
+  deserialize: (value: string) => T;
+  _triggerListeners: () => void;
+  scope: StorageScope;
+  key: string;
+};
+```
 
-## 🎯 Advanced Usage
+### `createStorageItem<T>(config)`
 
-### TypeScript Best Practices
+```ts
+function createStorageItem<T = undefined>(config: StorageItemConfig<T>): StorageItem<T>
+```
 
-**Nullable Types:**
-Use explicit generics for nullable values. `defaultValue` is optional and defaults to `undefined`.
+Notes:
 
-```typescript
-// ✅ Clean - explicit generic
-const userAtom = createStorageItem<User | null>({
-  key: "current-user",
-  scope: StorageScope.Memory,
-  defaultValue: null,
-});
+- `Memory` stores values directly.
+- `Disk` and `Secure` store serialized values.
+- Default serialization uses a primitive fast path for strings/numbers/booleans/null/undefined and JSON for objects/arrays.
+- If `expiration` is enabled, values are wrapped internally and expired lazily on read.
+- `readCache` is opt-in for `Disk`/`Secure` and can be enabled per item.
+- `coalesceSecureWrites` is opt-in and batches same-tick secure writes per key.
+- If `validate` fails on a stored value, fallback is:
+1. `onValidationError(invalidValue)` if provided
+2. `defaultValue` otherwise
+- Fallback values are written back only when the source was stored data and the resolved fallback also passes `validate`.
 
-// ✅ Optional value - no defaultValue needed
-const tokenAtom = createStorageItem<string | undefined>({
-  key: "auth-token",
-  scope: StorageScope.Secure,
-});
+Throws:
 
-// ❌ Avoid - type assertion
-const userAtom = createStorageItem({
-  key: "current-user",
-  scope: StorageScope.Memory,
-  defaultValue: null as User | null, // Not necessary
-});
-```
+- `Error("expiration.ttlMs must be greater than 0.")` when `expiration.ttlMs <= 0`.
 
-**Non-nullable Types:**
-For required values, just specify the default.
+### `useStorage(item)`
 
-```typescript
-const counterAtom = createStorageItem({
-  key: "counter",
-  scope: StorageScope.Memory,
-  defaultValue: 0, // Type inferred as number
-});
+```ts
+function useStorage<T>(
+  item: StorageItem<T>
+): [T, (value: T | ((prev: T) => T)) => void]
 ```
 
-### Custom Serialization
+### `useStorageSelector(item, selector, isEqual?)`
 
-```typescript
-const dateAtom = createStorageItem({
-  key: "last-login",
-  scope: StorageScope.Disk,
-  defaultValue: new Date(),
-  serialize: (date) => date.toISOString(),
-  deserialize: (str) => new Date(str),
-});
+```ts
+function useStorageSelector<T, TSelected>(
+  item: StorageItem<T>,
+  selector: (value: T) => TSelected,
+  isEqual?: (prev: TSelected, next: TSelected) => boolean
+): [TSelected, (value: T | ((prev: T) => T)) => void]
 ```
 
-### Complex Objects
-
-```typescript
-interface User {
-  id: string;
-  name: string;
-  preferences: {
-    theme: "light" | "dark";
-    language: string;
-  };
-}
+Use this to subscribe to a derived slice of a storage value and avoid rerenders when that slice does not change.
 
-const userAtom = createStorageItem<User>({
-  key: "user",
-  scope: StorageScope.Disk,
-  defaultValue: {
-    id: "",
-    name: "",
-    preferences: { theme: "dark", language: "en" },
-  },
-});
+### `useSetStorage(item)`
 
-// TypeScript knows the exact shape
-const user = userAtom.get();
-console.log(user.preferences.theme); // ✅ Type-safe
+```ts
+function useSetStorage<T>(
+  item: StorageItem<T>
+): (value: T | ((prev: T) => T)) => void
 ```
 
-### Direct Access (Outside React)
-
-Perfect for API interceptors, middleware, or anywhere you need storage without React.
+### `storage`
 
-```typescript
-// In an API interceptor
-axios.interceptors.request.use((config) => {
-  const token = tokenAtom.get();
-  if (token) {
-    config.headers.Authorization = `Bearer ${token}`;
-  }
-  return config;
-});
-
-// In a Redux middleware
-const authMiddleware = (store) => (next) => (action) => {
-  if (action.type === "AUTH_SUCCESS") {
-    tokenAtom.set(action.payload.token);
-  }
-  return next(action);
+```ts
+const storage: {
+  clear: (scope: StorageScope) => void;
+  clearAll: () => void;
 };
 ```
 
-### Manual Subscriptions
+Behavior:
 
-```typescript
-const unsubscribe = counterAtom.subscribe(() => {
-  console.log("Counter changed:", counterAtom.get());
-});
-
-// Clean up
-unsubscribe();
-```
+- `clear(scope)` clears all keys in a single scope.
+- `clearAll()` clears `Memory`, `Disk`, and `Secure`.
 
 ### Batch Operations
 
-Read or write multiple items at once. This is highly optimized on the native side for minimum overhead.
-
-```typescript
-import { getBatch, setBatch, removeBatch } from "react-native-nitro-storage";
+```ts
+type StorageBatchSetItem<T> = {
+  item: StorageItem<T>;
+  value: T;
+};
 
-// Write multiple items
-setBatch(
-  [
-    { item: item1, value: "v1" },
-    { item: item2, value: "v2" },
-  ],
-  StorageScope.Disk
-);
+function getBatch(
+  items: readonly Pick<StorageItem<unknown>, "key" | "scope" | "get" | "deserialize">[],
+  scope: StorageScope
+): unknown[];
 
-// Read multiple items
-const [v1, v2] = getBatch([item1, item2], StorageScope.Disk);
+function setBatch<T>(
+  items: readonly StorageBatchSetItem<T>[],
+  scope: StorageScope
+): void;
 
-// Remove multiple items
-removeBatch([item1, item2], StorageScope.Disk);
+function removeBatch(
+  items: readonly Pick<StorageItem<unknown>, "key" | "scope" | "delete">[],
+  scope: StorageScope
+): void;
 ```
 
-### Functional Updates
-
-Update state based on the previous value, just like `useState`.
+Rules:
 
-```typescript
-// Increment counter
-counterAtom.set((prev) => prev + 1);
-```
+- All items must match the batch `scope`.
+- Items using `validate` or `expiration` automatically run via per-item `get()`/`set()` paths to preserve validation and TTL behavior.
+- Mixed-scope calls throw:
+  - `Batch scope mismatch for "<key>": expected <Scope>, received <Scope>.`
 
-### Optimized Writes
+### Migrations
 
-Use `useSetStorage` to set values without subscribing to updates (avoids re-renders).
+```ts
+type MigrationContext = {
+  scope: StorageScope;
+  getRaw: (key: string) => string | undefined;
+  setRaw: (key: string, value: string) => void;
+  removeRaw: (key: string) => void;
+};
 
-```typescript
-import { useSetStorage } from "react-native-nitro-storage";
+type Migration = (context: MigrationContext) => void;
 
-function IncrementButton() {
-  const setCount = useSetStorage(counterAtom);
-  return <Button onPress={() => setCount((c) => c + 1)} title="+" />;
-}
+function registerMigration(version: number, migration: Migration): void;
+function migrateToLatest(scope?: StorageScope): number;
 ```
 
-### Clearing Data
-
-Clear entire storage scopes at once.
+Behavior:
 
-```typescript
-import { storage } from "react-native-nitro-storage";
+- Versions must be positive integers.
+- Duplicate versions throw.
+- Migration version is tracked per scope using key `__nitro_storage_migration_version__`.
+- `migrateToLatest` applies pending migrations in ascending version order and returns applied/latest version.
 
-// Clear all storage (all scopes)
-storage.clearAll();
-
-// Clear specific scope
-storage.clear(StorageScope.Memory);
-storage.clear(StorageScope.Disk);
-storage.clear(StorageScope.Secure);
-```
+Throws:
 
-### Migration from MMKV
+- `registerMigration`: throws when version is not a positive integer.
+- `registerMigration`: throws when version is already registered.
+- `migrateToLatest`: throws on invalid scope.
 
-Easily migrate data from `react-native-mmkv` to Nitro Storage.
+### Transactions
 
-```typescript
-import { migrateFromMMKV } from "react-native-nitro-storage/src/migration";
+```ts
+type TransactionContext = {
+  scope: StorageScope;
+  getRaw: (key: string) => string | undefined;
+  setRaw: (key: string, value: string) => void;
+  removeRaw: (key: string) => void;
+  getItem: <T>(item: Pick<StorageItem<T>, "scope" | "key" | "get">) => T;
+  setItem: <T>(item: Pick<StorageItem<T>, "scope" | "key" | "set">, value: T) => void;
+  removeItem: (item: Pick<StorageItem<unknown>, "scope" | "key" | "delete">) => void;
+};
 
-// Migrate 'user-settings' and delete from MMKV
-migrateFromMMKV(mmkvInstance, settingsAtom, true);
+function runTransaction<T>(
+  scope: StorageScope,
+  transaction: (context: TransactionContext) => T
+): T;
 ```
 
----
+Behavior:
 
-## 📊 Performance Benchmarks
+- On exception, it rolls back keys modified in that transaction.
+- Rollback is best-effort within process lifetime.
+- `setItem`/`removeItem` prefer item methods when available, so validation/TTL/cache semantics stay consistent.
 
-All operations are **100% synchronous** via JSI—no promises, no bridge, no lag.
+Throws:
 
-**Performance Metrics (1,000 operations per storage type):**
+- Throws on invalid scope.
+- Rethrows any error thrown by the transaction callback after rollback.
 
-| Storage Type | Write | Read  | Avg/op       |
-| ------------ | ----- | ----- | ------------ |
-| Memory       | 0.5ms | 0.3ms | **0.0008ms** |
-| Disk         | 45ms  | 38ms  | **0.083ms**  |
-| Secure       | 120ms | 95ms  | **0.215ms**  |
+### Validation and Expiration Types
 
-Run the benchmark yourself:
+```ts
+type Validator<T> = (value: unknown) => value is T;
 
-```bash
-cd apps/example
-npm run ios  # or npm run android
-# Navigate to the "Benchmark" tab
+type ExpirationConfig = {
+  ttlMs: number;
+};
 ```
 
----
-
-## 🎯 API Reference
-
-### `createStorageItem<T>(config)`
-
-Creates a storage atom.
-
-**Parameters:**
-
-- `key: string` - Unique identifier
-- `scope: StorageScope` - Memory, Disk, or Secure
-- `defaultValue: T` - Default value
-- `serialize?: (value: T) => string` - Custom serializer (default: JSON.stringify)
-- `deserialize?: (value: string) => T` - Custom deserializer (default: JSON.parse)
-
-**Returns:** `StorageItem<T>`
-
-### `StorageItem<T>`
-
-**Methods:**
-
-- `get(): T` - Get current value (synchronous)
-- `set(value: T | ((prev: T) => T)): void` - Set new value (synchronous)
-- `delete(): void` - Remove value (synchronous)
-- `subscribe(callback: () => void): () => void` - Subscribe to changes
+### MMKV Migration
 
-### `useStorage<T>(item: StorageItem<T>)`
-
-React hook using `useSyncExternalStore` for automatic re-renders.
+```ts
+type MMKVLike = {
+  getString: (key: string) => string | undefined;
+  getNumber: (key: string) => number | undefined;
+  getBoolean: (key: string) => boolean | undefined;
+  contains: (key: string) => boolean;
+  delete: (key: string) => void;
+  getAllKeys: () => string[];
+};
 
-**Returns:** `[value: T, setValue: (value: T | ((prev: T) => T)) => void]`
+function migrateFromMMKV<T>(
+  mmkv: MMKVLike,
+  item: StorageItem<T>,
+  deleteFromMMKV?: boolean
+): boolean;
+```
 
-### `useSetStorage<T>(item: StorageItem<T>)`
+Behavior:
 
-Returns the setter function only. Does not subscribe to updates.
+- Returns `true` when a value is found and copied, `false` otherwise.
+- Read priority is: `getString` -> `getNumber` -> `getBoolean`.
+- Uses `item.set(...)`, so schema validation on the target item still applies.
+- If `deleteFromMMKV` is `true`, deletes only when migration succeeds.
 
-**Returns:** `(value: T | ((prev: T) => T)) => void`
+## Examples
 
-### `storage` Object
+### Schema Validation + Fallback
 
-- `clearAll()`: Clears all storage across all scopes.
-- `clear(scope)`: Clears a specific storage scope.
+```ts
+const userIdItem = createStorageItem<number>({
+  key: "user-id",
+  scope: StorageScope.Disk,
+  defaultValue: 0,
+  validate: (v): v is number => typeof v === "number" && v > 0,
+  onValidationError: () => 1,
+});
+```
 
-### Batch Operations
+### TTL
 
-- `getBatch(items, scope)`: Returns an array of values for the given items.
-- `setBatch(items, scope)`: Sets multiple values at once.
-- `removeBatch(items, scope)`: Removes multiple items at once.
+```ts
+const otpItem = createStorageItem<string | undefined>({
+  key: "otp",
+  scope: StorageScope.Secure,
+  expiration: { ttlMs: 60_000 },
+});
+```
 
----
+### Transaction
 
-## 🔐 Security
+```ts
+runTransaction(StorageScope.Disk, (tx) => {
+  tx.setRaw("a", JSON.stringify(1));
+  tx.setRaw("b", JSON.stringify(2));
+});
+```
 
-### iOS
+### Versioned Migrations
 
-- **Disk:** `UserDefaults.standard`
-- **Secure:** Keychain with `kSecAttrAccessibleWhenUnlocked`
+```ts
+registerMigration(1, ({ setRaw }) => {
+  setRaw("seed", JSON.stringify({ ready: true }));
+});
 
-### Android
+registerMigration(2, ({ getRaw, setRaw }) => {
+  const raw = getRaw("seed");
+  if (!raw) return;
+  const value = JSON.parse(raw) as { ready: boolean };
+  setRaw("seed", JSON.stringify({ ...value, migrated: true }));
+});
 
-- **Disk:** `SharedPreferences`
-- **Secure:** `EncryptedSharedPreferences` with AES256-GCM encryption
+migrateToLatest(StorageScope.Disk);
+```
 
-All secure operations use platform-native encryption. No data is stored in plain text.
+## Scope Semantics
 
----
+- `Memory`: in-memory only, not persisted.
+- `Disk`: App-scoped UserDefaults suite (iOS), SharedPreferences (Android), `localStorage` (web).
+- `Secure`: Keychain (iOS), EncryptedSharedPreferences (Android), `sessionStorage` fallback (web).
 
-## 🧪 Testing
+## Dev Commands
 
-Comprehensive test coverage for both TypeScript and C++:
+From repo root:
 
 ```bash
-# TypeScript/Jest tests
-npm test
-
-# Type checking
-npm run typecheck
-
-# Build verification
-npm run build
+bun run test -- --filter=react-native-nitro-storage
+bun run typecheck -- --filter=react-native-nitro-storage
+bun run build -- --filter=react-native-nitro-storage
+bun run benchmark
 ```
 
-**Test Coverage:**
-
-- ✅ All storage scopes (Memory, Disk, Secure)
-- ✅ Custom serialization
-- ✅ Complex objects
-- ✅ Subscription/unsubscription
-- ✅ Memory leak prevention
-- ✅ Thread safety (C++)
-
----
-
-## 🏗️ Architecture
-
-Built on [Nitro Modules](https://nitro.margelo.com) for maximum performance:
+Inside package:
 
-- **C++ Core:** Thread-safe storage implementation with mutex protection
-- **JSI Bridge:** Zero-copy, synchronous JavaScript ↔ C++ communication
-- **Platform Adapters:** Native iOS (Objective-C++) and Android (Kotlin + JNI) implementations
-- **React Integration:** `useSyncExternalStore` for optimal React 18+ compatibility
-
----
-
-## 🆚 Comparison
-
-| Feature          | Nitro Storage | MMKV | AsyncStorage | Zustand | Expo Secure Store |
-| ---------------- | ------------- | ---- | ------------ | ------- | ----------------- |
-| Synchronous      | ✅            | ✅   | ❌           | ✅      | ❌                |
-| Memory State     | ✅            | ❌   | ❌           | ✅      | ❌                |
-| Disk Persistence | ✅            | ✅   | ✅           | ❌      | ❌                |
-| Secure Storage   | ✅            | ❌   | ❌           | ❌      | ✅                |
-| Type-Safe        | ✅            | ⚠️   | ⚠️           | ✅      | ⚠️                |
-| Unified API      | ✅            | ❌   | ❌           | ❌      | ❌                |
-| React Hooks      | ✅            | ❌   | ❌           | ✅      | ❌                |
-| Web Support      | ✅            | ❌   | ✅           | ✅      | ❌                |
-
----
+```bash
+bun run test
+bun run test:coverage
+bun run typecheck
+bun run build
+bun run benchmark
+```
 
-## 📄 License
+## License
 
 MIT
-
----
-
-**Keywords:** react-native storage, react-native state management, react-native keychain, react-native secure storage, react-native mmkv alternative, react-native async storage, synchronous storage react native, jsi storage, nitro modules, react native persistence