@json-eval-rs/react-native 0.0.74 → 0.0.75

package/android/src/main/cpp/json-eval-rn.cpp

@@ -9,8 +9,6 @@ using namespace jsoneval;
 static jclass gPromiseClass = nullptr;
 static jmethodID gResolveMethodID = nullptr;
 static jmethodID gRejectMethodID = nullptr;
-static jclass gIntegerClass = nullptr;
-static jmethodID gIntegerValueOfMethodID = nullptr;
 
 // Helper functions (C++ linkage - internal use only)
 // Helper to convert jstring to std::string
@@ -51,13 +49,6 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {
     gRejectMethodID = env->GetMethodID(gPromiseClass, "reject", "(Ljava/lang/String;Ljava/lang/String;)V");
     env->DeleteLocalRef(promiseClass);
     
-    // Cache Integer class for cacheLenAsync optimization
-    jclass integerClass = env->FindClass("java/lang/Integer");
-    if (integerClass == nullptr) return JNI_ERR;
-    gIntegerClass = reinterpret_cast<jclass>(env->NewGlobalRef(integerClass));
-    gIntegerValueOfMethodID = env->GetStaticMethodID(gIntegerClass, "valueOf", "(I)Ljava/lang/Integer;");
-    env->DeleteLocalRef(integerClass);
-    
     return JNI_VERSION_1_6;
 }
 
@@ -298,6 +289,26 @@ Java_com_jsonevalrs_JsonEvalRsModule_nativeValidateAsync(
     });
 }
 
