No need to explicitly use inline.

Define it like this, making clear this is per socket and ensuring every place use the same amount of bits in case we want to increase it later:

typedef uint32_t SocketModifiedFlags;
SocketUpdateFlags socket_modified;

We also use "modified" rather than "changed" in some places already, I'd remain consistent with that naming.

Also I suggest "modified" rather than "update" since the node base class only tracks what has been modified, and what that then means in terms of updates is up to the specific node implementations and managers.

Those functions are here to avoid typo errors while writing redundant code, and basically implement the logic to set the value, replacing the body of Node::set. I think Node::set could be a template instead, we can use some template magic to handle the runtime assertions, e.g. :

template <typename T>
struct SocketDataTypeInfo;

template <>
struct SocketDataTypeInfo<int> {
    static bool is_value_of_type(SocketType::Type type)
    {
        return type == SocketType::INT;
    }
};

template <>
struct SocketDataTypeInfo<float3> {
    static bool is_value_of_type(SocketType::Type type)
    {
        return type == SocketType::COLOR || type == SocketType::POINT ||
               type == SocketType::VECTOR || type == SocketType::NORMAL;
    }
};

template <typename T>
void Node::set(const SocketType &input, T value)
{
    assert(SocketDataTypeInfo<T>::is_value_of_type(input.type));

    if (value != get_socket_value(this, input)) {
        return;
    }

    get_socket_value(this, input) = value;
    socket_modified |= input.modified_flag_bit;
}

Those SocketDataTypeInfo could also be used to have type safety for getting or setting structures in one go if we choose to have structure sockets.