React ref callbacks behaves differently with useCallback hook?

In my React component with useCallback hook like below. I wrapped a onClick event handler with useCallback also wrapped a ref callback with useCallback. While clicking on the button, it would change the state value hence cause the component to re-render. It's observed that the console log inside the onClick event handler "handleOnClick" is executed at every re-render, whereas the console log inside the ref callback "divRefCallback" only executed once.

I can understand why the handleOnClick is executed at each re-render, because useCallback will only avoid recreating the function, but will NOT avoid re-executing the function. However, I cannot understand why useCallback works differently with ref callback, because in this example, it doesn't re-create the function but also not executing the logic inside the callback as well.

I am wondering why it's behaving like this? Is there any other scenario where useCallback would avoid re-executing the callback logic?

Is there any official document to explain this? Thanks in advance for any insights!

function UseCallbackDemo() {
  const divRef = React.useRef<HTMLDivElement | null>(null);
  const [count, setCount] = React.useState(0);

  console.log("**** re-render component");
  const divRefCallback = React.useCallback((div) => {
    if (div) {
      divRef.current = div;
    }
    console.log("*** divRefCallback");
  }, []);

  const handleOnClick = React.useCallback(() => {
    console.log('**** handleOnClick');
    setCount(count => count + 1);
  }, []);

  return (
    <>
      <div ref={divRefCallback}>{count}</div>
      <button onClick={handleOnClick}>click</button>
    </>
  );
}

Please test the code here: https://playcode.io/1529685

According to the documentation:

<blockquote>
Instead of a ref object (like the one returned by <code>useRef</code>), you may pass a function to the ref attribute. <br> <br>
<pre><code>&lt;div ref={(node) => console.log(node)} /></code></pre>
When the &lt;div> DOM node is added to the screen, React will call your ref callback with the DOM node as the argument. When that &lt;div> DOM node is removed, React will call your ref callback with null. <br> <br>
React will also call your ref callback whenever you pass a different ref callback. In the above example, <code>(node) => { ... }</code> is a different function on every render. When your component re-renders, the previous function will be called with null as the argument, and the next function will be called with the DOM node.
</blockquote>

Since useCallback returns the same function reference each time when the dependency array is empty, the ref function is only called once (before the <div> is removed) in the example from the question.