Seventy Seven Sevens Given a number n and an upper limit l list the numbers that can be created by multiplying two or more numbers consisting of only sevens of length n or less that are less than l. A161145 is close to this challenge, however, you will NOT be including the 7, 77, 777, 7777, 77777, etc..
Examples
n=anything, l&lt;49 would result in:
[]

n=1, l=49 would result in:
7*7=49

f(1,49)=[49]

n=1, l=343 would result in:
7*7   =49
7*7*7 =343

f(1,343)=[49,343]

n=2,l=6000 would result in:
7*7    =49
7*7*7  =343
7*7*7*7=2401
7*77   =539
7*7*77 =3773
77*77  =5929

f(2,6000)=[49,343,539,2401,3773,5929]

n=3, l=604000 would result in:
[49, 343, 539, 2401, 3773, 5439, 5929, 16807, 26411, 38073, 41503, 59829, 117649, 184877, 266511, 290521, 418803, 456533, 603729]

Etc...
Rules

You do not have to output intermediate steps, this was done for clarity.
Output can be as an array or separated by any character (even newlines).
Output must be in numerical order, lowest to highest.
To make the title relevant, highest n that must be handled is n=77 (if you can't handle that high, note why - language restrictions are acceptable, laziness is not). This limitation is to hinder those looking to build the entire superset in memory.
If TIO cannot run n=77 for your code, explain what specs were required to achieve n=77.
For a product to be valid it must consist of at least 2 numbers.
This is code-golf lowest byte-count will be deemed victorious.
You may choose the list to contain items less than l or less than/equal to l.
BONUS: If your code is exactly 77 bytes, kudos from me; worthless, I know.
Jelly, 21 20 19 18 bytes

R7ẋḌµ;ŒċP€⁹f€FµÐLḟ


Note that the output doesn't match the OP's. I've left a comment.

Try it online!

How it works

R7ẋḌµ;ŒċP€⁹f€FµÐLḟ  Main link. Left argument: n. Right argument: l

R                   Range; yield [1, ..., n].
 7ẋ                 Times; yield [[7], ..., [7] * n].
   Ḍ                Undecimal; yield s := [7, 77, ...].
    µ         µÐL   Begin a new chain with argument s and call the chain between 
                    until the results no longer chain.
                    Return the last unique result.
      Œċ            Combinations; return all unordered pairs in integers in the
                    return value.
     ;              Concatenate the return value and its pairs.
        P€          Take the product of each individual integer and each pair in
                    the result.
          ⁹f€       Filter each; for each j in [1, ..., l], intersect [j] with the
                    array of products. The result is sorted and contains no 
                    duplicates.
                 ḟ  Filterfalse; remove the elements of s from the result.