react-native-litert-lm 0.2.1 → 0.2.2

package/README.md

@@ -12,6 +12,8 @@ High-performance LLM inference for React Native powered by [LiteRT-LM](https://g
 - 📱 **Cross-Platform** - Android API 26+
 - 🖼️ **Multimodal** - Image and audio input support (Android Beta, iOS coming soon)
 - 🧵 **Async API** - Non-blocking inference to prevent UI freezes
+- 📊 **Real Memory Tracking** - OS-level memory metrics (RSS, native heap, available memory) via native APIs
+- 🧮 **Zero-Copy Buffers** - Memory snapshots stored in native ArrayBuffers via `NitroModules.createNativeArrayBuffer()` (v0.34+)
 
 ## Status
 
@@ -56,27 +58,31 @@ cd ios && pod install  # iOS coming soon
 
 ## Example App
 
-The repository includes a fully functional example app in the `example/` directory.
+The repository includes a fully functional example app in the `example/` directory with a dark-themed diagnostic UI that demonstrates model loading, inference, memory tracking, and performance stats.
 
 To run it:
 
-1.  **Navigate to the example directory:**
+1.  **Build the library** (compiles TypeScript to `lib/`):
 
     ```bash
-    cd example
+    npm run build
     ```
 
-2.  **Install dependencies:**
+2.  **Navigate to the example directory and install dependencies:**
 
     ```bash
+    cd example
     npm install
     ```
 
-3.  **Run on Android:**
+3.  **Create a development build and run on Android:**
     ```bash
+    npx expo prebuild --clean
     npx expo run:android
     ```
 
+> **Note:** If you change native code (C++/Kotlin), you must run `npx expo prebuild --clean` again.
+
 ## Model Management
 
 LiteRT-LM models (like Gemma 3n) are large files (3GB+) and cannot be bundled directly into your app's binary. You must download them at runtime to a writable directory (e.g., `DocumentDirectory`).
@@ -206,6 +212,84 @@ console.log(`Generated ${stats.completionTokens} tokens`);
 console.log(`Speed: ${stats.tokensPerSecond.toFixed(1)} tokens/sec`);
 ```
 
+### Memory Tracking
+
+The library provides real OS-level memory usage data. You can query memory at any time, or enable automatic tracking to record snapshots after each inference call.
+
+#### Direct Memory Query
+
+```typescript
+// Get a single real-time snapshot from native APIs
+const usage = llm.getMemoryUsage();
+console.log(`Native heap: ${(usage.nativeHeapBytes / 1024 / 1024).toFixed(1)} MB`);
+console.log(`RSS: ${(usage.residentBytes / 1024 / 1024).toFixed(1)} MB`);
+console.log(`Available: ${(usage.availableMemoryBytes / 1024 / 1024).toFixed(1)} MB`);
+console.log(`Low memory: ${usage.isLowMemory}`);
+```
+
+#### Automatic Tracking with Native Buffers
+
+Enable memory tracking to automatically record snapshots in a native-backed `ArrayBuffer` (allocated via `NitroModules.createNativeArrayBuffer()`) after every inference call:
+
+```typescript
+import { createLLM } from 'react-native-litert-lm';
+
+const llm = createLLM({
+  enableMemoryTracking: true,
+  maxMemorySnapshots: 256, // default
+});
+
+await llm.loadModel('/path/to/model.litertlm', { backend: 'cpu' });
+await llm.sendMessage('Hello!');
+
+// Review tracked data
+const summary = llm.memoryTracker!.getSummary();
+console.log(`Peak RSS: ${(summary.peakResidentBytes / 1024 / 1024).toFixed(1)} MB`);
+console.log(`Peak Native Heap: ${(summary.peakNativeHeapBytes / 1024 / 1024).toFixed(1)} MB`);
+console.log(`RSS Delta: ${(summary.residentDeltaBytes / 1024 / 1024).toFixed(1)} MB`);
+console.log(`Snapshots: ${summary.snapshotCount}`);
+```
+
+#### Using the `useModel` Hook with Memory Tracking
+
+```typescript
+import { useModel } from 'react-native-litert-lm';
+
+const { model, isReady, memorySummary, memoryTracker } = useModel(modelUrl, {
+  enableMemoryTracking: true,
+  maxMemorySnapshots: 100,
+});
+
+// memorySummary auto-updates after each inference call
+if (memorySummary) {
+  console.log(`Current RSS: ${memorySummary.currentResidentBytes}`);
+  console.log(`Peak RSS: ${memorySummary.peakResidentBytes}`);
+}
+```
+
+#### Standalone Memory Tracker
+
+```typescript
+import { createMemoryTracker, createNativeBuffer } from 'react-native-litert-lm';
+
+// Create a tracker backed by a native ArrayBuffer
+const tracker = createMemoryTracker(100);
+
+// Manually record snapshots
+tracker.record({
+  timestamp: Date.now(),
+  nativeHeapBytes: 50_000_000,
+  residentBytes: 200_000_000,
+  availableMemoryBytes: 4_000_000_000,
+});
+
+// Access the underlying native buffer (for zero-copy transfer to native code)
+const buffer = tracker.getNativeBuffer();
+
+// Create a standalone native buffer for custom use
+const customBuffer = createNativeBuffer(1024);
+```
+
 ## Supported Models
 
 Download `.litertlm` models automatically using the exported constants or from [HuggingFace](https://huggingface.co/litert-community):
@@ -264,6 +348,19 @@ Send a message with an image attachment (for vision models).
 
 Send a message with an audio attachment (for audio models).
 
+### `getMemoryUsage(): MemoryUsage`
+
+Returns real OS-level memory usage statistics from native APIs. No estimation — reads directly from `mach_task_basic_info` (iOS) / `Debug.getNativeHeapAllocatedSize()` + `/proc/self/status` (Android).
+
+```typescript
+interface MemoryUsage {
+  nativeHeapBytes: number;      // Native heap allocated bytes
+  residentBytes: number;        // Process RSS in bytes
+  availableMemoryBytes: number; // Available system memory in bytes
+  isLowMemory: boolean;         // Whether the system considers memory low
+}
+```
+
 ### `getHistory(): Message[]`
 
 Get conversation history.
@@ -341,7 +438,7 @@ const llamaPrompt = applyLlamaTemplate(history, "You are helpful.");
 ## Requirements
 
 - React Native 0.76+
-- react-native-nitro-modules 0.33.2+
+- react-native-nitro-modules **0.34.1+** (required for `createNativeArrayBuffer` and memory tracking)
 - Android API 26+ (ARM64 only)
 - **LiteRT-LM Android SDK**: `0.9.0-alpha01` (bundled automatically)
 - iOS 15.0+ (coming soon)

package/android/src/main/java/com/margelo/nitro/dev/litert/litertlm/HybridLiteRTLM.kt

@@ -6,6 +6,9 @@
 package com.margelo.nitro.dev.litert.litertlm
 
 import android.util.Log
+import android.os.Debug
+import android.app.ActivityManager
+import android.content.Context
 import androidx.annotation.Keep
 import com.facebook.proguard.annotations.DoNotStrip
 import dev.litert.litertlm.LiteRTLMInitProvider
@@ -496,6 +499,50 @@ class HybridLiteRTLM : HybridLiteRTLMSpec() {
         return lastStats
     }
 
+    override fun getMemoryUsage(): MemoryUsage {
+        // Native heap: allocated bytes from Debug APIs (most accurate for native allocations)
+        val nativeHeapBytes = Debug.getNativeHeapAllocatedSize().toDouble()
+
+        // Process RSS: read from /proc/self/status (VmRSS) in kB
+        var residentBytes = 0.0
+        try {
+            java.io.File("/proc/self/status").forEachLine { line ->
+                if (line.startsWith("VmRSS:")) {
+                    val kb = line.substringAfter("VmRSS:").trim().split("\\s+".toRegex())[0].toDoubleOrNull()
+                    if (kb != null) {
+                        residentBytes = kb * 1024.0
+                    }
+                    return@forEachLine
+                }
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "Failed to read /proc/self/status: ${e.message}")
+        }
+
+        // Available memory and low-memory flag from ActivityManager
+        var availableMemoryBytes = 0.0
+        var isLowMemory = false
+        try {
+            val context = LiteRTLMInitProvider.applicationContext
+            if (context != null) {
+                val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+                val memInfo = ActivityManager.MemoryInfo()
+                activityManager.getMemoryInfo(memInfo)
+                availableMemoryBytes = memInfo.availMem.toDouble()
+                isLowMemory = memInfo.lowMemory
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "Failed to get ActivityManager memory info: ${e.message}")
+        }
+
+        return MemoryUsage(
+            nativeHeapBytes = nativeHeapBytes,
+            residentBytes = residentBytes,
+            availableMemoryBytes = availableMemoryBytes,
+            isLowMemory = isLowMemory
+        )
+    }
+
     override fun close() {
         Log.d(TAG, "Closing resources")
         isClosed = true

package/cpp/HybridLiteRTLM.cpp

@@ -518,6 +518,85 @@ GenerationStats HybridLiteRTLM::getStats() {
   return lastStats_;
 }
 
+//------------------------------------------------------------------------------
+// getMemoryUsage - Return real memory usage from OS
+//------------------------------------------------------------------------------
+MemoryUsage HybridLiteRTLM::getMemoryUsage() {
+  double nativeHeapBytes = 0;
+  double residentBytes = 0;
+  double availableMemoryBytes = 0;
+  bool isLowMemory = false;
+
+#ifdef __APPLE__
+  // Get process memory info via Mach APIs
+  struct mach_task_basic_info taskInfo;
+  mach_msg_type_number_t infoCount = MACH_TASK_BASIC_INFO_COUNT;
+  if (task_info(mach_task_self(), MACH_TASK_BASIC_INFO,
+                (task_info_t)&taskInfo, &infoCount) == KERN_SUCCESS) {
+    residentBytes = static_cast<double>(taskInfo.resident_size);
+  }
+
+  // Get system-wide memory pressure
+  vm_statistics64_data_t vmStats;
+  mach_msg_type_number_t vmCount = HOST_VM_INFO64_COUNT;
+  if (host_statistics64(mach_host_self(), HOST_VM_INFO64,
+                        (host_info64_t)&vmStats, &vmCount) == KERN_SUCCESS) {
+    vm_size_t pageSize;
+    host_page_size(mach_host_self(), &pageSize);
+    availableMemoryBytes = static_cast<double>(vmStats.free_count) * pageSize;
+    // Consider low memory if free pages < 10% of total active+inactive+free
+    uint64_t totalPages = vmStats.active_count + vmStats.inactive_count + vmStats.free_count;
+    isLowMemory = (totalPages > 0) &&
+                  (static_cast<double>(vmStats.free_count) / totalPages < 0.1);
+  }
+
+  // malloc_size is per-allocation; use resident_size as native heap proxy
+  nativeHeapBytes = residentBytes;
+#endif
+
+#ifdef __ANDROID__
+  // Parse /proc/self/status for VmRSS (resident set size)
+  std::ifstream statusFile("/proc/self/status");
+  if (statusFile.is_open()) {
+    std::string line;
+    while (std::getline(statusFile, line)) {
+      if (line.rfind("VmRSS:", 0) == 0) {
+        // Format: "VmRSS:    123456 kB"
+        std::istringstream iss(line.substr(6));
+        double kbValue = 0;
+        iss >> kbValue;
+        residentBytes = kbValue * 1024.0;
+        break;
+      }
+    }
+  }
+
+  // Use mallinfo for native heap
+  struct mallinfo mi = mallinfo();
+  nativeHeapBytes = static_cast<double>(mi.uordblks); // total allocated space
+
+  // Parse /proc/meminfo for available memory
+  std::ifstream memFile("/proc/meminfo");
+  if (memFile.is_open()) {
+    std::string line;
+    while (std::getline(memFile, line)) {
+      if (line.rfind("MemAvailable:", 0) == 0) {
+        std::istringstream iss(line.substr(13));
+        double kbValue = 0;
+        iss >> kbValue;
+        availableMemoryBytes = kbValue * 1024.0;
+        break;
+      }
+    }
+  }
+
+  // Consider low if available < 256MB
+  isLowMemory = availableMemoryBytes > 0 && availableMemoryBytes < 256.0 * 1024 * 1024;
+#endif
+
+  return MemoryUsage{nativeHeapBytes, residentBytes, availableMemoryBytes, isLowMemory};
+}
+
 //------------------------------------------------------------------------------
 // close - Release all native resources
 //------------------------------------------------------------------------------

package/cpp/HybridLiteRTLM.hpp

@@ -21,6 +21,16 @@
 #include "litert/lm/types.h"
 #endif
 
+// Memory usage headers
+#ifdef __APPLE__
+#include <mach/mach.h>
+#include <mach/mach_host.h>
+#endif
+#ifdef __ANDROID__
+#include <malloc.h>
+#include <fstream>
+#endif
+
 #include <string>
 #include <optional>
 #include <vector>
@@ -79,6 +89,8 @@ public:
   
   GenerationStats getStats() override;
   
+  MemoryUsage getMemoryUsage() override;
+  
   void close() override;
 
 private:

package/cpp/cpp-adapter.cpp

@@ -2,12 +2,20 @@
 /// cpp-adapter.cpp
 /// JNI Entry Point - Required by Nitrogen to register Kotlin HybridObjects
 ///
+/// Updated for react-native-nitro-modules v0.34+:
+/// Uses facebook::jni::initialize() directly with registerAllNatives().
+///
 
 #include <jni.h>
+#include <fbjni/fbjni.h>
 #include "LiteRTLMOnLoad.hpp"
 
 // JNI_OnLoad is called when the native library is loaded via System.loadLibrary()
-// This is where we initialize the Nitrogen bridge and register all Kotlin HybridObjects
+// This is where we initialize the Nitrogen bridge and register all Kotlin HybridObjects.
+// The new v0.34 API allows registering custom C++ native JNI classes/functions
+// alongside Nitrogen's auto-generated registrations.
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-    return margelo::nitro::litertlm::initialize(vm);
+    return facebook::jni::initialize(vm, []() {
+        margelo::nitro::litertlm::registerAllNatives();
+    });
 }

package/lib/hooks.d.ts

@@ -1,6 +1,20 @@
 import { LiteRTLM, LLMConfig } from "./index";
+import type { MemoryTracker, MemoryTrackerSummary } from "./memoryTracker";
 export interface UseModelConfig extends LLMConfig {
     autoLoad?: boolean;
+    /**
+     * Enable memory tracking using native ArrayBuffers (v0.34+).
+     * 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: LiteRTLM | null;
@@ -12,5 +26,16 @@ export interface UseModelResult {
     reset: () => void;
     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;

package/lib/hooks.js

@@ -9,11 +9,25 @@ function useModel(pathOrUrl, config) {
     const [isGenerating, setIsGenerating] = (0, react_1.useState)(false);
     const [downloadProgress, setDownloadProgress] = (0, react_1.useState)(0);
     const [error, setError] = (0, react_1.useState)(null);
-    // Extract autoLoad (default true)
+    const [memorySummary, setMemorySummary] = (0, react_1.useState)(null);
+    // Extract autoLoad (default true) and memory tracking options
     const autoLoad = config?.autoLoad ?? true;
+    const enableMemoryTracking = config?.enableMemoryTracking ?? false;
+    const maxMemorySnapshots = config?.maxMemorySnapshots ?? 256;
+    /**
+     * Refresh memory summary from the tracker's native buffer.
+     */
+    const refreshMemorySummary = (0, react_1.useCallback)(() => {
+        if (modelRef.current?.memoryTracker) {
+            setMemorySummary(modelRef.current.memoryTracker.getSummary());
+        }
+    }, []);
     // Initialize the model instance
     (0, react_1.useEffect)(() => {
-        modelRef.current = (0, modelFactory_1.createLLM)();
+        modelRef.current = (0, modelFactory_1.createLLM)({
+            enableMemoryTracking,
+            maxMemorySnapshots,
+        });
         let isMounted = true;
         // Cleanup on unmount
         return () => {
@@ -25,7 +39,7 @@ function useModel(pathOrUrl, config) {
                 console.warn("Failed to close model", e);
             }
         };
-    }, []);
+    }, [enableMemoryTracking, maxMemorySnapshots]);
     const load = (0, react_1.useCallback)(async () => {
         setIsReady(false);
         setError(null);
@@ -71,6 +85,7 @@ function useModel(pathOrUrl, config) {
                     modelRef.current?.sendMessageAsync(prompt, (token, done) => {
                         fullResponse += token;
                         if (done) {
+                            refreshMemorySummary();
                             resolve(fullResponse);
                         }
                     });
@@ -87,7 +102,7 @@ function useModel(pathOrUrl, config) {
         finally {
             setIsGenerating(false);
         }
-    }, [isReady]);
+    }, [isReady, refreshMemorySummary]);
     const reset = (0, react_1.useCallback)(() => {
         if (modelRef.current) {
             modelRef.current.resetConversation();
@@ -110,5 +125,7 @@ function useModel(pathOrUrl, config) {
         reset,
         deleteModel,
         load,
+        memoryTracker: modelRef.current?.memoryTracker ?? null,
+        memorySummary,
     };
 }

package/lib/index.d.ts

@@ -1,7 +1,9 @@
 import type { Backend } from "./specs/LiteRTLM.nitro";
-export type { LiteRTLM, LLMConfig, Message, Backend, Role, GenerationStats, } from "./specs/LiteRTLM.nitro";
+export type { LiteRTLM, LLMConfig, Message, Backend, Role, GenerationStats, MemoryUsage, } from "./specs/LiteRTLM.nitro";
 export type { ChatMessage } from "./templates";
 export { applyGemmaTemplate, applyPhiTemplate, applyLlamaTemplate, } from "./templates";
+export type { MemorySnapshot, MemoryTracker, MemoryTrackerSummary, } from "./memoryTracker";
+export { createMemoryTracker, createNativeBuffer } from "./memoryTracker";
 export * from "./hooks";
 /**
  * Creates a new LiteRT-LM inference engine instance.

package/lib/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GEMMA_3N_E2B_IT_INT4 = exports.Models = exports.createLLM = exports.applyLlamaTemplate = exports.applyPhiTemplate = exports.applyGemmaTemplate = void 0;
+exports.GEMMA_3N_E2B_IT_INT4 = exports.Models = exports.createLLM = exports.createNativeBuffer = exports.createMemoryTracker = exports.applyLlamaTemplate = exports.applyPhiTemplate = exports.applyGemmaTemplate = void 0;
 exports.getRecommendedBackend = getRecommendedBackend;
 exports.checkBackendSupport = checkBackendSupport;
 exports.checkMultimodalSupport = checkMultimodalSupport;
@@ -23,6 +23,9 @@ var templates_1 = require("./templates");
 Object.defineProperty(exports, "applyGemmaTemplate", { enumerable: true, get: function () { return templates_1.applyGemmaTemplate; } });
 Object.defineProperty(exports, "applyPhiTemplate", { enumerable: true, get: function () { return templates_1.applyPhiTemplate; } });
 Object.defineProperty(exports, "applyLlamaTemplate", { enumerable: true, get: function () { return templates_1.applyLlamaTemplate; } });
+var memoryTracker_1 = require("./memoryTracker");
+Object.defineProperty(exports, "createMemoryTracker", { enumerable: true, get: function () { return memoryTracker_1.createMemoryTracker; } });
+Object.defineProperty(exports, "createNativeBuffer", { enumerable: true, get: function () { return memoryTracker_1.createNativeBuffer; } });
 __exportStar(require("./hooks"), exports);
 /**
  * Creates a new LiteRT-LM inference engine instance.

package/lib/memoryTracker.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Memory tracking utilities for LiteRT-LM using real native memory metrics.
+ *
+ * Records real memory usage from OS-level APIs via `getMemoryUsage()`,
+ * and stores snapshots in a native-backed ArrayBuffer allocated via
+ * `NitroModules.createNativeArrayBuffer()` (v0.34+) for zero-copy interop.
+ *
+ * @example
+ * ```typescript
+ * import { createMemoryTracker } from 'react-native-litert-lm';
+ *
+ * const tracker = createMemoryTracker(100);
+ *
+ * // Record a real snapshot (typically called internally after inference)
+ * tracker.record({
+ *   timestamp: Date.now(),
+ *   nativeHeapBytes: usage.nativeHeapBytes,
+ *   residentBytes: usage.residentBytes,
+ *   availableMemoryBytes: usage.availableMemoryBytes,
+ * });
+ *
+ * console.log(`Peak RSS: ${tracker.getPeakMemory()} bytes`);
+ * ```
+ */
+/**
+ * A single memory usage snapshot with real data from OS APIs.
+ */
+export interface MemorySnapshot {
+    /** Unix timestamp in milliseconds */
+    timestamp: number;
+    /** Native heap allocated bytes (Debug.getNativeHeapAllocatedSize on Android, task_info on iOS) */
+    nativeHeapBytes: number;
+    /** Process resident set size (RSS) in bytes */
+    residentBytes: number;
+    /** Available system memory in bytes */
+    availableMemoryBytes: number;
+}
+/**
+ * Memory tracker that stores snapshots in a native-backed ArrayBuffer.
+ *
+ * Uses `NitroModules.createNativeArrayBuffer()` to allocate the backing
+ * buffer in native (C++) memory, ensuring zero-copy interop with native
+ * methods and keeping memory tracking data off the JS heap.
+ */
+export interface MemoryTracker {
+    /**
+     * Record a new memory snapshot.
+     * @param snapshot The memory usage data to record
+     * @returns true if recorded, false if buffer is full
+     */
+    record(snapshot: MemorySnapshot): boolean;
+    /**
+     * Get all recorded snapshots as structured objects.
+     */
+    getSnapshots(): MemorySnapshot[];
+    /**
+     * Get the number of recorded snapshots.
+     */
+    getSnapshotCount(): number;
+    /**
+     * Get the maximum number of snapshots this tracker can hold.
+     */
+    getCapacity(): number;
+    /**
+     * Get the peak resident set size across all snapshots.
+     */
+    getPeakMemory(): number;
+    /**
+     * Get the latest memory snapshot, or undefined if none recorded.
+     */
+    getLatestSnapshot(): MemorySnapshot | undefined;
+    /**
+     * Get the underlying native ArrayBuffer.
+     * This buffer is allocated via `NitroModules.createNativeArrayBuffer()`
+     * and lives in native memory, enabling zero-copy transfer to native methods.
+     */
+    getNativeBuffer(): ArrayBuffer;
+    /**
+     * Get the Float64Array view over the native buffer.
+     */
+    getView(): Float64Array;
+    /**
+     * Reset the tracker, clearing all recorded snapshots.
+     * The native buffer is preserved (not reallocated).
+     */
+    reset(): void;
+    /**
+     * Get a summary of memory usage statistics.
+     */
+    getSummary(): MemoryTrackerSummary;
+}
+/**
+ * Summary statistics from the memory tracker.
+ */
+export interface MemoryTrackerSummary {
+    /** Number of snapshots recorded */
+    snapshotCount: number;
+    /** Peak resident set size in bytes */
+    peakResidentBytes: number;
+    /** Average resident set size in bytes */
+    averageResidentBytes: number;
+    /** Latest resident set size in bytes */
+    currentResidentBytes: number;
+    /** Peak native heap allocated in bytes */
+    peakNativeHeapBytes: number;
+    /** Latest native heap allocated in bytes */
+    currentNativeHeapBytes: number;
+    /** RSS delta from first to last snapshot in bytes */
+    residentDeltaBytes: number;
+    /** Size of the native tracking buffer itself in bytes */
+    trackerBufferSizeBytes: number;
+}
+/**
+ * Create a new memory tracker backed by a native ArrayBuffer.
+ *
+ * @param maxSnapshots Maximum number of snapshots to store (default: 256)
+ * @returns A MemoryTracker instance
+ */
+export declare function createMemoryTracker(maxSnapshots?: number): MemoryTracker;
+/**
+ * Create a native ArrayBuffer for efficient data transfer.
+ *
+ * A convenience wrapper around `NitroModules.createNativeArrayBuffer()`.
+ *
+ * @param size Size in bytes
+ * @returns A native-backed ArrayBuffer
+ */
+export declare function createNativeBuffer(size: number): ArrayBuffer;