Method route_request

server/src/server/http_server.cpp:1388–1800

    }

    std::fprintf(stderr, "[server] listening on http://%s:%d\n",
                 config_.host.c_str(), config_.port);

    // A backend-provided sequence engine replaces the one-request worker
    // with the concurrent scheduler. Upstream forwarding stays on the
    // classic path even when the local backend exposes an engine.
    if (SeqEngine * engine = backend_.seq_engine();
        engine && config_.pflash_upstream_base.empty()) {
        worker_thread_ =
            std::thread([this, engine]() { scheduler_loop(*engine); });
    } else {
        worker_thread_ = std::thread([this]() { worker_loop(); });
    }

    // Accept loop.
    while (!stopping_.load()) {
        struct pollfd pfd{listen_fd_, POLLIN, 0};
        int pr = poll(&pfd, 1, 200 /* ms */);
        if (pr <= 0) {
            // 0 = timeout (re-check stopping_); <0 with EINTR = signal. Both loop.
            if (pr < 0 && !sock_is_eintr(sock_errno())) {
                std::fprintf(stderr, "[server] poll() error: %s\n", sock_strerror());
            }
            continue;
        }

        struct sockaddr_in client_sa{};
        socklen_t client_len = sizeof(client_sa);
        SocketHandle client_fd = accept(
            listen_fd_, (struct sockaddr *)&client_sa, &client_len);
        if (!socket_is_valid(client_fd)) {
            if (stopping_.load()) break;
            if (sock_is_eintr(sock_errno()) || sock_is_eagain(sock_errno())) continue;
            std::fprintf(stderr, "[server] accept() error: %s\n", sock_strerror());
            continue;
        }

        // Disable Nagle for low-latency SSE streaming.
        int flag = 1;
        setsockopt(client_fd, IPPROTO_TCP, TCP_NODELAY, SETSOCKOPT_CAST &flag, sizeof(flag));

        // Spawn client thread (detached — client_main owns the fd).
        active_clients_.fetch_add(1);
        std::thread([this, client_fd]() {
            handle_client(client_fd);
            if (active_clients_.fetch_sub(1) == 1) {
                std::lock_guard<std::mutex> lk(clients_mu_);
                clients_cv_.notify_all();
            }
        }).detach();
    }

    // Wake the worker thread so it can observe stopping_ and exit.
    queue_cv_.notify_all();

    // Wait for client threads to drain, but bound it: a client mid-stream (long
    // SSE generation) must not hold the process resident on shutdown. After the
    // grace period we proceed — detached client threads are torn down on exit.