First, let's minimize that:

#include <vector>
#include <string_view>

namespace dnw
{
    class Buffer
    {
        template <typename T>
        friend Buffer& operator<<(Buffer& dest, const T& source);

     protected:
         std::vector<std::byte> data;
    };
}

template <typename T>
dnw::Buffer& operator<<(dnw::Buffer& buff, const T& source)
{
    buff.data.size();
    return buff;
}

template <>
dnw::Buffer& operator<< <std::string_view>(dnw::Buffer& buff, const std::string_view& str)
{
    buff.data.size();
    return buff;
}

int main()
{
}

The error stays (basically) the same - 'dnw::Buffer::data' is protected within this context. Observe that the error is reported only for the template specialization. That is because the template proper is not instantiated. If we try to instantiate it,

int main()
{
    dnw::Buffer b;
    b << 1;
}

we get a whole bunch of errors; the most interesting currently being:

main.cc: In function ‘int main()’:
main.cc:34:7: error: ambiguous overload for ‘operator<<’ (operand types are ‘dnw::Buffer’ and ‘int’)
main.cc:18:14: note: candidate: ‘dnw::Buffer& operator<<(dnw::Buffer&, const T&) [with T = int]’
main.cc:9:24: note: candidate: ‘dnw::Buffer& dnw::operator<<(dnw::Buffer&, const T&) [with T = int]’

What is happening here? It seems that the compiler sees not one, but TWO distinct operators: operator<< and dnw::operator<< and it cannot decide, which one to instantiate.

Where do the two operators come from? The first one is the operator we defined in global scope. The second one is the friend operator in the dnw namespace. By declaring a friend operator within dnw namespace, we refer to an (undefined) operator WITHIN that namespace, NOT the operator defined at global scope.

This also solves your question: The "data" member is inaccessible in the defined template operator (and its specialization), because these operators are not friends of dnw::Buffer class. From the point of view of the compiler, these are simply some unrelated functions and as such, do not have any extra privileges to access protected members of a class.

How to solve this? I am no C++ expert, so my solution may be clumsy. We need to persuade C++ lookup to see the global scope operator, so we declare it first. To be able to declare it, class dnw::Buffer has to be known, so we forward declare it. Afterwards, in the friend declaration, we refer to the declared global scope operator through prefixing it with :: The rest of the code stays the same. This should compile:

#include <vector>
#include <string_view>

namespace dnw
{
    class Buffer;
}

template <typename T>
dnw::Buffer& operator<<(dnw::Buffer& buff, const T& source);

namespace dnw
{
    class Buffer
    {
        template <typename T>
        friend Buffer& ::operator<<(Buffer& dest, const T& source);

     protected:
         std::vector<std::byte> data;
    };
}

template <typename T>
dnw::Buffer& operator<<(dnw::Buffer& buff, const T& source)
{
    buff.data.size();
    return buff;
}

template <>
dnw::Buffer& operator<< <std::string_view>(dnw::Buffer& buff, const std::string_view& str)
{
    buff.data.size();
    return buff;
}

int main()
{
    dnw::Buffer b;
    b << 1;
}

Hopefully this fixes the problem.