[YevheniiKotyrlo]

Problem

RNSkWorker::run() calls each job with nothing around it, on the thread the worker detaches:

        job = std::move(_jobs.front());
        _jobs.pop_front();
      }
      job();

An exception a job lets out leaves the thread's function, and the standard then calls std::terminate: the app ends. On main the worker runs the encodes of encodeToBytes() and encodeToBase64(), readPixels()' read of a CPU image and its conversion of a GPU readback, and makeRasterImage()'s decode of an encoded image, each of which throws only when an allocation fails; any job posted to the worker later is in the same position.

Solution

run() catches what a job throws, logs it through RNSkLogger::logToConsole, with what() for a std::exception as RNSkGraphiteProducer logs a failed replay, and runs the next job. A throw now fails its own job, not the app. The format overload writes into a fixed-size buffer, so the handler allocates nothing and logs a std::bad_alloc too.

Each of those jobs completes its promise from inside the job, so with the catch alone a job that throws would leave its promise pending, and on a worklet runtime the scheduler's tick re-arming. A job with a result goes through post(make, deliver) instead: the worker runs make inside that catch and hands deliver what it returned, or null when it threw, as DawnContext::readPixels() hands its callback null for a failed read. The four jobs post that way, each deliver completing the promise, so a job that throws settles its promise as one that fails without throwing does: the encodes and makeRasterImage() reject, and readPixels() resolves to null. The settling reaches the runtime as every result does; on the React Native runtime that goes through React Native's noexcept invokeAsync, which allocates the task it schedules: a heap too exhausted for that ends the app there.

run.sh adds React Native's JSI headers (JSI_INCLUDE), which RNSkLog.h includes.

Tests

cpp-tests/WorkerTest.cpp checks that the job behind one that throws runs, and that post(make, deliver) delivers once, null when make threw. Its first case aborts on main's worker, and with deliver(make()) as the result job, which is how the jobs complete their promise on main, the result case fails:

terminate called after throwing an instance of 'std::runtime_error'
  what():  a job failed

FAIL: a job that threw a std::exception did not deliver a null result once

With the fix, yarn test-cpp prints WorkerTest: passed.

Verification

cpplint with CI's flags clean · yarn test-cpp 2 of 2 passed (g++ 15.2) · WorkerTest passed with Apple clang 21 (Xcode 27.1, -Wall -Wextra, no warning), and JsiSkImage.h compiles with it against the macOS and iOS SDKs · yarn lint and yarn tsc clean · the example's Android release build (arm64-v8a) succeeds, with no warning in packages/skia · on a Galaxy S23 (Android 14), the Readback, ImageEncoding, DataEncoding and Image e2e specs pass, and with each of the four jobs made to throw, every promise settles as above, where with main's jobs beside the catch each stays pending

Not run here: the example's iOS and macOS builds (CI's build-test-ios, build-test-macos and build-test-ios-spm).

No existing issue or PR covers this: I searched for RNSkWorker, worker thread abort, uncaught exception thread and terminate called.

Related

#4328 stacks on this PR: its static canvases present on this worker, and on Android its presented bitmaps are made there through calls into Java.

Base

main at 3184116c9, merged in by 7dfd0589b.

[wcandillon]

This is a good catch. Now that we don't crash on throws, the caller (JsiSkImage), needs to reject the promise right?

[YevheniiKotyrlo]

Right: a47ce50 gives the worker post(make, deliver), which hands deliver null when make throws, and makeRasterImage() posts its decode through it, so the promise rejects as it does for a decode that returns null.

[YevheniiKotyrlo]

Updated to the latest main (3184116). #4368 runs the encodes and readPixels()' reads on the worker too, each completing its promise from inside the job, so 3748cf8 posts them through post(make, deliver) as the decode does: a job that throws now settles its promise, the encodes and makeRasterImage() rejecting and readPixels() resolving to null.