Tuples by sequentially stepping through entries in list of lists Challenge:

Given a list of nonempty lists of integers, return a list of tuples of the following form: First list tuples starting with each element of the first list followed by the first element of every subsequent list, so the ith tuple should be [ith element of first list, first element of second list, ... , first element of last list]. For example:

[[1, 2, 3], [4, 5, 6], [7, 8, 9]] =&gt; [[1, 4, 7], [2, 4, 7], [3, 4, 7], ...


Then do tuples of the form [last element of first list, ith element of second list, first element of third list, ..., first element of last list], so in our example this would be:

[[1, 2, 3], [4, 5, 6], [7, 8, 9]] =&gt;  ..., [3, 4, 7], [3, 5, 7], [3, 6, 7], ...


Continue on with each remaining list, until you get to [last element of first list, ..., last element of second to last list, ith element of last list]:

[[1, 2, 3], [4, 5, 6], [7, 8, 9]] =&gt; ..., [3, 6, 7], [3, 6, 8], [3, 6, 9]]


The full output is as follows:

[[1, 2, 3], [4, 5, 6], [7, 8, 9]] =&gt; 
        [[1, 4, 7], [2, 4, 7], [3, 4, 7], [3, 5, 7], [3, 6, 7], [3, 6, 8], [3, 6, 9]]


Some boilerplate for good measure:


If you want the input to be lists of strings, or lists of positive integers, it's fine. The question is about manipulating lists, not about what is in the lists.
Input and output can be in any acceptable format.
Either a full program or function is permitted.
Standard loopholes are disallowed by default.
This question is code golf, so lowest byte-count wins.


Examples:

[] =&gt; [[]] (or an error, thanks to ngn for correcting the output in this case)

[[1]] =&gt; [[1]]

[[1, 2], [3, 4], [5]] =&gt; [[1, 3, 5], [2, 3, 5], [2, 4, 5]]

[[1], [2], [5, 6], [3], [4]] =&gt; [[1, 2, 5, 3, 4], [1, 2, 6, 3, 4]]

[[1, 2, 3], [4, 5]] =&gt; [[1, 4], [2, 4], [3, 4], [3, 5]]

[[1, 2, 3], []] =&gt; unspecified behavior (can be an error)

[[3, 13, 6], [9, 2, 4], [5, 10, 8], [12, 1, 11], [7, 14]] =&gt; 
     [[3, 9, 5, 12, 7], [13, 9, 5, 12, 7], [6, 9, 5, 12, 7], [6, 2, 5, 12, 7], 
      [6, 4, 5, 12, 7], [6, 4, 10, 12, 7], [6, 4, 8, 12, 7], [6, 4, 8, 1, 7], 
      [6, 4, 8, 11, 7], [6, 4, 8, 11, 14]]  

[[16, 8, 4, 14, 6, 7, 10, 15], [11, 1, 12, 2, 19, 18, 9, 3], [13, 5, 17]] =&gt;
    [[16, 11, 13], [8, 11, 13], [4, 11, 13], [14, 11, 13], [6, 11, 13], 
     [7, 11, 13], [10, 11, 13], [15, 11, 13], [15, 1, 13], [15, 12, 13], [15, 2, 13], 
     [15, 19, 13], [15, 18, 13], [15, 9, 13], [15, 3, 13], [15, 3, 5], [15, 3, 17]]


If anyone has a better title, let me know.
JavaScript (ES6), 59 bytes
Expects a list of lists of positive integers.

f=a=&gt;[a.map(a=&gt;a[0]),...a.some(a=&gt;a[1]&amp;&amp;a.shift())?f(a):[]]

Try it online!
How?
At each iteration:

We output a new list consisting of the first element of each list.
We remove the first element of the first list containing at least 2 elements, and repeat the process. Or we stop the recursion if no such list exists.