@onekeyfe/react-native-background-thread 3.0.61 → 3.0.63

package/android/src/main/cpp/cpp-adapter.cpp

@@ -4,7 +4,6 @@
 #include <atomic>
 #include <chrono>
 #include <condition_variable>
-#include <cstdio>
 #include <deque>
 #include <functional>
 #include <memory>
@@ -71,6 +70,166 @@ static std::mutex gWorkMutex;
 static std::unordered_map<int64_t, std::function<void(jsi::Runtime &)>> gPendingWork;
 static int64_t gNextWorkId = 0;
 
+using JavaObjectRef = std::shared_ptr<_jobject>;
+
+static constexpr size_t kRuntimeDrainBatchSize = 64;
+static constexpr size_t kRuntimeQueueWarnThreshold = 128;
+static constexpr size_t kRuntimeQueueWarnInterval = 128;
+
+struct RuntimeWorkQueue {
+    std::deque<std::function<void(jsi::Runtime &)>> items;
+    bool drainScheduled = false;
+};
+
+static RuntimeWorkQueue gMainRuntimeWorkQueue;
+static RuntimeWorkQueue gBgRuntimeWorkQueue;
+
+static RuntimeWorkQueue &getRuntimeWorkQueue(bool isMain) {
+    return isMain ? gMainRuntimeWorkQueue : gBgRuntimeWorkQueue;
+}
+
+static bool callScheduleOnJSThread(const JavaObjectRef &ref, bool isMain, int64_t workId) {
+    JNIEnv *env = getJNIEnv();
+    if (!env || !ref) {
+        LOGE("executor: env=%p, ref=%p — aborting", env, ref.get());
+        return false;
+    }
+
+    jclass cls = env->GetObjectClass(ref.get());
+    if (!cls) {
+        LOGE("executor: GetObjectClass failed");
+        if (env->ExceptionCheck()) {
+            env->ExceptionDescribe();
+            env->ExceptionClear();
+        }
+        return false;
+    }
+
+    jmethodID mid = env->GetMethodID(cls, "scheduleOnJSThread", "(ZJ)Z");
+    if (!mid) {
+        LOGE("executor: scheduleOnJSThread method not found!");
+        if (env->ExceptionCheck()) {
+            env->ExceptionDescribe();
+            env->ExceptionClear();
+        }
+        env->DeleteLocalRef(cls);
+        return false;
+    }
+
+    LOGI("executor: calling scheduleOnJSThread(isMain=%d, workId=%ld)", isMain, (long)workId);
+    jboolean scheduled = env->CallBooleanMethod(
+        ref.get(),
+        mid,
+        static_cast<jboolean>(isMain),
+        static_cast<jlong>(workId));
+    if (env->ExceptionCheck()) {
+        LOGE("executor: JNI exception after scheduleOnJSThread");
+        env->ExceptionDescribe();
+        env->ExceptionClear();
+        env->DeleteLocalRef(cls);
+        return false;
+    }
+    env->DeleteLocalRef(cls);
+    return scheduled == JNI_TRUE;
+}
+
+static void scheduleRuntimeDrain(const JavaObjectRef &ref, bool isMain);
+
+static void drainRuntimeWorkQueue(jsi::Runtime &rt, JavaObjectRef ref, bool isMain) {
+    size_t drained = 0;
+
+    while (drained < kRuntimeDrainBatchSize) {
+        std::function<void(jsi::Runtime &)> work;
+        {
+            std::lock_guard<std::mutex> lock(gWorkMutex);
+            auto &queue = getRuntimeWorkQueue(isMain);
+            if (queue.items.empty()) {
+                break;
+            }
+            work = std::move(queue.items.front());
+            queue.items.pop_front();
+        }
+
+        try {
+            work(rt);
+        } catch (const jsi::JSError &e) {
+            LOGE("JSError in runtime drain work: %s", e.getMessage().c_str());
+        } catch (const std::exception &e) {
+            LOGE("Error in runtime drain work: %s", e.what());
+        } catch (...) {
+            LOGE("Unknown error in runtime drain work");
+        }
+        drained += 1;
+    }
+
+    bool shouldReschedule = false;
+    size_t remaining = 0;
+    {
+        std::lock_guard<std::mutex> lock(gWorkMutex);
+        auto &queue = getRuntimeWorkQueue(isMain);
+        remaining = queue.items.size();
+        if (remaining == 0) {
+            queue.drainScheduled = false;
+        } else {
+            shouldReschedule = true;
+        }
+    }
+
+    if (drained > 1 || remaining > 0) {
+        LOGI("executor: drained runtime queue isMain=%d, drained=%zu, remaining=%zu",
+             isMain, drained, remaining);
+    }
+
+    if (shouldReschedule) {
+        scheduleRuntimeDrain(ref, isMain);
+    }
+}
+
+static void scheduleRuntimeDrain(const JavaObjectRef &ref, bool isMain) {
+    int64_t workId;
+    size_t queued = 0;
+    {
+        std::lock_guard<std::mutex> lock(gWorkMutex);
+        workId = gNextWorkId++;
+        queued = getRuntimeWorkQueue(isMain).items.size();
+        gPendingWork[workId] = [ref, isMain](jsi::Runtime &rt) {
+            drainRuntimeWorkQueue(rt, ref, isMain);
+        };
+    }
+
+    bool scheduled = callScheduleOnJSThread(ref, isMain, workId);
+    if (!scheduled) {
+        std::lock_guard<std::mutex> lock(gWorkMutex);
+        gPendingWork.erase(workId);
+        getRuntimeWorkQueue(isMain).drainScheduled = false;
+        LOGE("executor: failed to schedule runtime drain isMain=%d, workId=%ld, queued=%zu",
+             isMain, (long)workId, queued);
+    }
+}
+
+static void enqueueRuntimeWork(JavaObjectRef ref, bool isMain, std::function<void(jsi::Runtime &)> work) {
+    bool shouldSchedule = false;
+    size_t queued = 0;
+    {
+        std::lock_guard<std::mutex> lock(gWorkMutex);
+        auto &queue = getRuntimeWorkQueue(isMain);
+        queue.items.push_back(std::move(work));
+        queued = queue.items.size();
+        if (!queue.drainScheduled) {
+            queue.drainScheduled = true;
+            shouldSchedule = true;
+        }
+    }
+
+    if (queued >= kRuntimeQueueWarnThreshold && queued % kRuntimeQueueWarnInterval == 0) {
+        LOGE("executor: runtime queue backlog isMain=%d, queued=%zu", isMain, queued);
+    }
+
+    if (shouldSchedule) {
+        scheduleRuntimeDrain(ref, isMain);
+    }
+}
+
 // Called from Kotlin after runOnJSQueueThread dispatches to the correct thread.
 extern "C" JNIEXPORT void JNICALL
 Java_com_backgroundthread_BackgroundThreadManager_nativeExecuteWork(
@@ -448,323 +607,6 @@ static void installTimersOnRuntime(jsi::Runtime &rt) {
     LOGI("Timer + rAF + rIC polyfills installed on bg runtime");
 }
 
-// ── Background segment eval (fix A: eval-then-resolve on the BG runtime) ──
-//
-// WHY THIS EXISTS — the "Requiring unknown module" race on the BACKGROUND
-// runtime:
-// The Kotlin BackgroundThreadManager.registerSegmentInBackground previously
-// called `ReactContext.registerSegment(...)`, which (bridgeless) routes through
-// ReactHostImpl.registerSegment → ReactInstance.registerSegment → C++
-// ReactInstance::registerSegment, and that only `scheduleWork`s the
-// evaluateJavaScript onto the RuntimeScheduler before returning. The Kotlin
-// completion callback then fired immediately, so the JS promise resolved BEFORE
-// the segment's `__d(...)` module definitions ran. Metro's
-// `import().then(() => __r(moduleId))` could then run `__r` before the module
-// table was populated → a fatal, uncatchable "Requiring unknown module". Locale
-// segments load through THIS bg path, so a language switch could still crash.
-//
-// THE FIX (mirrors the MAIN-runtime SplitBundleLoaderJSI fix and the iOS
-// callFunctionOnBufferedRuntimeExecutor: fix):
-// We evaluate the segment OURSELVES on the BACKGROUND JS thread and signal
-// completion in the SAME block, strictly AFTER eval. The accessor we use is the
-// background runtime's own RuntimeExecutor (`gBgTimerExecutor`), captured in
-// nativeInstallSharedBridge for the bg runtime (isMain=false). It dispatches via
-// scheduleOnJSThread(isMain=false, ...) → nativeExecuteWork, which runs the work
-// on the bg JS queue thread and then drainMicrotasks() — so this targets the
-// BACKGROUND runtime, NOT the main one. This is the correct bg analogue of the
-// main path's CallInvoker (the bg runtime is created by ReactHostImpl and the bg
-// ReactContext does not surface a usable jsCallInvokerHolder the way the main
-// one does, but its RuntimeExecutor already exists and routes to the bg JS
-// thread).
-//
-// Off-thread read (fix F): the segment file is read on the CALLING (native
-// module) thread before dispatch; only evaluateJavaScript + completion run on
-// the bg JS thread.
-
-// Java callback contract — implemented in Kotlin as
-// BackgroundThreadManager.SegmentEvalCallback.onComplete(error). Empty/null
-// error string → success. A message prefixed with "NO_RUNTIME:" → bg runtime
-// not ready (retryable); "IO_ERROR:" → file read failure (fatal); otherwise →
-// eval throw (fatal). Resolved exactly once on the Kotlin side via its watchdog
-// guard.
-static void invokeBgSegmentCallback(jobject globalCallback, const std::string &error) {
-    JNIEnv *env = getJNIEnv();
-    if (!env || !globalCallback) {
-        return;
-    }
-    jclass cls = env->GetObjectClass(globalCallback);
-    jmethodID mid =
-        env->GetMethodID(cls, "onComplete", "(Ljava/lang/String;)V");
-    if (mid) {
-        jstring jerr = error.empty() ? nullptr : env->NewStringUTF(error.c_str());
-        env->CallVoidMethod(globalCallback, mid, jerr);
-        if (env->ExceptionCheck()) {
-            LOGE("invokeBgSegmentCallback: JNI exception after onComplete");
-            env->ExceptionDescribe();
-            env->ExceptionClear();
-        }
-        if (jerr) {
-            env->DeleteLocalRef(jerr);
-        }
-    } else {
-        LOGE("invokeBgSegmentCallback: onComplete method not found!");
-        if (env->ExceptionCheck()) {
-            env->ExceptionDescribe();
-            env->ExceptionClear();
-        }
-    }
-    env->DeleteLocalRef(cls);
-}
-
-// ── Pending bg-eval callback registry (fix: bounded global-ref lifetime) ──
-//
-// The bg-eval work lambda captures a JNI global ref to the SegmentEvalCallback
-// and is enqueued onto gPendingWork for the bg JS thread. If that work is
-// enqueued but NEVER runs, the captured global ref would leak and the JS promise
-// would settle only via the Kotlin 30s watchdog. The drop paths that release it:
-//   - Java schedule fails (JNI exception / missing scheduleOnJSThread): the C++
-//     executor erases gPendingWork[workId] and drains this eval.
-//   - bg context==null / ptr==0 in scheduleOnJSThread: Kotlin calls
-//     nativeDropScheduledWork(workId) — which erases the work AND drains —
-//     BEFORE it would call nativeExecuteWork. (nativeExecuteWork's own
-//     rt==nullptr guard merely returns and is NOT a drain path; it is never
-//     reached for a dead ptr because Kotlin intercepts that case first.)
-//   - nativeDestroy: intentionally leaks the work lambdas (their ~jsi::Function
-//     can't run on a torn-down runtime) but drains this registry to settle them.
-// To make this strictly bounded, every in-flight bg eval registers here. Whoever
-// settles it first (the work lambda after eval, OR a drain on a drop path) claims
-// it via `settled`, invokes the Java callback exactly once, and deletes the
-// global ref. This guarantees no leak and no double-invoke.
-struct PendingBgEval {
-    jobject globalCallback;                  // owned: deleted by whoever settles
-    std::shared_ptr<std::atomic<bool>> settled;  // exactly-once claim
-};
-static std::mutex gBgEvalMutex;
-static std::unordered_map<int64_t, PendingBgEval> gPendingBgEvals;
-static int64_t gNextBgEvalId = 0;
-
-// Settle a pending bg eval exactly once: invoke the Java callback with `error`
-// (empty => success) and release the global ref. The shared `settled` flag is
-// the single source of truth for the one-shot — the registry entry may already
-// be gone (claimed/erased by the other party), so this is self-contained.
-static void settleBgEval(jobject globalCallback,
-                         const std::shared_ptr<std::atomic<bool>> &settled,
-                         const std::string &error) {
-    if (!settled) {
-        return;
-    }
-    bool expected = false;
-    if (!settled->compare_exchange_strong(expected, true)) {
-        // Already settled by the other party (lambda vs drain). Do nothing —
-        // the winner already invoked + deleted the global ref.
-        return;
-    }
-    invokeBgSegmentCallback(globalCallback, error);
-    JNIEnv *env = getJNIEnv();
-    if (env && globalCallback) {
-        env->DeleteGlobalRef(globalCallback);
-    }
-}
-
-// Settle ALL currently-registered bg evals with a retryable NO_RUNTIME-class
-// failure and clear the registry. Used when the bg runtime is going away (or is
-// unreachable) and any enqueued-but-unrun eval would otherwise leak its global
-// ref and hang the JS promise until the Kotlin watchdog. Each settle is
-// exactly-once (the work lambda may race us, but the shared flag arbitrates),
-// so this never double-invokes.
-static void drainPendingBgEvals(const std::string &reason) {
-    // Move the entries OUT under the lock and clear the registry, then settle
-    // OUTSIDE the lock. settleBgEval performs a Java upcall (onComplete via
-    // CallVoidMethod), so holding gBgEvalMutex across it would hold a native
-    // lock across arbitrary JS — a re-entrancy / deadlock hazard if a callback
-    // ever synchronously re-enters a gBgEvalMutex-taking path. PendingBgEval is
-    // copyable (jobject handle + shared_ptr); copies share the same global ref
-    // and `settled` flag, and the shared flag still arbitrates exactly-once
-    // against a racing work lambda, so the global ref is released exactly once.
-    std::vector<PendingBgEval> drained;
-    {
-        std::lock_guard<std::mutex> lock(gBgEvalMutex);
-        if (gPendingBgEvals.empty()) {
-            return;
-        }
-        LOGE("[SplitBundle] draining %zu pending bg eval(s): %s",
-             gPendingBgEvals.size(), reason.c_str());
-        drained.reserve(gPendingBgEvals.size());
-        for (auto &entry : gPendingBgEvals) {
-            drained.push_back(entry.second);
-        }
-        gPendingBgEvals.clear();
-    }
-    for (auto &entry : drained) {
-        settleBgEval(entry.globalCallback, entry.settled, "NO_RUNTIME:" + reason);
-    }
-}
-
-// Reads the whole file at `path` into `out`. Returns false on failure.
-static bool readBgFileToString(const std::string &path, std::string &out) {
-    FILE *f = std::fopen(path.c_str(), "rb");
-    if (f == nullptr) {
-        return false;
-    }
-    if (std::fseek(f, 0, SEEK_END) != 0) {
-        std::fclose(f);
-        return false;
-    }
-    long size = std::ftell(f);
-    if (size < 0) {
-        std::fclose(f);
-        return false;
-    }
-    if (std::fseek(f, 0, SEEK_SET) != 0) {
-        std::fclose(f);
-        return false;
-    }
-    out.resize(static_cast<size_t>(size));
-    size_t readBytes =
-        (size == 0) ? 0 : std::fread(&out[0], 1, static_cast<size_t>(size), f);
-    std::fclose(f);
-    return readBytes == static_cast<size_t>(size);
-}
-
-// nativeEvaluateSegmentInBackground: schedule eval of the segment at `path`
-// onto the BACKGROUND JS thread via the bg RuntimeExecutor and invoke `callback`
-// from INSIDE that same block, strictly AFTER eval. Returns immediately; the
-// callback fires later on the bg JS thread (or synchronously here on a fail-fast
-// path such as bg runtime not ready / file read failure).
-extern "C" JNIEXPORT void JNICALL
-Java_com_backgroundthread_BackgroundThreadManager_nativeEvaluateSegmentInBackground(
-    JNIEnv *env, jobject /* thiz */, jstring segmentPath, jstring sourceURL,
-    jobject callback) {
-
-    // Global-ref the callback: it is invoked later on a different thread.
-    jobject globalCallback = env->NewGlobalRef(callback);
-    // Shared one-shot claim flag for this eval — used by BOTH the work lambda
-    // (after eval) and any drop-path drain, so exactly one of them invokes the
-    // callback + deletes the global ref.
-    auto settled = std::make_shared<std::atomic<bool>>(false);
-
-    const char *pathChars = segmentPath ? env->GetStringUTFChars(segmentPath, nullptr) : nullptr;
-    std::string path = pathChars ? std::string(pathChars) : std::string();
-    if (pathChars) env->ReleaseStringUTFChars(segmentPath, pathChars);
-
-    const char *urlChars = sourceURL ? env->GetStringUTFChars(sourceURL, nullptr) : nullptr;
-    std::string url = urlChars ? std::string(urlChars) : std::string("segment");
-    if (urlChars) env->ReleaseStringUTFChars(sourceURL, urlChars);
-
-    // Fail-fast on THIS thread: settle exactly once, no registry entry created.
-    auto finishOnThisThread = [&](const std::string &err) {
-        settleBgEval(globalCallback, settled, err);
-    };
-
-    if (path.empty()) {
-        finishOnThisThread("IO_ERROR:Empty segment path");
-        return;
-    }
-
-    // Snapshot the bg RuntimeExecutor under the timer mutex (the same lock that
-    // guards its assignment/teardown). If it's null the bg runtime hasn't
-    // installed its SharedBridge yet → retryable NO_RUNTIME.
-    RPCRuntimeExecutor executor;
-    {
-        std::lock_guard<std::mutex> lock(gTimerMutex);
-        executor = gBgTimerExecutor;
-    }
-    if (!executor) {
-        finishOnThisThread("NO_RUNTIME:Background runtime executor not available");
-        return;
-    }
-
-    // F: read the segment file HERE, on the calling (native module) thread,
-    // BEFORE dispatch — so only evaluateJavaScript + completion run on the bg JS
-    // thread and the read does not block it or race the watchdog.
-    std::string source;
-    if (!readBgFileToString(path, source)) {
-        finishOnThisThread("IO_ERROR:Failed to read bg segment file: " + path);
-        return;
-    }
-    if (source.empty()) {
-        finishOnThisThread("IO_ERROR:Empty bg segment file: " + path);
-        return;
-    }
-
-    // Register this in-flight eval BEFORE dispatch so that if the enqueued work
-    // never runs (schedule fails, context==null, ptr==0, or nativeDestroy drops
-    // pending work) the drain can settle it as a retryable NO_RUNTIME failure
-    // and release the global ref — instead of leaking it and leaning on the
-    // Kotlin 30s watchdog. The work lambda removes its own entry when it runs.
-    int64_t bgEvalId;
-    {
-        std::lock_guard<std::mutex> lock(gBgEvalMutex);
-        bgEvalId = gNextBgEvalId++;
-        gPendingBgEvals[bgEvalId] = PendingBgEval{globalCallback, settled};
-    }
-
-    // Move the already-read buffer + the global callback ref into the work
-    // lambda. The lambda runs on the bg JS thread (via nativeExecuteWork), which
-    // also drainMicrotasks() after — preserving eval+resolve as one atomic turn.
-    executor([globalCallback, settled, bgEvalId, source = std::move(source),
-              url = std::move(url)](jsi::Runtime &rt) {
-        // We are running now → claim ownership and remove our registry entry so
-        // a concurrent nativeDestroy drain can't also touch this eval.
-        {
-            std::lock_guard<std::mutex> lock(gBgEvalMutex);
-            gPendingBgEvals.erase(bgEvalId);
-        }
-        std::string error;
-        try {
-            LOGI("[SplitBundle] bg evaluating segment %s (%zu bytes)", url.c_str(),
-                 source.size());
-            auto buffer =
-                std::make_shared<jsi::StringBuffer>(std::move(source));
-            // Runs the segment's top-level __d(...) synchronously on the bg JS
-            // thread before returning.
-            rt.evaluateJavaScript(std::move(buffer), url);
-            LOGI("[SplitBundle] bg segment %s evaluated", url.c_str());
-        } catch (const jsi::JSError &e) {
-            error = std::string("Bg segment eval JSError for ") + url + ": " +
-                    e.getMessage();
-            LOGE("[SplitBundle] %s", error.c_str());
-        } catch (const std::exception &e) {
-            error = std::string("Bg segment eval failed for ") + url + ": " +
-                    e.what();
-            LOGE("[SplitBundle] %s", error.c_str());
-        } catch (...) {
-            error = std::string("Bg segment eval failed for ") + url +
-                    " (unknown C++ exception)";
-            LOGE("[SplitBundle] %s", error.c_str());
-        }
-        // Resolve/reject from INSIDE this same bg-JS-thread block, strictly
-        // AFTER eval above — the ordering guarantee that fixes the race. The
-        // shared `settled` flag makes this a no-op if a drain already claimed
-        // it (it would not have, since we erased our entry above, but the flag
-        // keeps the invariant airtight against any reorder).
-        settleBgEval(globalCallback, settled, error);
-    });
-}
-
-// nativeDropScheduledWork: clean up after a scheduleOnJSThread drop path where
-// CallVoidMethod itself SUCCEEDED but Kotlin then found the bg runtime
-// unreachable (context==null / ptr==0) and returned WITHOUT calling
-// nativeExecuteWork for this `workId`. Two things must be released:
-//   1. gPendingWork[workId] — the stored work lambda (holding the segment
-//      SOURCE BUFFER). nativeExecuteWork is the only other eraser and it will
-//      never run for this id, so without this it leaks until nativeDestroy.
-//   2. The in-flight bg eval(s) — settle as retryable NO_RUNTIME so the JNI
-//      global ref is released and the JS promise resolves now instead of
-//      hanging on the 30s watchdog. drain-all is sound: an unreachable bg JS
-//      thread dooms every enqueued bg eval equally.
-// Exactly-once via the shared `settled` flag, so a recovered runtime that later
-// DOES run stale work (it can't — we erased it) would be a harmless no-op.
-extern "C" JNIEXPORT void JNICALL
-Java_com_backgroundthread_BackgroundThreadManager_nativeDropScheduledWork(
-    JNIEnv * /* env */, jobject /* thiz */, jlong workId) {
-    {
-        std::lock_guard<std::mutex> lock(gWorkMutex);
-        gPendingWork.erase(static_cast<int64_t>(workId));
-    }
-    drainPendingBgEvals("Background runtime unreachable when scheduling segment eval");
-}
-
 // ── nativeInstallSharedBridge ───────────────────────────────────────────
 // Install SharedStore and SharedRPC into a runtime.
 extern "C" JNIEXPORT void JNICALL
@@ -788,71 +630,7 @@ Java_com_backgroundthread_BackgroundThreadManager_nativeInstallSharedBridge(
     bool capturedIsMain = static_cast<bool>(isMain);
 
     RPCRuntimeExecutor executor = [ref, capturedIsMain](std::function<void(jsi::Runtime &)> work) {
-        JNIEnv *env = getJNIEnv();
-
-        // Settle any enqueued-but-now-unrunnable bg eval when this work will NOT
-        // reach nativeExecuteWork. Bg eval lambdas are only ever dispatched via
-        // the bg executor, so this is gated on !capturedIsMain — a main-thread
-        // schedule hiccup must never falsely reject healthy bg evals. This
-        // mirrors the existing context==null / ptr==0 (nativeDropScheduledWork)
-        // and nativeDestroy drop paths: drain-all is sound because a failed bg
-        // schedule means the bg JS thread is unreachable, so every enqueued bg
-        // eval is equally doomed. NO_RUNTIME is retryable, so JS re-attempts.
-        auto drainBgEvalsIfBg = [capturedIsMain](const char *reason) {
-            if (!capturedIsMain) {
-                drainPendingBgEvals(reason);
-            }
-        };
-
-        if (!env || !ref) {
-            LOGE("executor: env=%p, ref=%p — aborting", env, ref.get());
-            drainBgEvalsIfBg("Background executor env/ref unavailable when scheduling segment eval");
-            return;
-        }
-
-        int64_t workId;
-        {
-            std::lock_guard<std::mutex> lock(gWorkMutex);
-            workId = gNextWorkId++;
-            gPendingWork[workId] = std::move(work);
-        }
-
-        jclass cls = env->GetObjectClass(ref.get());
-        jmethodID mid = env->GetMethodID(cls, "scheduleOnJSThread", "(ZJ)V");
-        bool scheduled = false;
-        if (mid) {
-            LOGI("executor: calling scheduleOnJSThread(isMain=%d, workId=%ld)", capturedIsMain, (long)workId);
-            env->CallVoidMethod(ref.get(), mid, static_cast<jboolean>(capturedIsMain), static_cast<jlong>(workId));
-            if (env->ExceptionCheck()) {
-                LOGE("executor: JNI exception after scheduleOnJSThread");
-                env->ExceptionDescribe();
-                env->ExceptionClear();
-            } else {
-                scheduled = true;
-            }
-        } else {
-            LOGE("executor: scheduleOnJSThread method not found!");
-            if (env->ExceptionCheck()) {
-                env->ExceptionDescribe();
-                env->ExceptionClear();
-            }
-        }
-        env->DeleteLocalRef(cls);
-
-        // Schedule failed (JNI exception or missing method): nativeExecuteWork
-        // will never run this workId, so erase it now to free the stored work
-        // (and its captured segment source buffer) instead of leaking it until
-        // nativeDestroy. Then settle the corresponding bg eval(s) so the JNI
-        // global ref is released and the JS promise resolves immediately rather
-        // than hanging on the Kotlin 30s watchdog. Erasing also makes a late
-        // Kotlin enqueue (if scheduleOnJSThread threw AFTER posting) a no-op.
-        if (!scheduled) {
-            {
-                std::lock_guard<std::mutex> lock(gWorkMutex);
-                gPendingWork.erase(workId);
-            }
-            drainBgEvalsIfBg("Background JS thread unreachable when scheduling segment eval");
-        }
+        enqueueRuntimeWork(ref, capturedIsMain, std::move(work));
     };
 
     std::string runtimeId = isMain ? "main" : "background";
@@ -998,24 +776,20 @@ Java_com_backgroundthread_BackgroundThreadManager_nativeDestroy(
     // Drain pending cross-runtime work. Each std::function may capture a
     // shared_ptr<jsi::Function> tied to the destroyed runtime; leak them
     // for the same reason as above.
-    //
-    // NOTE: the bg-eval work lambdas captured here also hold a JNI global ref
-    // to a SegmentEvalCallback. Leaking the std::function leaks that ref AND
-    // leaves the JS promise pending — so we settle those explicitly below via
-    // gPendingBgEvals (the entry survives independently of the leaked lambda).
     {
         std::lock_guard<std::mutex> lock(gWorkMutex);
         for (auto &entry : gPendingWork) {
             new std::function<void(jsi::Runtime &)>(std::move(entry.second));
         }
         gPendingWork.clear();
+        for (auto *queue : {&gMainRuntimeWorkQueue, &gBgRuntimeWorkQueue}) {
+            for (auto &work : queue->items) {
+                new std::function<void(jsi::Runtime &)>(std::move(work));
+            }
+            queue->items.clear();
+            queue->drainScheduled = false;
+        }
     }
 
-    // Drain pending bg-eval callbacks: the bg runtime is gone, so any eval that
-    // was enqueued but never ran must be settled NOW (retryable NO_RUNTIME) so
-    // the JS promise resolves immediately and the global ref is released —
-    // rather than leaking and relying on the Kotlin 30s watchdog.
-    drainPendingBgEvals("Background runtime destroyed before segment eval ran");
-
     LOGI("Native resources cleaned up");
 }

package/android/src/main/java/com/backgroundthread/BackgroundThreadManager.kt

@@ -24,7 +24,6 @@ import com.facebook.react.shell.MainReactPackage
 import java.io.File
 import java.lang.ref.WeakReference
 import java.util.concurrent.TimeUnit
-import java.util.concurrent.atomic.AtomicBoolean
 
 /**
  * Singleton manager for the background React Native runtime.
@@ -64,12 +63,6 @@ class BackgroundThreadManager private constructor() {
     companion object {
         private const val MODULE_NAME = "background"
 
-        // Bounded watchdog: if the bg JS thread never drains to our scheduled
-        // eval (e.g. the bg entry bundle never finished evaluating), reject as a
-        // RETRYABLE timeout rather than leaving the JS promise pending forever.
-        // Matches the main-runtime SplitBundleLoader watchdog.
-        private const val BG_SEGMENT_EVAL_TIMEOUT_MS = 30_000L
-
         init {
             System.loadLibrary("background_thread")
         }
@@ -85,20 +78,6 @@ class BackgroundThreadManager private constructor() {
         }
     }
 
-    /**
-     * Completion contract invoked by the native (JNI) side AFTER the bg segment
-     * has been evaluated into the BACKGROUND runtime. Called from the bg JS
-     * thread (or synchronously on the caller thread for fail-fast paths).
-     *
-     * @param error null on success; a non-empty message on failure. A message
-     *   prefixed with "NO_RUNTIME:" means the bg runtime is not ready yet
-     *   (retryable); "IO_ERROR:" means the segment file read failed (fatal);
-     *   any other message is a segment JS/Hermes eval throw (fatal).
-     */
-    fun interface SegmentEvalCallback {
-        fun onComplete(error: String?)
-    }
-
     // ── JNI declarations ────────────────────────────────────────────────────
 
     private external fun nativeInstallSharedBridge(runtimePtr: Long, isMain: Boolean)
@@ -106,34 +85,6 @@ class BackgroundThreadManager private constructor() {
     private external fun nativeDestroy()
     private external fun nativeExecuteWork(runtimePtr: Long, workId: Long)
 
-    /**
-     * Evaluate the segment at [segmentPath] into the BACKGROUND runtime on its
-     * JS thread and invoke [callback] from inside that same JS-thread block,
-     * strictly AFTER the segment's `__d(...)` module definitions have run. This
-     * is the ordering guarantee that fixes the bg "Requiring unknown module"
-     * race (the bg analogue of the main-runtime SplitBundleLoaderJSI fix).
-     *
-     * Returns immediately; [callback] fires later on the bg JS thread (or
-     * synchronously on the calling thread for fail-fast paths such as the bg
-     * runtime not being ready or the segment file failing to read).
-     */
-    private external fun nativeEvaluateSegmentInBackground(
-        segmentPath: String,
-        sourceURL: String,
-        callback: SegmentEvalCallback
-    )
-
-    /**
-     * Settle every in-flight bg segment eval as a retryable NO_RUNTIME failure
-     * without tearing the runtime down. Called from [scheduleOnJSThread] when
-     * the bg runtime is momentarily unreachable (context == null / ptr == 0) so
-     * any eval enqueued onto the native pending-work map — which will never be
-     * drained on the JS thread in that state — releases its JNI global ref and
-     * settles the JS promise immediately, instead of leaking until the next
-     * teardown or relying on the bg watchdog. Exactly-once on the native side.
-     */
-    private external fun nativeDropScheduledWork(workId: Long)
-
     /**
      * Synchronously mark the SharedRPC listener for `runtimeId` as dead
      * before the underlying JS runtime is torn down. See
@@ -456,140 +407,87 @@ class BackgroundThreadManager private constructor() {
      * Routes to main or background runtime's JS queue thread, then calls nativeExecuteWork.
      */
     @DoNotStrip
-    fun scheduleOnJSThread(isMain: Boolean, workId: Long) {
+    fun scheduleOnJSThread(isMain: Boolean, workId: Long): Boolean {
         val context = if (isMain) mainReactContext else bgReactHost?.currentReactContext
         BTLogger.info("scheduleOnJSThread: isMain=$isMain, workId=$workId, context=${context != null}")
         if (context == null) {
             BTLogger.error("scheduleOnJSThread: context is null! isMain=$isMain, mainCtx=${mainReactContext != null}, bgHost=${bgReactHost != null}, bgCtx=${bgReactHost?.currentReactContext != null}")
-            // The just-enqueued native work will never reach the bg JS thread.
-            // Drop it now: erase gPendingWork[workId] (frees the captured segment
-            // source buffer) and, if it was a bg segment eval, settle it
-            // (retryable NO_RUNTIME) so its JNI global ref is released and the JS
-            // promise resolves instead of leaking until teardown / the bg watchdog.
-            if (!isMain) {
-                nativeDropScheduledWork(workId)
-            }
-            return
+            return false
         }
-        context.runOnJSQueueThread {
-            // Re-read ptr inside the block — if a reload happened between
-            // scheduling and execution, the old ptr may be stale.
-            val ptr = if (isMain) mainRuntimePtr else bgRuntimePtr
-            BTLogger.info("scheduleOnJSThread runOnJSQueueThread: isMain=$isMain, workId=$workId, ptr=$ptr")
-            if (ptr != 0L) {
-                try {
-                    nativeExecuteWork(ptr, workId)
-                } catch (e: Exception) {
-                    BTLogger.error("Error executing work on JS thread: ${e.message}")
-                }
-            } else {
-                BTLogger.error("scheduleOnJSThread: ptr is 0! isMain=$isMain")
-                // Same as the null-context case: the work won't run on this
-                // (stale/torn-down) bg runtime. Drop gPendingWork[workId] (frees
-                // the source buffer) and settle any pending bg eval so it doesn't
-                // leak its global ref / hang the JS promise.
-                if (!isMain) {
-                    nativeDropScheduledWork(workId)
+        return try {
+            val posted = context.runOnJSQueueThread {
+                // Re-read ptr inside the block — if a reload happened between
+                // scheduling and execution, the old ptr may be stale.
+                val ptr = if (isMain) mainRuntimePtr else bgRuntimePtr
+                BTLogger.info("scheduleOnJSThread runOnJSQueueThread: isMain=$isMain, workId=$workId, ptr=$ptr")
+                if (ptr != 0L) {
+                    try {
+                        nativeExecuteWork(ptr, workId)
+                    } catch (e: Exception) {
+                        BTLogger.error("Error executing work on JS thread: ${e.message}")
+                    }
+                } else {
+                    BTLogger.error("scheduleOnJSThread: ptr is 0! isMain=$isMain")
                 }
             }
+            if (!posted) {
+                BTLogger.error("scheduleOnJSThread: runOnJSQueueThread rejected workId=$workId isMain=$isMain")
+            }
+            posted
+        } catch (e: Exception) {
+            BTLogger.error("scheduleOnJSThread: failed to post workId=$workId isMain=$isMain error=${e.message}")
+            false
         }
     }
 
     // ── Segment Registration (Phase 2.5 spike) ─────────────────────────────
 
     /**
-     * Evaluate a HBC segment into the background runtime with completion
-     * callback (fix A: eval-then-resolve).
+     * Register a HBC segment in the background runtime.
+     * Uses CatalystInstance.registerSegment() on the background ReactContext.
      *
-     * Previously this called `ReactContext.registerSegment(...)`, whose
-     * completion fires BEFORE the segment bytecode is evaluated into the runtime
-     * (registerSegment only ENQUEUES the eval). That races Metro's
-     * `import().then(() => __r(moduleId))` and produces a fatal, uncatchable
-     * "Requiring unknown module" — locale segments load through this bg path, so
-     * a language switch could still crash. We now evaluate the segment OURSELVES
-     * on the bg JS thread via [nativeEvaluateSegmentInBackground] and resolve
-     * ONLY after eval completes, so eval + resolve are one atomic JS-thread turn.
+     * @param segmentId The segment ID to register
+     * @param path Absolute file path to the .seg.hbc file
+     * @throws IllegalStateException if background runtime is not started
+     * @throws IllegalArgumentException if segment file does not exist
+     */
+    /**
+     * Register a HBC segment in the background runtime with completion callback.
+     * Dispatches to the background JS queue thread and invokes the callback
+     * only after registerSegment has actually executed.
      *
-     * @param segmentId The segment ID (used only for the synthetic source URL)
+     * @param segmentId The segment ID to register
      * @param path Absolute file path to the .seg.hbc file
-     * @param onComplete Called with (code=null) on success, or
-     *   (code=<contract reject code>, message) on failure. The code is one of
-     *   the SHARED split-bundle contract codes so the JS loader's retryable set
-     *   { SPLIT_BUNDLE_NO_RUNTIME, SPLIT_BUNDLE_TIMEOUT } classifies correctly.
+     * @param onComplete Called with null on success, or an Exception on failure
      */
-    fun registerSegmentInBackground(
-        segmentId: Int,
-        path: String,
-        onComplete: (code: String?, message: String?) -> Unit
-    ) {
+    fun registerSegmentInBackground(segmentId: Int, path: String, onComplete: (Exception?) -> Unit) {
         if (!isStarted) {
-            // Bg runtime not started yet → retryable (the loader will re-attempt
-            // once the bg host is up).
-            onComplete("SPLIT_BUNDLE_NO_RUNTIME", "Background runtime not started")
+            onComplete(IllegalStateException("Background runtime not started"))
             return
         }
 
         val file = File(path)
         if (!file.exists()) {
-            onComplete("SPLIT_BUNDLE_NOT_FOUND", "Segment file not found: $path")
+            onComplete(IllegalArgumentException("Segment file not found: $path"))
             return
         }
 
         val context = bgReactHost?.currentReactContext
         if (context == null) {
-            onComplete("SPLIT_BUNDLE_NO_RUNTIME", "Background ReactContext not available")
+            onComplete(IllegalStateException("Background ReactContext not available"))
             return
         }
 
-        // One-shot guard: native success/error AND the watchdog can each try to
-        // settle; only the first wins.
-        val settled = AtomicBoolean(false)
-        val sourceURL = "seg-$segmentId.js"
-        val segStart = System.nanoTime()
-
-        // Bounded watchdog: if the bg JS thread never drains to our eval, reject
-        // with the RETRYABLE SPLIT_BUNDLE_TIMEOUT instead of hanging forever.
-        val watchdog = Handler(Looper.getMainLooper())
-        val timeoutRunnable = Runnable {
-            if (settled.compareAndSet(false, true)) {
-                BTLogger.error("[SplitBundle] bg segment id=$segmentId eval timed out after ${BG_SEGMENT_EVAL_TIMEOUT_MS}ms (bg entry bundle likely never finished evaluating); rejecting as retryable timeout")
-                onComplete("SPLIT_BUNDLE_TIMEOUT", "Bg segment eval timed out: id=$segmentId")
-            }
-        }
-        watchdog.postDelayed(timeoutRunnable, BG_SEGMENT_EVAL_TIMEOUT_MS)
-
+        // Use ReactContext.registerSegment which works in both bridge
+        // and bridgeless modes.
         try {
-            nativeEvaluateSegmentInBackground(path, sourceURL) { error ->
-                if (settled.compareAndSet(false, true)) {
-                    watchdog.removeCallbacks(timeoutRunnable)
-                    if (error == null) {
-                        val segMs = (System.nanoTime() - segStart) / 1_000_000.0
-                        BTLogger.info("[SplitBundle] bg segment id=$segmentId evaluated in ${String.format("%.1f", segMs)}ms (eval-complete)")
-                        onComplete(null, null)
-                    } else {
-                        // Native prefixes its failures so we can map to the
-                        // shared contract codes: NO_RUNTIME (retryable),
-                        // IO_ERROR (fatal), else eval throw (fatal).
-                        when {
-                            error.startsWith("NO_RUNTIME:") ->
-                                onComplete("SPLIT_BUNDLE_NO_RUNTIME", error.removePrefix("NO_RUNTIME:"))
-                            error.startsWith("IO_ERROR:") ->
-                                onComplete("SPLIT_BUNDLE_IO_ERROR", error.removePrefix("IO_ERROR:"))
-                            else ->
-                                onComplete("SPLIT_BUNDLE_EVAL_ERROR", error)
-                        }
-                    }
-                }
-            }
-        } catch (e: Throwable) {
-            // nativeEvaluateSegmentInBackground itself failed to dispatch (e.g.
-            // UnsatisfiedLinkError). Fail closed; do NOT fall back to the
-            // race-prone registerSegment path.
-            if (settled.compareAndSet(false, true)) {
-                watchdog.removeCallbacks(timeoutRunnable)
-                BTLogger.error("[SplitBundle] FATAL: nativeEvaluateSegmentInBackground threw for id=$segmentId: ${e.message}")
-                onComplete("SPLIT_BUNDLE_NATIVE_UNAVAILABLE", "Bg native segment eval unavailable: ${e.message}")
+            context.registerSegment(segmentId, path) {
+                BTLogger.info("Segment registered in background runtime: id=$segmentId, path=$path")
+                onComplete(null)
             }
+        } catch (e: Exception) {
+            BTLogger.error("Failed to register segment in background runtime: ${e.message}")
+            onComplete(e)
         }
     }
 

package/android/src/main/java/com/backgroundthread/BackgroundThreadModule.kt

@@ -30,17 +30,9 @@ class BackgroundThreadModule(reactContext: ReactApplicationContext) :
 
     override fun loadSegmentInBackground(segmentId: Double, path: String, promise: Promise) {
         BackgroundThreadManager.getInstance()
-            .registerSegmentInBackground(segmentId.toInt(), path) { code, message ->
-                if (code != null) {
-                    // Reject with the SHARED split-bundle contract code (e.g.
-                    // SPLIT_BUNDLE_NO_RUNTIME / SPLIT_BUNDLE_TIMEOUT are
-                    // retryable; SPLIT_BUNDLE_IO_ERROR / SPLIT_BUNDLE_EVAL_ERROR
-                    // / SPLIT_BUNDLE_NATIVE_UNAVAILABLE / SPLIT_BUNDLE_NOT_FOUND
-                    // are not) so the JS loader classifies retryability the same
-                    // way it does for the main path. registerSegmentInBackground
-                    // always supplies one of these contract codes here, so there
-                    // is no legacy/opaque default string to fall back to.
-                    promise.reject(code, message)
+            .registerSegmentInBackground(segmentId.toInt(), path) { error ->
+                if (error != null) {
+                    promise.reject("BG_SEGMENT_LOAD_ERROR", error.message, error)
                 } else {
                     promise.resolve(null)
                 }

package/ios/BackgroundThread.mm

@@ -38,54 +38,7 @@
                                     path:path
                               completion:^(NSError * _Nullable error) {
         if (error) {
-            // Fix 1/E: map the manager's DISTINCT NSError.code to its own JS
-            // reject code (matching SplitBundleLoader's main-runtime mapping and
-            // the shared error-code contract) so JS can classify
-            // retryable-vs-fatal. EVERY EBgMgrSegmentEvalError case is mapped
-            // EXPLICITLY here — there is no silent `default → NO_RUNTIME` that
-            // could MISCLASSIFY a fatal failure (e.g. a missing segment file)
-            // as a transient runtime-not-ready that gets retried/masked. The old
-            // code both collapsed bg failures into one opaque
-            // `BG_SEGMENT_LOAD_ERROR` and (before that) let raw codes 1/2 fall
-            // through `default` to retryable NO_RUNTIME.
-            NSString *rejectCode;
-            switch ((EBgMgrSegmentEvalError)error.code) {
-                case EBgMgrSegmentEvalErrorNotStarted:
-                case EBgMgrSegmentEvalErrorNilInstance:
-                    // Bg runtime not started / RCTInstance nil — TRANSIENT: the
-                    // bg host simply wasn't ready yet; a later attempt may win.
-                    rejectCode = @"SPLIT_BUNDLE_NO_RUNTIME";        // retryable
-                    break;
-                case EBgMgrSegmentEvalErrorFileNotFound:
-                    // Segment file missing — FATAL packaging/OTA corruption.
-                    rejectCode = @"SPLIT_BUNDLE_NOT_FOUND";         // fatal
-                    break;
-                case EBgMgrSegmentEvalErrorIvarMissing:
-                    // `_rctInstance` ivar reflection failed — STRUCTURAL/PERMANENT
-                    // (an RN bump renamed the private field). Retrying is futile.
-                    rejectCode = @"SPLIT_BUNDLE_NATIVE_UNAVAILABLE"; // fatal
-                    break;
-                case EBgMgrSegmentEvalErrorIORead:
-                    rejectCode = @"SPLIT_BUNDLE_IO_ERROR";          // fatal
-                    break;
-                case EBgMgrSegmentEvalErrorEvalThrow:
-                    rejectCode = @"SPLIT_BUNDLE_EVAL_ERROR";        // fatal (segment bug)
-                    break;
-                case EBgMgrSegmentEvalErrorTimeout:
-                    rejectCode = @"SPLIT_BUNDLE_TIMEOUT";           // retryable
-                    break;
-                default:
-                    // Defensive LAST RESORT only: every real EBgMgrSegmentEvalError
-                    // case is handled above, so reaching here means the manager
-                    // emitted an unmapped code (a bug). Choose retryable
-                    // NO_RUNTIME so a stale/unknown native build degrades safely
-                    // rather than permanently poisoning a segment — but log it
-                    // loudly so the unmapped code is caught and named.
-                    [BTLogger warn:[NSString stringWithFormat:@"[SplitBundle] bg loadSegment: UNMAPPED EBgMgrSegmentEvalError code=%ld — defaulting to retryable NO_RUNTIME. This is a native bug: add an explicit case.", (long)error.code]];
-                    rejectCode = @"SPLIT_BUNDLE_NO_RUNTIME";        // retryable (defensive)
-                    break;
-            }
-            reject(rejectCode, error.localizedDescription, error);
+            reject(@"BG_SEGMENT_LOAD_ERROR", error.localizedDescription, error);
         } else {
             resolve(nil);
         }

package/ios/BackgroundThreadManager.h

@@ -6,49 +6,6 @@ NS_ASSUME_NONNULL_BEGIN
 @class RCTReactNativeFactory;
 @class RCTHost;
 
-/// NSError `code` values produced by `registerSegmentInBackground:` /
-/// `evaluateSegmentInBackground:` under the `BackgroundThread` error domain.
-///
-/// These are DISTINCT (kept numerically aligned with SplitBundleLoader's
-/// `ESegmentEvalError`) so the TurboModule boundary
-/// (`BackgroundThread.loadSegmentInBackground`) can map each to its OWN JS
-/// reject code and JS can classify retryable-vs-fatal — rather than collapsing
-/// every bg failure into one opaque code (fix E). EVERY failure the manager
-/// produces MUST have a NAMED case here so the boundary's switch maps it
-/// explicitly: a raw integer literal would fall through to the boundary's
-/// defensive `default` (→ retryable NO_RUNTIME) and silently MISCLASSIFY a
-/// fatal failure (e.g. a missing segment file) as a transient one that gets
-/// retried/masked instead of surfaced. The mapping the boundary applies is:
-///   - NotStarted  (bg runtime not started yet) → `SPLIT_BUNDLE_NO_RUNTIME`     (retryable)
-///   - FileNotFound (segment file missing)      → `SPLIT_BUNDLE_NOT_FOUND`      (fatal)
-///   - NilInstance (bg RCTInstance is nil)      → `SPLIT_BUNDLE_NO_RUNTIME`     (retryable)
-///   - IORead      (file read/mmap failed)      → `SPLIT_BUNDLE_IO_ERROR`       (fatal)
-///   - EvalThrow   (segment JS/Hermes bug)      → `SPLIT_BUNDLE_EVAL_ERROR`     (fatal)
-///   - Timeout     (buffered executor never ran)→ `SPLIT_BUNDLE_TIMEOUT`        (retryable)
-///   - IvarMissing (`_rctInstance` reflection
-///                  failed — STRUCTURAL/permanent)→ `SPLIT_BUNDLE_NATIVE_UNAVAILABLE` (fatal)
-///
-/// WHY NilInstance and IvarMissing are split (and not both NO_RUNTIME): a nil
-/// RCTInstance is TRANSIENT — the bg host just isn't up yet, a later attempt
-/// can succeed. A missing `_rctInstance` ivar is STRUCTURAL/PERMANENT — an RN
-/// version bump renamed/removed the private field our reflection depends on, so
-/// bg segment loading is disabled until the native code is updated. Retrying
-/// the latter is futile, so it maps to fatal NATIVE_UNAVAILABLE.
-///
-/// Declared here (not file-local in the .mm) so the boundary references these
-/// by NAME — a future renumbering stays exact instead of drifting against a
-/// hardcoded magic-number switch. Values 3-6 are kept STABLE; 1/2/7 fill in the
-/// previously-raw `registerSegmentInBackground:` codes and the structural split.
-typedef NS_ENUM(NSInteger, EBgMgrSegmentEvalError) {
-    EBgMgrSegmentEvalErrorNotStarted = 1,   // bg runtime not started yet (retryable)
-    EBgMgrSegmentEvalErrorFileNotFound = 2, // segment file missing (fatal)
-    EBgMgrSegmentEvalErrorNilInstance = 3,  // bg RCTInstance is nil (retryable)
-    EBgMgrSegmentEvalErrorIORead = 4,       // file read/mmap failed (fatal)
-    EBgMgrSegmentEvalErrorEvalThrow = 5,    // segment JS/Hermes bug (fatal)
-    EBgMgrSegmentEvalErrorTimeout = 6,      // buffered executor never ran (retryable)
-    EBgMgrSegmentEvalErrorIvarMissing = 7,  // `_rctInstance` ivar reflection failed (fatal, structural)
-};
-
 @interface BackgroundThreadManager : NSObject
 
 /// Shared instance for singleton pattern

package/ios/BackgroundThreadManager.mm

@@ -20,82 +20,6 @@
 #import <React/RCTReloadCommand.h>
 #import <ReactCommon/RCTHost.h>
 #import <objc/runtime.h>
-#import <os/lock.h>
-#include <jsi/jsi.h>
-#include <cstdint>
-
-namespace {
-
-// Zero-copy jsi::Buffer that retains its NSData for the async (buffered)
-// executor block's lifetime — same rationale as SplitBundleLoader's
-// NSDataJSIBuffer (M4/M5): no second full copy of the segment bytes, and the
-// mmap'd/heap bytes stay alive because the buffer owns the NSData.
-class BgMgrNSDataJSIBuffer : public facebook::jsi::Buffer {
- public:
-  explicit BgMgrNSDataJSIBuffer(NSData *data) : data_(data) {}
-  size_t size() const override { return data_.length; }
-  const uint8_t *data() const override {
-    return static_cast<const uint8_t *>(data_.bytes);
-  }
-
- private:
-  NSData *data_;  // strong retain (ARC).
-};
-
-}  // namespace
-
-// Exactly-once settle guard for the bg watchdog — same design as
-// SplitBundleLoader's SBLSettleGuard. An ARC object captured by both the
-// executor block and the watchdog dispatch_after; ARC keeps its lock alive
-// until both release, so neither block needs (or may do) a manual free —
-// avoiding the use-after-free that would occur if either freed the lock while
-// the other still runs.
-@interface BgMgrSettleGuard : NSObject
-- (BOOL)tryClaim;
-@end
-
-@implementation BgMgrSettleGuard {
-  os_unfair_lock _lock;
-  BOOL _settled;
-}
-- (instancetype)init {
-  if (self = [super init]) {
-    _lock = OS_UNFAIR_LOCK_INIT;
-    _settled = NO;
-  }
-  return self;
-}
-- (BOOL)tryClaim {
-  os_unfair_lock_lock(&_lock);
-  BOOL won = !_settled;
-  if (won) {
-    _settled = YES;
-  }
-  os_unfair_lock_unlock(&_lock);
-  return won;
-}
-@end
-
-// Watchdog window for the bg buffered runtime executor (H2 = bg-runtime port of
-// SplitBundleLoader's C1). The bg runtime's buffered executor stays buffered
-// until the bg entry bundle finishes evaluating in
-// BackgroundReactNativeDelegate.hostDidStart:; if that never completes (host
-// teardown, OTA-resolve abort), the block never runs — without this watchdog
-// the JS promise would hang inflightSegments forever.
-//
-// Fix G: 30s (matching Android and the main-runtime watchdog). The buffered
-// executor stays buffered until the bg ENTRY bundle finishes evaluating; on a
-// slow/throttled cold start that entry eval can itself exceed 10s, which would
-// falsely trip the watchdog on a load that was about to succeed. 30s keeps the
-// genuine-wedge safety net while leaving generous headroom for slow cold starts.
-static const NSTimeInterval kBgSegmentEvalWatchdogSeconds = 30.0;
-
-// EBgMgrSegmentEvalError NSError `code` values are declared in
-// BackgroundThreadManager.h so the TurboModule boundary
-// (BackgroundThread.loadSegmentInBackground) can map each distinct code to its
-// own JS reject code by NAME. They stay numerically aligned with
-// SplitBundleLoader's ESegmentEvalError; see installProdBundleLoader.ts for the
-// retryable-vs-fatal classification (H3 / fix E).
 
 @interface BackgroundThreadManager ()
 @property (nonatomic, strong) BackgroundReactNativeDelegate *reactNativeFactoryDelegate;
@@ -277,166 +201,33 @@ static NSString *const MODULE_DEBUG_URL = @"http://localhost:8082/apps/mobile/ba
                          completion:(void (^)(NSError * _Nullable error))completion
 {
     if (!self.isStarted || !self.reactNativeFactoryDelegate) {
-        // Transient: the bg runtime just isn't up yet. NotStarted → NO_RUNTIME
-        // (retryable). Previously a raw `code:1` which fell through the
-        // boundary's `default` — same destination, but now NAMED so the mapping
-        // is explicit and can never drift (fix 1 / E).
         NSError *error = [NSError errorWithDomain:@"BackgroundThread"
-                                             code:EBgMgrSegmentEvalErrorNotStarted
+                                             code:1
                                          userInfo:@{NSLocalizedDescriptionKey: @"Background runtime not started"}];
         if (completion) completion(error);
         return;
     }
 
-    // Verify the file exists. FATAL: a missing segment file is real packaging /
-    // OTA corruption — retrying just re-misses. Previously a raw `code:2` that
-    // the boundary's `default` MISCLASSIFIED as retryable NO_RUNTIME, masking
-    // the corruption; now FileNotFound → NOT_FOUND (fatal) (fix 1 / E — the
-    // NO-SHIP blocker).
+    // Verify the file exists
     if (![[NSFileManager defaultManager] fileExistsAtPath:path]) {
         NSError *error = [NSError errorWithDomain:@"BackgroundThread"
-                                             code:EBgMgrSegmentEvalErrorFileNotFound
+                                             code:2
                                          userInfo:@{NSLocalizedDescriptionKey:
                                                         [NSString stringWithFormat:@"Segment file not found: %@", path]}];
         if (completion) completion(error);
         return;
     }
 
-    [self evaluateSegmentInBackground:segmentId path:path completion:completion];
-}
-
-// Evaluate-then-resolve segment load for the BACKGROUND runtime (H2).
-//
-// WHY THIS REPLACES registerSegmentWithId: + immediate completion(nil):
-// The old path called `[delegate registerSegmentWithId:path:]` (which routes to
-// RCTInstance/ReactInstance::registerSegment — that only ENQUEUES
-// `runtime.evaluateJavaScript(segment)` on the runtime scheduler and returns)
-// then resolved the JS promise immediately. That is the exact
-// "Requiring unknown module" race the MAIN runtime already fixed in
-// SplitBundleLoader: Metro's `import().then(() => __r(moduleId))` microtask can
-// run `__r` BEFORE the scheduled eval populated the module table → a FATAL,
-// uncatchable crash. Locale segments load through THIS path in the bg runtime
-// (ServiceSetting.refreshLocaleMessages → import('./json/*.json') runs in
-// kit-bg), so a language switch could still crash.
-//
-// Fix: evaluate the segment OURSELVES inside one
-// `callFunctionOnBufferedRuntimeExecutor:` block on the bg RCTInstance and
-// signal completion in that SAME block, strictly AFTER eval — making eval +
-// resolve one atomic unit so any subsequent `__r(moduleId)` finds the module.
-// The bg RCTInstance is the delegate's private `_rctInstance` ivar; we read it
-// reflectively (the same pattern installSharedBridgeInMainRuntime: uses on the
-// main host) to keep this fix self-contained in this file rather than widening
-// the delegate's surface. Includes the same exactly-once + watchdog guard as
-// the main-runtime fix (C1) because the bg buffered executor is likewise
-// buffered until the bg entry bundle finishes evaluating in hostDidStart:.
-- (void)evaluateSegmentInBackground:(NSNumber *)segmentId
-                               path:(NSString *)path
-                         completion:(void (^)(NSError * _Nullable error))completion
-{
-    // Reach the bg RCTInstance via the delegate's `_rctInstance` ivar. `id`
-    // (not a typed RCTInstance*) mirrors installSharedBridgeInMainRuntime:'s
-    // untyped handling and avoids needing the RCTInstance header here.
-    BackgroundReactNativeDelegate *delegate = self.reactNativeFactoryDelegate;
-    Ivar ivar = class_getInstanceVariable([delegate class], "_rctInstance");
-    if (!ivar) {
-        // Loud failure (L7 parity): a future RN/delegate refactor that renames
-        // this ivar silently disables ALL bg segment loading — surface it.
-        // STRUCTURAL/PERMANENT (not transient): retrying can never recreate a
-        // renamed ivar, so this maps to fatal NATIVE_UNAVAILABLE — distinct from
-        // the nil-instance case below, which IS transient. Misclassifying this
-        // as NO_RUNTIME would make JS retry a permanently-broken reflection.
-        [BTLogger error:[NSString stringWithFormat:@"[SplitBundle] FATAL: _rctInstance ivar not found on %@ — bg segment loading is DISABLED.", [delegate class]]];
-        NSError *error = [NSError errorWithDomain:@"BackgroundThread"
-                                             code:EBgMgrSegmentEvalErrorIvarMissing
-                                         userInfo:@{NSLocalizedDescriptionKey: @"_rctInstance ivar not found on bg delegate"}];
-        if (completion) completion(error);
-        return;
-    }
-    id instance = object_getIvar(delegate, ivar);
-    if (!instance) {
-        [BTLogger error:@"[SplitBundle] bg loadSegment: background RCTInstance not available"];
-        NSError *error = [NSError errorWithDomain:@"BackgroundThread"
-                                             code:EBgMgrSegmentEvalErrorNilInstance
-                                         userInfo:@{NSLocalizedDescriptionKey: @"Background RCTInstance not available"}];
-        if (completion) completion(error);
-        return;
-    }
-
-    // M4/M5: mmap + zero-copy buffer (retains the NSData for the async block).
-    NSError *readError = nil;
-    NSData *data = [NSData dataWithContentsOfFile:path
-                                         options:NSDataReadingMappedIfSafe
-                                           error:&readError];
-    if (!data || data.length == 0) {
+    BOOL success = [self.reactNativeFactoryDelegate registerSegmentWithId:segmentId path:path];
+    if (success) {
+        if (completion) completion(nil);
+    } else {
         NSError *error = [NSError errorWithDomain:@"BackgroundThread"
-                                             code:EBgMgrSegmentEvalErrorIORead
-                                         userInfo:@{NSLocalizedDescriptionKey: [NSString stringWithFormat:@"Failed to read bg segment at %@%@", path, readError ? [NSString stringWithFormat:@": %@", readError.localizedDescription] : @""]}];
+                                             code:3
+                                         userInfo:@{NSLocalizedDescriptionKey:
+                                                        @"Failed to register segment in background runtime"}];
         if (completion) completion(error);
-        return;
     }
-
-    // M6: synthetic `seg-<id>.js` source URL for in-segment crash symbolication.
-    int segIdInt = segmentId.intValue;
-    NSString *sourceURL = [NSString stringWithFormat:@"seg-%d.js", segIdInt];
-
-    // C1: exactly-once guard shared (and retained) by the executor block and the
-    // watchdog. ARC-owned so the lock outlives both with no manual free.
-    BgMgrSettleGuard *settleGuard = [[BgMgrSettleGuard alloc] init];
-
-    CFAbsoluteTime dispatchStart = CFAbsoluteTimeGetCurrent();
-    [BTLogger info:[NSString stringWithFormat:@"[SplitBundle] bg loadSegment: evaluating %@ (id=%d, %lu bytes)", sourceURL, segIdInt, (unsigned long)data.length]];
-
-    // No __weak dance needed here (unlike the SharedRPC executor): this block
-    // does not re-dispatch onto the instance — it runs synchronously inside the
-    // instance's own runtime executor with a live `runtime &`, so by the time it
-    // executes the instance is necessarily still alive.
-    [instance callFunctionOnBufferedRuntimeExecutor:^(facebook::jsi::Runtime &runtime) {
-        @autoreleasepool {
-            BOOL won = [settleGuard tryClaim];
-            NSError *evalError = nil;
-            CFAbsoluteTime evalStart = CFAbsoluteTimeGetCurrent();
-            try {
-                auto buffer = std::make_shared<BgMgrNSDataJSIBuffer>(data);
-                runtime.evaluateJavaScript(buffer, [sourceURL UTF8String]);
-                double evalMs = (CFAbsoluteTimeGetCurrent() - evalStart) * 1000.0;
-                [BTLogger info:[NSString stringWithFormat:@"[SplitBundle] bg loadSegment: %@ evaluated in %.1fms", sourceURL, evalMs]];
-            } catch (const std::exception &e) {
-                evalError = [NSError errorWithDomain:@"BackgroundThread"
-                                                code:EBgMgrSegmentEvalErrorEvalThrow
-                                            userInfo:@{NSLocalizedDescriptionKey: [NSString stringWithFormat:@"Bg segment evaluation failed for %@: %s", sourceURL, e.what()]}];
-                [BTLogger error:[NSString stringWithFormat:@"[SplitBundle] bg loadSegment: %@ evaluation threw: %s", sourceURL, e.what()]];
-            } catch (...) {
-                evalError = [NSError errorWithDomain:@"BackgroundThread"
-                                                code:EBgMgrSegmentEvalErrorEvalThrow
-                                            userInfo:@{NSLocalizedDescriptionKey: [NSString stringWithFormat:@"Bg segment evaluation failed for %@ (unknown C++ exception)", sourceURL]}];
-                [BTLogger error:[NSString stringWithFormat:@"[SplitBundle] bg loadSegment: %@ evaluation threw an unknown exception", sourceURL]];
-            }
-            if (won) {
-                // Resolve AFTER eval — the ordering guarantee that fixes the race.
-                if (completion) completion(evalError);
-            } else {
-                [BTLogger warn:[NSString stringWithFormat:@"[SplitBundle] bg loadSegment: %@ evaluated AFTER watchdog already settled (bg entry was wedged >%.0fs)", sourceURL, kBgSegmentEvalWatchdogSeconds]];
-            }
-        }
-    }];
-
-    // C1 watchdog — fires only on a genuine wedge (bg entry bundle never
-    // finished evaluating). Rejects with a retryable timeout so the JS loader
-    // re-attempts. settleGuard is retained by this block, so the lock stays
-    // valid even if the executor block later runs.
-    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(kBgSegmentEvalWatchdogSeconds * NSEC_PER_SEC)),
-                   dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
-        if ([settleGuard tryClaim]) {
-            [BTLogger error:[NSString stringWithFormat:@"[SplitBundle] bg loadSegment: %@ WATCHDOG fired after %.0fs — bg runtime executor never ran (bg entry bundle likely never finished evaluating). Rejecting as retryable timeout.", sourceURL, kBgSegmentEvalWatchdogSeconds]];
-            NSError *timeoutError = [NSError errorWithDomain:@"BackgroundThread"
-                                                        code:EBgMgrSegmentEvalErrorTimeout
-                                                    userInfo:@{NSLocalizedDescriptionKey: [NSString stringWithFormat:@"Bg segment %@ eval timed out after %.0fs (buffered runtime executor never ran)", sourceURL, kBgSegmentEvalWatchdogSeconds]}];
-            if (completion) completion(timeoutError);
-        }
-    });
-
-    double dispatchMs = (CFAbsoluteTimeGetCurrent() - dispatchStart) * 1000.0;
-    [BTLogger info:[NSString stringWithFormat:@"[SplitBundle] bg loadSegment: %@ dispatched in %.1fms (resolve fires after eval; watchdog %.0fs)", sourceURL, dispatchMs, kBgSegmentEvalWatchdogSeconds]];
 }
 
 #pragma mark - Restart

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-background-thread",
-  "version": "3.0.61",
+  "version": "3.0.63",
   "description": "react-native-background-thread",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/SharedRPC.ts

@@ -4,7 +4,7 @@ export interface ISharedRPC {
   // the payload value, so there is no read-back. `read`/`has`/`pendingCount`
   // (the old slot-map introspection) are gone.
   onWrite(
-    callback: (callId: string, value: string | number | boolean) => void,
+    callback: (callId: string, value: string | number | boolean) => void
   ): void;
   // The calling runtime declares which SharedStore key holds its readiness
   // payload, so the native invalidate path clears exactly that key on teardown