test

            continue;

        }

        std::unique_lock<std::recursive_mutex> target_lock(t->quic_mtx());

        // try_lock, not block (same rationale as flush_pending_app() in

        // accept(), above): pumpIncoming() is called in a tight loop from

        // every streaming H2/H3 response's continuation thread, so

        // blocking here to wait out a sibling connection that's busy

        // elsewhere serializes all of them on whichever one is slowest —

        // and, worse, ties up the caller's own thread instead of letting

        // it get back to draining the shared listener socket. QUIC's own

        // loss detection retransmits whatever we skip here, so dropping

        // it now and picking it up on a later pump/drain cycle is safe.

        std::unique_lock<std::recursive_mutex> target_lock(t->quic_mtx(), std::try_to_lock);

        if (!target_lock.owns_lock()) continue;

        t->processApplicationPacketsBatch(pkts);

        // The self case's pending flow-control frames are flushed by the

        // unconditional block below (operating on `this`'s own state);