+JNIEXPORT void JNICALL
+Java_com_jsonevalrs_JsonEvalRsModule_nativeValidatePathsAsync(
+    JNIEnv* env,
+    jobject /* this */,
+    jstring handle,
+    jstring data,
+    jstring context,
+    jstring pathsJson,
+    jobject promise
+) {
+    std::string handleStr = jstringToString(env, handle);
+    std::string dataStr = jstringToString(env, data);
+    std::string contextStr = jstringToString(env, context);
+    std::string pathsJsonStr = jstringToString(env, pathsJson);
+    
+    runAsyncWithPromise(env, promise, "VALIDATE_PATHS_ERROR", [handleStr, dataStr, contextStr, pathsJsonStr](auto callback) {
+        JsonEvalBridge::validatePathsAsync(handleStr, dataStr, contextStr, pathsJsonStr, callback);
+    });
+}
+
 JNIEXPORT void JNICALL
 Java_com_jsonevalrs_JsonEvalRsModule_nativeEvaluateDependentsAsync(
     JNIEnv* env,
@@ -307,6 +318,7 @@ Java_com_jsonevalrs_JsonEvalRsModule_nativeEvaluateDependentsAsync(
     jstring data,
     jstring context,
     jboolean reEvaluate,
+    jboolean includeSubforms,
     jobject promise
 ) {
     std::string handleStr = jstringToString(env, handle);
@@ -314,9 +326,10 @@ Java_com_jsonevalrs_JsonEvalRsModule_nativeEvaluateDependentsAsync(
     std::string dataStr = jstringToString(env, data);
     std::string contextStr = jstringToString(env, context);
     bool reEval = static_cast<bool>(reEvaluate);
+    bool includeSubf = static_cast<bool>(includeSubforms);
     
-    runAsyncWithPromise(env, promise, "EVALUATE_DEPENDENTS_ERROR", [handleStr, pathStr, dataStr, contextStr, reEval](auto callback) {
-        JsonEvalBridge::evaluateDependentsAsync(handleStr, pathStr, dataStr, contextStr, reEval, callback);
+    runAsyncWithPromise(env, promise, "EVALUATE_DEPENDENTS_ERROR", [handleStr, pathStr, dataStr, contextStr, reEval, includeSubf](auto callback) {
+        JsonEvalBridge::evaluateDependentsAsync(handleStr, pathStr, dataStr, contextStr, reEval, includeSubf, callback);
     });
 }
 
@@ -578,127 +591,6 @@ Java_com_jsonevalrs_JsonEvalRsModule_nativeReloadSchemaFromCacheAsync(
     });
 }
 
-JNIEXPORT void JNICALL
-Java_com_jsonevalrs_JsonEvalRsModule_nativeCacheStatsAsync(
-    JNIEnv* env,
-    jobject /* this */,
-    jstring handle,
-    jobject promise
-) {
-    std::string handleStr = jstringToString(env, handle);
-    
-    runAsyncWithPromise(env, promise, "CACHE_STATS_ERROR", [handleStr](auto callback) {
-        JsonEvalBridge::cacheStatsAsync(handleStr, callback);
-    });
-}
-
-JNIEXPORT void JNICALL
-Java_com_jsonevalrs_JsonEvalRsModule_nativeClearCacheAsync(
-    JNIEnv* env,
-    jobject /* this */,
-    jstring handle,
-    jobject promise
-) {
-    std::string handleStr = jstringToString(env, handle);
-    
-    runAsyncWithPromise(env, promise, "CLEAR_CACHE_ERROR", [handleStr](auto callback) {
-        JsonEvalBridge::clearCacheAsync(handleStr, callback);
-    });
-}
-
-JNIEXPORT void JNICALL
-Java_com_jsonevalrs_JsonEvalRsModule_nativeCacheLenAsync(
-    JNIEnv* env,
-    jobject /* this */,
-    jstring handle,
-    jobject promise
-) {
-    std::string handleStr = jstringToString(env, handle);
-    
-    JavaVM* jvm;
-    env->GetJavaVM(&jvm);
-    jobject globalPromise = env->NewGlobalRef(promise);
-    
-    JsonEvalBridge::cacheLenAsync(handleStr,
-        [jvm, globalPromise](const std::string& result, const std::string& error) {
-            JNIEnv* env = nullptr;
-            jvm->AttachCurrentThread(&env, nullptr);
-            
-            if (error.empty()) {
-                // Optimized: Direct parse and box using cached method IDs
-                jint intValue = std::stoi(result);
-                jobject integerObj = env->CallStaticObjectMethod(gIntegerClass, gIntegerValueOfMethodID, intValue);
-                env->CallVoidMethod(globalPromise, gResolveMethodID, integerObj);
-                env->DeleteLocalRef(integerObj);
-            } else {
-                rejectPromise(env, globalPromise, "CACHE_LEN_ERROR", error);
-            }
-            
-            env->DeleteGlobalRef(globalPromise);
-            jvm->DetachCurrentThread();
-        }
-    );
-}
-
-JNIEXPORT void JNICALL
-Java_com_jsonevalrs_JsonEvalRsModule_nativeValidatePathsAsync(
-    JNIEnv* env,
-    jobject /* this */,
-    jstring handle,
-    jstring data,
-    jstring context,
-    jstring pathsJson,
-    jobject promise
-) {
-    std::string handleStr = jstringToString(env, handle);
-    std::string dataStr = jstringToString(env, data);
-    std::string contextStr = jstringToString(env, context);
-    std::string pathsStr = jstringToString(env, pathsJson);
-    
-    runAsyncWithPromise(env, promise, "VALIDATE_PATHS_ERROR", [handleStr, dataStr, contextStr, pathsStr](auto callback) {
-        JsonEvalBridge::validatePathsAsync(handleStr, dataStr, contextStr, pathsStr, callback);
-    });
-}
-
-JNIEXPORT void JNICALL
-Java_com_jsonevalrs_JsonEvalRsModule_nativeEnableCacheAsync(
-    JNIEnv* env,
-    jobject /* this */,
-    jstring handle,
-    jobject promise
-) {
-    std::string handleStr = jstringToString(env, handle);
-    
-    runAsyncWithPromise(env, promise, "ENABLE_CACHE_ERROR", [handleStr](auto callback) {
-        JsonEvalBridge::enableCacheAsync(handleStr, callback);
-    });
-}
-
-JNIEXPORT void JNICALL
-Java_com_jsonevalrs_JsonEvalRsModule_nativeDisableCacheAsync(
-    JNIEnv* env,
-    jobject /* this */,
-    jstring handle,
-    jobject promise
-) {
-    std::string handleStr = jstringToString(env, handle);
-    
-    runAsyncWithPromise(env, promise, "DISABLE_CACHE_ERROR", [handleStr](auto callback) {
-        JsonEvalBridge::disableCacheAsync(handleStr, callback);
-    });
-}
-
-JNIEXPORT jboolean JNICALL
-Java_com_jsonevalrs_JsonEvalRsModule_nativeIsCacheEnabled(
-    JNIEnv* env,
-    jobject /* this */,
-    jstring handle
-) {
-    std::string handleStr = jstringToString(env, handle);
-    bool enabled = JsonEvalBridge::isCacheEnabled(handleStr);
-    return enabled ? JNI_TRUE : JNI_FALSE;
-}
-
 JNIEXPORT void JNICALL
 Java_com_jsonevalrs_JsonEvalRsModule_nativeDispose(
     JNIEnv* env,
@@ -834,6 +726,7 @@ Java_com_jsonevalrs_JsonEvalRsModule_nativeEvaluateDependentsSubformAsync(
     jstring data,
     jstring context,
     jboolean reEvaluate,
+    jboolean includeSubforms,
     jobject promise
 ) {
     std::string handleStr = jstringToString(env, handle);
@@ -842,9 +735,10 @@ Java_com_jsonevalrs_JsonEvalRsModule_nativeEvaluateDependentsSubformAsync(
     std::string dataStr = jstringToString(env, data);
     std::string contextStr = jstringToString(env, context);
     bool reEval = static_cast<bool>(reEvaluate);
+    bool includeSubf = static_cast<bool>(includeSubforms);
     
-    runAsyncWithPromise(env, promise, "EVALUATE_DEPENDENTS_SUBFORM_ERROR", [handleStr, subformPathStr, changedPathStr, dataStr, contextStr, reEval](auto callback) {
-        JsonEvalBridge::evaluateDependentsSubformAsync(handleStr, subformPathStr, changedPathStr, dataStr, contextStr, reEval, callback);
+    runAsyncWithPromise(env, promise, "EVALUATE_DEPENDENTS_SUBFORM_ERROR", [handleStr, subformPathStr, changedPathStr, dataStr, contextStr, reEval, includeSubf](auto callback) {
+        JsonEvalBridge::evaluateDependentsSubformAsync(handleStr, subformPathStr, changedPathStr, dataStr, contextStr, reEval, includeSubf, callback);
     });
 }
 

package/android/src/main/java/com/jsonevalrs/JsonEvalRsModule.kt

@@ -72,9 +72,10 @@ class JsonEvalRsModule(reactContext: ReactApplicationContext) :
         data: String?,
         context: String?,
         reEvaluate: Boolean,
+        includeSubforms: Boolean,
         promise: Promise
     ) {
-        nativeEvaluateDependentsAsync(handle, changedPathsJson, data ?: "", context ?: "", reEvaluate, promise)
+        nativeEvaluateDependentsAsync(handle, changedPathsJson, data ?: "", context ?: "", reEvaluate, includeSubforms, promise)
     }
 
     @ReactMethod
@@ -232,53 +233,6 @@ class JsonEvalRsModule(reactContext: ReactApplicationContext) :
         }
     }
 
-    @ReactMethod
-    fun cacheStats(
-        handle: String,
-        promise: Promise
-    ) {
-        nativeCacheStatsAsync(handle, promise)
-    }
-
-    @ReactMethod
-    fun clearCache(
-        handle: String,
-        promise: Promise
-    ) {
-        nativeClearCacheAsync(handle, promise)
-    }
-
-    @ReactMethod
-    fun cacheLen(
-        handle: String,
-        promise: Promise
-    ) {
-        nativeCacheLenAsync(handle, promise)
-    }
-
-    @ReactMethod
-    fun enableCache(
-        handle: String,
-        promise: Promise
-    ) {
-        nativeEnableCacheAsync(handle, promise)
-    }
-
-    @ReactMethod
-    fun disableCache(
-        handle: String,
-        promise: Promise
-    ) {
-        nativeDisableCacheAsync(handle, promise)
-    }
-
-    @ReactMethod(isBlockingSynchronousMethod = true)
-    fun isCacheEnabled(
-        handle: String
-    ): Boolean {
-        return nativeIsCacheEnabled(handle)
-    }
-
     @ReactMethod
     fun setTimezoneOffset(
         handle: String,
@@ -390,9 +344,10 @@ class JsonEvalRsModule(reactContext: ReactApplicationContext) :
         data: String?,
         context: String?,
         reEvaluate: Boolean,
+        includeSubforms: Boolean,
         promise: Promise
     ) {
-        nativeEvaluateDependentsSubformAsync(handle, subformPath, changedPath, data ?: "", context ?: "", reEvaluate, promise)
+        nativeEvaluateDependentsSubformAsync(handle, subformPath, changedPath, data ?: "", context ?: "", reEvaluate, includeSubforms, promise)
     }
 
     @ReactMethod
@@ -576,6 +531,7 @@ class JsonEvalRsModule(reactContext: ReactApplicationContext) :
         data: String,
         context: String,
         reEvaluate: Boolean,
+        includeSubforms: Boolean,
         promise: Promise
     )
     private external fun nativeGetEvaluatedSchemaAsync(handle: String, skipLayout: Boolean, promise: Promise)
@@ -590,12 +546,6 @@ class JsonEvalRsModule(reactContext: ReactApplicationContext) :
     private external fun nativeReloadSchemaAsync(handle: String, schema: String, context: String, data: String, promise: Promise)
     private external fun nativeReloadSchemaMsgpackAsync(handle: String, schemaMsgpack: ByteArray, context: String, data: String, promise: Promise)
     private external fun nativeReloadSchemaFromCacheAsync(handle: String, cacheKey: String, context: String, data: String, promise: Promise)
-    private external fun nativeCacheStatsAsync(handle: String, promise: Promise)
-    private external fun nativeClearCacheAsync(handle: String, promise: Promise)
-    private external fun nativeCacheLenAsync(handle: String, promise: Promise)
-    private external fun nativeEnableCacheAsync(handle: String, promise: Promise)
-    private external fun nativeDisableCacheAsync(handle: String, promise: Promise)
-    private external fun nativeIsCacheEnabled(handle: String): Boolean
     private external fun nativeValidatePathsAsync(handle: String, data: String, context: String, pathsJson: String, promise: Promise)
     private external fun nativeResolveLayoutAsync(handle: String, evaluate: Boolean, promise: Promise)
     private external fun nativeCompileAndRunLogicAsync(handle: String, logicStr: String, data: String, context: String, promise: Promise)
@@ -648,7 +598,7 @@ class JsonEvalRsModule(reactContext: ReactApplicationContext) :
 
     private external fun nativeEvaluateSubform(handle: String, subformPath: String, data: String, context: String, pathsJson: String, promise: Promise)
     private external fun nativeValidateSubformAsync(handle: String, subformPath: String, data: String, context: String, promise: Promise)
-    private external fun nativeEvaluateDependentsSubformAsync(handle: String, subformPath: String, changedPath: String, data: String, context: String, reEvaluate: Boolean, promise: Promise)
+    private external fun nativeEvaluateDependentsSubformAsync(handle: String, subformPath: String, changedPath: String, data: String, context: String, reEvaluate: Boolean, includeSubforms: Boolean, promise: Promise)
     private external fun nativeResolveLayoutSubformAsync(handle: String, subformPath: String, evaluate: Boolean, promise: Promise)
     private external fun nativeGetEvaluatedSchemaSubformAsync(handle: String, subformPath: String, resolveLayout: Boolean, promise: Promise)
     private external fun nativeGetSchemaValueSubformAsync(handle: String, subformPath: String, promise: Promise)

package/cpp/json-eval-bridge.cpp

@@ -22,7 +22,7 @@ extern "C" {
     FFIResult json_eval_evaluate(JSONEvalHandle* handle, const char* data, const char* context, const char* paths_json);
     FFIResult json_eval_get_evaluated_schema_msgpack(JSONEvalHandle* handle, bool skip_layout);
     FFIResult json_eval_validate(JSONEvalHandle* handle, const char* data, const char* context);
-    FFIResult json_eval_evaluate_dependents(JSONEvalHandle* handle, const char* changed_path, const char* data, const char* context, int re_evaluate);
+    FFIResult json_eval_evaluate_dependents(JSONEvalHandle* handle, const char* changed_path, const char* data, const char* context, int re_evaluate, int include_subforms);
     FFIResult json_eval_get_evaluated_schema(JSONEvalHandle* handle, bool skip_layout);
     FFIResult json_eval_get_schema_value(JSONEvalHandle* handle);
     FFIResult json_eval_get_schema_value_array(JSONEvalHandle* handle);
@@ -40,19 +40,13 @@ extern "C" {
     FFIResult json_eval_reload_schema_msgpack(JSONEvalHandle* handle, const uint8_t* schema_msgpack, size_t schema_len, const char* context, const char* data);
     FFIResult json_eval_reload_schema_from_cache(JSONEvalHandle* handle, const char* cache_key, const char* context, const char* data);
     JSONEvalHandle* json_eval_new_from_cache(const char* cache_key, const char* context, const char* data);
-    FFIResult json_eval_cache_stats(JSONEvalHandle* handle);
-    FFIResult json_eval_clear_cache(JSONEvalHandle* handle);
-    FFIResult json_eval_cache_len(JSONEvalHandle* handle);
-    FFIResult json_eval_enable_cache(JSONEvalHandle* handle);
-    FFIResult json_eval_disable_cache(JSONEvalHandle* handle);
-    int json_eval_is_cache_enabled(JSONEvalHandle* handle);
     FFIResult json_eval_validate_paths(JSONEvalHandle* handle, const char* data, const char* context, const char* paths_json);
     FFIResult json_eval_evaluate_logic_pure(const char* logic_str, const char* data, const char* context);
     
     // Subform FFI methods
     FFIResult json_eval_evaluate_subform(JSONEvalHandle* handle, const char* subform_path, const char* data, const char* context, const char* paths_json);
     FFIResult json_eval_validate_subform(JSONEvalHandle* handle, const char* subform_path, const char* data, const char* context);
-    FFIResult json_eval_evaluate_dependents_subform(JSONEvalHandle* handle, const char* subform_path, const char* changed_path, const char* data, const char* context, int re_evaluate);
+    FFIResult json_eval_evaluate_dependents_subform(JSONEvalHandle* handle, const char* subform_path, const char* changed_path, const char* data, const char* context, int re_evaluate, int include_subforms);
     FFIResult json_eval_resolve_layout_subform(JSONEvalHandle* handle, const char* subform_path, bool evaluate);
     FFIResult json_eval_get_evaluated_schema_subform(JSONEvalHandle* handle, const char* subform_path, bool resolve_layout);
     FFIResult json_eval_get_schema_value_subform(JSONEvalHandle* handle, const char* subform_path);
@@ -370,9 +364,10 @@ void JsonEvalBridge::evaluateDependentsAsync(
     const std::string& data,
     const std::string& context,
     bool reEvaluate,
+    bool includeSubforms,
     std::function<void(const std::string&, const std::string&)> callback
 ) {
-    runAsync([handleId, changedPathsJson, data, context, reEvaluate]() -> std::string {
+    runAsync([handleId, changedPathsJson, data, context, reEvaluate, includeSubforms]() -> std::string {
         std::lock_guard<std::mutex> lock(handlesMutex);
         auto it = handles.find(handleId);
         if (it == handles.end()) {
@@ -386,7 +381,8 @@ void JsonEvalBridge::evaluateDependentsAsync(
             changedPathsJson.c_str(), 
             dataPtr, 
             ctx,
-            reEvaluate ? 1 : 0
+            reEvaluate ? 1 : 0,
+            includeSubforms ? 1 : 0
         );
         
         if (!result.success) {
@@ -824,151 +820,6 @@ void JsonEvalBridge::reloadSchemaFromCacheAsync(
     }, callback);
 }
 
-void JsonEvalBridge::cacheStatsAsync(
-    const std::string& handleId,
-    std::function<void(const std::string&, const std::string&)> callback
-) {
-    runAsync([handleId]() -> std::string {
-        std::lock_guard<std::mutex> lock(handlesMutex);
-        auto it = handles.find(handleId);
-        if (it == handles.end()) {
-            throw std::runtime_error("Invalid handle");
-        }
-        
-        FFIResult result = json_eval_cache_stats(it->second);
-        
-        if (!result.success) {
-            std::string error = result.error ? result.error : "Unknown error";
-            json_eval_free_result(result);
-            throw std::runtime_error(error);
-        }
-        
-        // Zero-copy: construct string directly from raw pointer
-        std::string resultStr;
-        if (result.data_ptr && result.data_len > 0) {
-            resultStr.assign(reinterpret_cast<const char*>(result.data_ptr), result.data_len);
-        } else {
-            resultStr = "{}";
-        }
-        json_eval_free_result(result);
-        return resultStr;
-    }, callback);
-}
-
-void JsonEvalBridge::clearCacheAsync(
-    const std::string& handleId,
-    std::function<void(const std::string&, const std::string&)> callback
-) {
-    runAsync([handleId]() -> std::string {
-        std::lock_guard<std::mutex> lock(handlesMutex);
-        auto it = handles.find(handleId);
-        if (it == handles.end()) {
-            throw std::runtime_error("Invalid handle");
-        }
-        
-        FFIResult result = json_eval_clear_cache(it->second);
-        
-        if (!result.success) {
-            std::string error = result.error ? result.error : "Unknown error";
-            json_eval_free_result(result);
-            throw std::runtime_error(error);
-        }
-        
-        json_eval_free_result(result);
-        return "{}";
-    }, callback);
-}
-
-void JsonEvalBridge::cacheLenAsync(
-    const std::string& handleId,
-    std::function<void(const std::string&, const std::string&)> callback
-) {
-    runAsync([handleId]() -> std::string {
-        std::lock_guard<std::mutex> lock(handlesMutex);
-        auto it = handles.find(handleId);
-        if (it == handles.end()) {
-            throw std::runtime_error("Invalid handle");
-        }
-        
-        FFIResult result = json_eval_cache_len(it->second);
-        
-        if (!result.success) {
-            std::string error = result.error ? result.error : "Unknown error";
-            json_eval_free_result(result);
-            throw std::runtime_error(error);
-        }
-        
-        // Zero-copy: construct string directly from raw pointer
-        std::string resultStr;
-        if (result.data_ptr && result.data_len > 0) {
-            resultStr.assign(reinterpret_cast<const char*>(result.data_ptr), result.data_len);
-        } else {
-            resultStr = "0";
-        }
-        json_eval_free_result(result);
-        return resultStr;
-    }, callback);
-}
-
-void JsonEvalBridge::enableCacheAsync(
-    const std::string& handleId,
-    std::function<void(const std::string&, const std::string&)> callback
-) {
-    runAsync([handleId]() -> std::string {
-        std::lock_guard<std::mutex> lock(handlesMutex);
-        auto it = handles.find(handleId);
-        if (it == handles.end()) {
-            throw std::runtime_error("Invalid handle");
-        }
-        
-        FFIResult result = json_eval_enable_cache(it->second);
-        
-        if (!result.success) {
-            std::string error = result.error ? result.error : "Unknown error";
-            json_eval_free_result(result);
-            throw std::runtime_error(error);
-        }
-        
-        json_eval_free_result(result);
-        return "";
-    }, callback);
-}
-
-void JsonEvalBridge::disableCacheAsync(
-    const std::string& handleId,
-    std::function<void(const std::string&, const std::string&)> callback
-) {
-    runAsync([handleId]() -> std::string {
-        std::lock_guard<std::mutex> lock(handlesMutex);
-        auto it = handles.find(handleId);
-        if (it == handles.end()) {
-            throw std::runtime_error("Invalid handle");
-        }
-        
-        FFIResult result = json_eval_disable_cache(it->second);
-        
-        if (!result.success) {
-            std::string error = result.error ? result.error : "Unknown error";
-            json_eval_free_result(result);
-            throw std::runtime_error(error);
-        }
-        
-        json_eval_free_result(result);
-        return "";
-    }, callback);
-}
-
-bool JsonEvalBridge::isCacheEnabled(const std::string& handleId) {
-    std::lock_guard<std::mutex> lock(handlesMutex);
-    auto it = handles.find(handleId);
-    if (it == handles.end()) {
-        return false;
-    }
-    
-    int result = json_eval_is_cache_enabled(it->second);
-    return result != 0;
-}
-
 void JsonEvalBridge::resolveLayoutAsync(
     const std::string& handleId,
     bool evaluate,
@@ -1147,9 +998,10 @@ void JsonEvalBridge::evaluateDependentsSubformAsync(
     const std::string& data,
     const std::string& context,
     bool reEvaluate,
+    bool includeSubforms,
     std::function<void(const std::string&, const std::string&)> callback
 ) {
-    runAsync([handleId, subformPath, changedPath, data, context, reEvaluate]() -> std::string {
+    runAsync([handleId, subformPath, changedPath, data, context, reEvaluate, includeSubforms]() -> std::string {
         std::lock_guard<std::mutex> lock(handlesMutex);
         auto it = handles.find(handleId);
         if (it == handles.end()) {
@@ -1158,7 +1010,10 @@ void JsonEvalBridge::evaluateDependentsSubformAsync(
         
         const char* dt = data.empty() ? nullptr : data.c_str();
         const char* ctx = context.empty() ? nullptr : context.c_str();
-        FFIResult result = json_eval_evaluate_dependents_subform(it->second, subformPath.c_str(), changedPath.c_str(), dt, ctx, reEvaluate ? 1 : 0);
+        FFIResult result = json_eval_evaluate_dependents_subform(
+            it->second, subformPath.c_str(), changedPath.c_str(), dt, ctx,
+            reEvaluate ? 1 : 0, includeSubforms ? 1 : 0
+        );
         
         if (!result.success) {
             std::string error = result.error ? result.error : "Unknown error";

package/cpp/json-eval-bridge.h

@@ -114,6 +114,7 @@ public:
         const std::string& data,
         const std::string& context,
         bool reEvaluate,
+        bool includeSubforms,
         std::function<void(const std::string&, const std::string&)> callback
     );
 
@@ -289,63 +290,6 @@ public:
         std::function<void(const std::string&, const std::string&)> callback
     );
 
-    /**
-     * Get cache stats (async)
-     * @param handle Instance handle
-     * @param callback Result callback
-     */
-    static void cacheStatsAsync(
-        const std::string& handle,
-        std::function<void(const std::string&, const std::string&)> callback
-    );
-
-    /**
-     * Clear cache (async)
-     * @param handle Instance handle
-     * @param callback Result callback
-     */
-    static void clearCacheAsync(
-        const std::string& handle,
-        std::function<void(const std::string&, const std::string&)> callback
-    );
-
-    /**
-     * Get cache length (async)
-     * @param handle Instance handle
-     * @param callback Result callback
-     */
-    static void cacheLenAsync(
-        const std::string& handle,
-        std::function<void(const std::string&, const std::string&)> callback
-    );
-
-    /**
-     * Enable evaluation caching (async)
-     * @param handle Instance handle
-     * @param callback Result callback
-     */
-    static void enableCacheAsync(
-        const std::string& handle,
-        std::function<void(const std::string&, const std::string&)> callback
-    );
-
-    /**
-     * Disable evaluation caching (async)
-     * @param handle Instance handle
-     * @param callback Result callback
-     */
-    static void disableCacheAsync(
-        const std::string& handle,
-        std::function<void(const std::string&, const std::string&)> callback
-    );
-
-    /**
-     * Check if caching is enabled (synchronous)
-     * @param handle Instance handle
-     * @returns true if caching is enabled, false otherwise
-     */
-    static bool isCacheEnabled(const std::string& handle);
-
     /**
      * Resolve layout with optional evaluation (async)
      * @param handle Instance handle
@@ -484,6 +428,7 @@ public:
         const std::string& data,
         const std::string& context,
         bool reEvaluate,
+        bool includeSubforms,
         std::function<void(const std::string&, const std::string&)> callback
     );