Class CoroutinePlatformPthread

src/platforms/wasm/coroutine_platform_wasm.hpp:134–224

}

class CoroutinePlatformPthread : public ICoroutinePlatform {
public:
    void* createContext(void (*entry_fn)(), size_t /*stack_size*/) FL_NOEXCEPT override {
        auto* ctx = new PthreadCoroCtx();  // ok bare allocation - platform context lifetime
        ctx->entry_fn = entry_fn;
        ctx->thread.reset(new fl::thread(pthread_coro_thread_main, ctx));  // ok bare allocation
        return ctx;
    }

    void* createRunnerContext() FL_NOEXCEPT override {
        // Runner is the calling thread (sketch thread). No OS thread to spawn —
        // we just need a parking spot for it.
        auto* ctx = new PthreadCoroCtx();  // ok bare allocation
        return ctx;
    }

    void destroyContext(void* ctx_p) FL_NOEXCEPT override {
        auto* ctx = static_cast<PthreadCoroCtx*>(ctx_p);
        if (!ctx) return;

        if (ctx->thread) {
            // Teardown protocol — guarantees the worker has fully stopped
            // touching *ctx before we free it.
            //
            //   1. Set `exit_requested` and `signaled` under the lock.
            //   2. notify_all() — wakes the worker out of either its initial
            //      cv.wait() or any contextSwitch() cv.wait().
            //   3. The worker rechecks `exit_requested` after every cv.wait()
            //      and either falls off pthread_coro_thread_main (initial
            //      wait) or calls pthread_exit() (contextSwitch).
            //   4. join() blocks until that exit completes — only then is it
            //      safe to delete the thread object and *ctx.
            //
            // NB: under `-fno-exceptions`, `pthread_exit` skips C++ stack
            // unwinding. Library frames release their locks before exit (see
            // contextSwitch / pthread_coro_thread_main), but RAII objects
            // living on the *user* coroutine's stack are abandoned without
            // destructors. See the "Coroutine teardown contract" block at
            // the top of this file for the caller-facing implications.
            {
                fl::lock_guard<fl::mutex> lk(ctx->mutex);
                ctx->exit_requested = true;
                ctx->signaled = true;
            }
            ctx->cv.notify_all();

            if (ctx->thread->joinable()) {
                ctx->thread->join();
            }
            ctx->thread.reset();
        }
        delete ctx;  // ok bare allocation - platform context lifetime
    }

    void contextSwitch(void* from_ctx_p, void* to_ctx_p) FL_NOEXCEPT override {
        auto* from = static_cast<PthreadCoroCtx*>(from_ctx_p);
        auto* to = static_cast<PthreadCoroCtx*>(to_ctx_p);
        if (!from || !to) return;