Asuming the folowing widget layout:

type myLeaf struct {
    node.LeafEmbed
    // some other fields
}

func NewMyLeaf() *myLeaf {
    w := &myLeaf{}
    w.Wrapper = w
    return w
}

func (w *myLeaf) Paint(ctx *node.PaintContext, origin image.Point) error {
    w.Marks.UnmarkNeedsPaint()
    // draw to ctx ...
}

Inside driver.Main():

leafA := NewMyLeaf()
leafB := NewMyLeaf()

w := widget.NewFlow(widget.AxisVertical,
    widget.NewSheet(leafA),
    widget.NewSheet(leafB),
)

if err := widget.RunWindow(s, w, &widget.RunWindowOptions{
    NewWindowOptions: screen.NewWindowOptions{},
}); err != nil {
    log.Fatal(err)
}

How does one execute func (w *myLeaf) Paint(...) error on the widget tree for each leaf (myLeaf) from outside driver.Main()?

Also using pointers for leafA, leafB and w is possible.

When we look up here we see that widget.RunWindow( ... ) doesn't handle such external requests from the caller.

A workaraound could be to implement an analogous function MyRunWindow( ... ) and assign the Window to an global Interface. Like this:

func MyRunWindow(s screen.Screen, root node.Node, opts *RunWindowOptions) (err error) {
    var nwo *screen.NewWindowOptions

    // ... assign window options ...

    if MyWindow, err = s.NewWindow(nwo); err != nil {
        return err
    }

    // event loop, processing 'lifecycle.Event', 'input.Event', etc.
    // and you can process own 'Events' in a type switch
    for {
        e := MyWindow.NextEvent()

        if e = gef.Filter(e); e == nil {
            continue
        }

        switch e := e.(type) {
        case MyEvent:
        // ... call on 'root' here
        }
    }

On the caller side you can use your global Interface like this:

MyWindow.Send(paint.Event{}) // for a needed call to root.Paint()
MyWindow.Send(MyEvent{})     // for your own event to be processed