Issues with refs

I kinda get the issues with refs now, it basically ties into how we can switch from a patch oriented diff to a mount one.

In essence we always discard refs as part of our unmount process which makes sense in essence but this could prove to be hard when we do

    const App = ({ open }) =>
      open ? (
        <div class=“open” key=“open”>
          <div ref={ref} />
        </div>
      ) : (
        <div class=“closes” key=“closed”>
          <div ref={ref} />
        </div>
      );

Now we put either one on the unmount queue and switch to mount-mode for the other. Which essentially means that we dive into mount which immediately applies the ref as part of mountChildren and when we trampoline back up into patchChildren we will meet the unmount call and erase the ref to null.

The issue with queueing is determining the timeframe to apply the refs as they will need to be there before our layout-effects are triggering so we need it before we connect the new nodes to our root-tree.

This makes a queue a hard task as we try to be as indeterminate as possible about what phase we are in.

On the bright side we could start experimenting with tracking the refs on the rendererState still a bit hesitant on when to start applying them.

The thing that worries me about the patch —> mount cycle is that we would probably even here have issues queuing and keeping a deterministic order. i.e. we could keep two arrays with nullish and non-nullish invocations, this would result in us executing them out of order —> all null —> all value rather than null - value - null - value (useImperativeHandle). I think we would just need to find a special case for this replacement logic.