[Question]
  [
As you may know it, the factorial of a positive integer `n` is the product of all the positive integers which are equal or smaller to `n`.
For instance :
```
6! = 6*5*4*3*2*1 = 720
0! = 1
```
We will now define a special operation with an irrelevant name like `sumFac`:
Given a positive integer `n`, `sumFac(n)` is the sum of the factorials of the digits.
For instance :
`sumFac(132) = 1! + 3! + 2! = 9`
## Task
Your mission, whether or not you choose to accept it, is to return the sequence (potentially infinite) of the applications of `sumFac` to an integer given in input.
Example : `132 -> 132, 9, 362880, 81369, 403927, ...`
But that's not all! Indeed, the applications of `sumFac` will eventually create a cycle. You must also return this cycle!
If your language has a built in factorial you can use it.
I'm not picky about the return type, you just have to return the sequence of sumFac applications and the cycle in a format understandable by a human.
EDIT : To help you visualize better what should the output look like I copied Leaky Nun's just below:
```
[132, 9, 362880, 81369, 403927, 367953, 368772, 51128, 40444, 97, 367920, 368649, 404670, 5810, 40442, 75, 5160, 842, 40346, 775, 10200, 6, 720, 5043, 151, 122, 5, 120, 4, 24, 26, 722, 5044, 169, 363601, 1454]
```
You just need to stop the sequence when the cycle is about to start for the second time!
But this is [code-golf](https://codegolf.stackexchange.com/questions/tagged/code-golf) so the shortest answer in bytes wins!
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
D!SµÐĿ
    ÐĿ  Repeat until the results are no longer unique. Collects all intermediate results.
D           Convert from integer to decimal (list of digits)
 !          Factorial (each digit)
  S         Sum
```
[Try it online!](https://tio.run/nexus/jelly#@@@iGHxo6@EJR/b////f0NgIAA "Jelly – TIO Nexus")
I don't see any other way to make it shorter other than to do as told.
## Specs
* Input: `132` (as command-line argument)
* Output: `[132, 9, 362880, 81369, 403927, 367953, 368772, 51128, 40444, 97, 367920, 368649, 404670, 5810, 40442, 75, 5160, 842, 40346, 775, 10200, 6, 720, 5043, 151, 122, 5, 120, 4, 24, 26, 722, 5044, 169, 363601, 1454]`
[Answer]
# [Python 2](https://docs.python.org/2/), 88 bytes
```
import math
f=lambda x,l=[]:l*(x in l)or f(sum(math.factorial(int(i))for i in`x`),l+[x])
```
[Try it online!](https://tio.run/nexus/python2#FcsxCoAwDEDR3VNkTFQEdRM8iQiNSjGQWqkVevta5/9@Fnf7EMFxPCs7K7vtYEitzss6aY0J5AIlH8Di8zr8XWd5jz4IK8oVUYhs6VKkSYZabZa0Ur5DieXqx4HyBw "Python 2 – TIO Nexus")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 12 bytes
```
[DˆS!O©¯så#®
```
[Try it online!](https://tio.run/nexus/05ab1e#@x/tcrotWNH/0MpD64sPL1U@tO7/f0NjIwA "05AB1E – TIO Nexus")
**Explanation**
```
[               # infinite loop
 Dˆ             # add a copy of current value to the global list (initialized as input)
   S            # split current number to digits
    !O          # calculate factorial of each and sum
      ©         # save a copy in register
       ¯så#     # if the current number is in the global list, exit loop
           ®    # retrieve the value from the register for the next iteration
                # implicitly output the global list
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 17 bytes
```
g:I{tẹḟᵐ+}ᵃ⁾L¬≠Lk
```
[Try it online!](https://tio.run/nexus/brachylog2#ASYA2f//ZzpJe3ThurnhuJ/htZArfeG1g@KBvkzCrOKJoExr//8xMzL/Wg "Brachylog – TIO Nexus")
### Explanation
```
g:I{     }ᵃ⁾         Accumulate I (a variable) times, with [Input] as initial input:
    t                  Take the last integer
     ẹḟᵐ+              Compute the sum of the factorial of its digits
            L        The result of the accumulation is L
            L¬≠      Not all elements of L are different
               Lk    Output is L minus the last one (which is the start of the loop)
```
[Answer]
# Wolfram Language, ~~62~~ ~~60~~ 56 bytes
```
Most@NestWhileList[Tr[IntegerDigits@#!]&,#,UnsameQ,All]&
```
It is really too bad that Wolfram Language has such abominably long function names. \*Sigh\*
**Explanation:**
```
Most[NestWhileList[Tr[IntegerDigits[#]!]&,#,UnsameQ,All]]&
                      IntegerDigits[#]                     (*Split input into list of digits*)
                                      !                    (*Factorial each element in the list*)
                   Tr[                 ]&                  (*Sum the list together*)
     NestWhileList[                      ,#,UnsameQ,All]   (*Iterate the function over itself, pushing each to a list, until a repeat is detected*)
Most[                                                   ]& (*Remove the last element in the list*)
```
[Answer]
# ClojureScript, ~~146~~ 109 bytes
```
#(loop[n[%]](let[f(apply +(for[a(str(last n))](apply *(range 1(int a))))](if(some #{f}n)n(recur(conj n f)))))
```
Yikes, that is a monstrosity. Someone please help me golf this...
Thanks `@cliffroot` for shaving off a whopping 37 bytes!
This is an anonymous function, to run the function, you have to do this:
```
(#(...) {arguments})
```
TIO doesn't have ClojureScript, so [here's a link](http://clojurescript.io/) to a ClojureScript REPL.
[Here's a link](https://tio.run/nexus/clojure#dVJBboQwDLzzipEqVaEVEvuAvgTtwQqBpgIHQTisVn07dZKNmm53cyBoZmyP7RyqNwNjIO0bfdGTQcfnClCTc4v87/MWkAAF0Hh0UStEhNJJxObXhqHkEoA2jxBd1@dCKFJalumC9z@gwINb0RHUSjwaKO129ogZ7zMUWd7@EcgZTg8oIS3rh0SIM9Q3UtHy@ESC2NxTUmj2n8k0qM4nu1d2kHg3G7xc8wy/04zityqc6L0sI9Pgr6hBDkypqyqtr5nJMrpX0DpuxfoI7W1zofYHCKe2baWcnbKp3v3WXaR3P4n32/5U8SxCP3cO4zRzo4eKJurjBw "Clojure – TIO Nexus") to a Clojure program which prints the last element in the list from 0 to 1000.
Here's the output for `9999`:
```
[9999 1451520 269 363602 1455 265 842 40346 775 10200 6 720 5043 151 122 5 120 4 24 26 722 5044 169 363601 1454]
```
I have a strong suspicion that all numbers must eventually settle at `1` or the loop `[169 363601 1454]`.
## Ungolfed code:
```
(defn fact-cycle [n]
  (loop [nums [n]]
    (let [fact-num
          (let [str-n (str (last nums))]
            (apply +
              (for [a (range (count str-n))]
                (apply *
                  (range 1
                    (inc (int (nth str-n a))))))))]
      (if (some #{fact-num} nums) nums
        (recur
          (conj nums fact-num))))))
```
Explanation coming soon!
[Answer]
## JavaScript (ES6), ~~91~~ 89 bytes
*Saved 2 bytes thanks to fəˈnɛtɪk*
It turns out to be quite similar to [the other JS answer](https://codegolf.stackexchange.com/a/117596/58563).
```
f=(n,x=!(a=[n]))=>n?f(n/10|0,x+(F=n=>n?n--*F(n):1)(n%10)):~a.indexOf(x)?a:f(x,!a.push(x))
```
```
f=(n,x=!(a=[n]))=>n?f(n/10|0,x+(F=n=>n?n--*F(n):1)(n%10)):~a.indexOf(x)?a:f(x,!a.push(x))
console.log(f(132))
```
[Answer]
# [Perl 6](https://perl6.org), 64 bytes
```
{my@a;$_,{[+] .comb.map:{[*] 2..$_}}...^{$_∈@a||[[email protected]](/cdn-cgi/l/email-protection): $_}}
```
[Try it](https://tio.run/nexus/perl6#Ky1OVSgz00u25sqtVFArLs3VTUtMLskvykzMUbD9X51b6ZBorRKvUx2tHaugl5yfm6SXm1hgVR2tFatgpKenEl9bq6enF1etEv@oo8MhsaZG0SFRr6C0OMNKAST3vzixUgHVUENjI2suTGELbIKGJqYm1v8B "Perl 6 – TIO Nexus")
## Expanded:
```
{
  my @a;             # array of values already seen
  $_,                # seed sequence with the input
  {
    [+]              # reduce using &infix:<+>
      .comb          # the digits of $_ (implicit method call)
      .map:          # do the following for each
      {
        [*] 2..$_    # get the factorial of
      }
  }
  ...^               # keep generating values until
                     # (｢^｣ means throw away the last value when done)
  {
      $_ ∈ @a        # is it an elem of @a? (｢∈｣ is shorter than ｢(cont)｣)
    ||               # if it's not
      !              # boolean invert so this returns False
        @a.push: $_  # add the tested value to @a
  }
}
```
Every line above that has `{` starts a new bare block lambda with an implicit parameter of `$_`.
I used `[*] 2..$_` instead of `[*] 1..$_` purely as a micro optimization.
[Answer]
# JavaScript, 92 bytes
Thanks @Shaggy for golfing off one byte with includes  
Thanks @Neil for golfing off two bytes
**Code separated into individual functions 92 bytes**
```
f=(x,a=[])=>a.includes(x)?a:f(k(x),a,a.push(x))
p=y=>y?y*p(y-1):1
k=n=>n?p(n%10)+k(n/10|0):0
```
**Code on one line 92 bytes**
```
f=(x,a=[])=>a.includes(x)?a:f((k=n=>n?(p=y=>y?y*p(y-1):1)(n%10)+k(n/10|0):0)(x),a,a.push(x))
```
## Explanation
Initially call the function with just a single argument, therefore a=[].
If x exists in the array a return a `a.includes(x)?a:...`
Otherwise, append x to a and pass the factorial digit sum and a to the function `(a.push(x),f(k(x),a))`
```
p=y=>y?y*p(y-1):1
k=n=>n?p(n%10)+k(n/10|0):0
```
Factorial Digit sum performed so that it will not exceed the maximum recursion limit.
**List of all possible endpoints:** 1, 2, 145, 169, 871, 872, 1454, 40585, 45361, 45362, 363601
[Try it online!](https://tio.run/nexus/javascript-node#DcbBCgIhEADQ@/5HMFOuad2E0Q@JDsO2ViijIAsr9O@27/RGJNgV0@OJ5Fl/Zcnba22wY2AXIR1RrFjXrX2O41Spk@@hnyv02aKzUyIhL6GCnKzBSwK5WvMz6MxYirSSV53LGyLY@w1x/AE)
[Answer]
# [Haskell](https://www.haskell.org/), ~~80~~ 67 bytes
```
g#n|elem n g=g|h<-g++[n]=h#sum[product[1..read[d]]|d<-show n]
([]#)
```
[Try it online!](https://tio.run/nexus/haskell#BcFBCoAgEADAe69YsEMRBtU1X7LsQdI0yE006eLfbaY5wdXeNgCDU676XbppQiblRS4BY3pMOV5c5jlZbdAQVbPL7J8PmLpTDUhibEFfDApiuviFHk5YtrX9 "Haskell – TIO Nexus") Usage: `([]#) 132`
Edit: Saved 13 bytes with typs from Ørjan Johansen!
[Answer]
# Pyth, 9 bytes
```
.us.!MjNT
.us.!MjNTQ  implicit Q
.u          explained below
       N      current value
      j T     convert to decimal (list of digits)
   .!M        factorial of each digit
  s           sum
```
[Try it online!](http://pyth.herokuapp.com/?code=.us.%21MjNT&input=132&debug=0)
This answer uses `.u` ("Cumulative fixed-point. Apply until a result that has occurred before is found. Return all intermediate results.")
[Answer]
# Pyth, 30 bytes
```
W!hxYQQ=+YQKQ=Q0WK=+Q.!%KT=/KT
```
[Try It Here](http://pyth.herokuapp.com/?code=W%21hxYQQ%3D%2BYQKQ%3DQ0WK%3D%2BQ.%21%25KT%3D%2FKT&input=132&debug=0)
[Answer]
# [Python 3](https://docs.python.org/3/), 110 bytes
```
g=lambda x:x<1or x*g(x-1)
def f(n):
 a=[];b=n
 while b not in a:a+=[b];yield b;b=sum(g(int(x))for x in str(b))
```
[Try it online!](https://tio.run/nexus/python3#PcxNCsMgEEDhvaeY5UxLF7Y7U08SsnDwp4IxxRhqT28SCt0@Pl4POpmZrYGm2lMuBdolYLtJEtZ58JhJCTB6nAbWWcDnFZMDhrxUiBmMMlc98jR8o0sW@EDrNmPAmCs2In8OT7jWgkzU/8GjfNxJvctP9h0 "Python 3 – TIO Nexus")
[Answer]
# R, 120 Bytes
```
o=scan()
repeat {
q=sum(factorial(as.double(el(strsplit(as.character(o[length(o)]), "")))))
if(q%in%o)break
o=c(o,q)
}
o
```
[Answer]
# Java 9 JSHell, 213 bytes
```
n->{Set<Integer>s=new HashSet<>();
return IntStream.iterate(n,i->(""+i).chars()
.map(x->x<50?1:IntStream.rangeClosed(2,x-48)
.reduce(1,(a,b)->a*b)).sum()).boxed()
.takeWhile(x->s.add(x)).collect(Collectors.toList());}
```
[Try it online!](https://tio.run/nexus/java-openjdk9#bVCxTsMwEN3zFVYnuyQWLSAh0oahEgIJpgwMiOGSXFODY0f2paSq@u3FoamQELc8@b1357unmtY6Yh@wBdmR0nKaRuovt@5MScqaf0VPDqEZpKjtCq1KVmrwnr2AMmwfsVAj7wkowNaqijVB5Tk5Zeq3dwau9mI0D/Uwfrh4MoQ1upg9K0/nV5axNVseTZLtc/xl/dLgF3sEvxnYjIvUIXXOsGDIT0sqQgeE3MQqyfhkcqGELDfgPBeygZb3SdYvbi7vZ3e/PQ5MjSttPVZ8HvfJ9a2QDquuRD6LOcSFSDKYFkJI3zU8QGH7YBWS4BNfN0rjMNZLqCreB7m0WmNJfHVC67wkO5wXetPD8RxBmu88YSNtR7INMZE2fC2hbfWOD3fmJRiDjo82ZYQ02FPYO8wR6U@Uh@hwnF3NvwE "Java (OpenJDK 9) – TIO Nexus")
Note: This solution relies on the string representation of a number having code points in the range 48-57. Works for ASCII, UTF-8, Latin-1, all ISO-8859-\* character sets, most code pages. Does not work for EBCDIC. I don't think anyone will deduct points for that. :)
Ungolfed:
```
Function<Integer, List<Integer>> f =        // function from Integer to List of Integer
n -> {
    Set<Integer> s = new HashSet<>();       // memo of values we've seen
    return IntStream.iterate(n,             // iterate over n, f(n), f(f(n)), etc.
    i -> (""+i).chars()                     // the sumFac function; for all chars
        .map(x -> x < 50? 1 :               // give 1 for 0! or 1!
        IntStream.rangeClosed(2, x-48)      // else produce range 2..d 
        .reduce(1,(a,b)->a*b))              // reduction to get the factorial
        .sum())                             // and sum up the factorii!
                                            // now we have a stream of ints
                                            // from applying sumFac repeatedly
        .boxed()                            // box them into Integers (thanks, Java)
        .takeWhile(x->s.add(x))             // and take them while not in the memo
        .collect(Collectors.toList());      // collect them into a list
}
```
Notes:
* The return value of Set::add is very helpful here; returns true **iff** the item was not in the set
* I was being sarcastic when I said "Thanks, Java"
* *factorii* isn't really a word; I just made that up
[Answer]
# Pyth, ~~22~~ 11 bytes
```
.usm.!sd+Nk
```
[Try it online!](http://pyth.herokuapp.com/?code=.usm.%21sd%2BNk&input=132&debug=0)
Lots of credit to [Leaky Nun's answer](https://codegolf.stackexchange.com/a/117669/52152), which introduced me to `.u`, and helped save a massive 11 bytes of this program.
Explanation:
```
.usm.!sd+NkQ | ending Q is implicitly added
             | Implicit: Q = eval(input())
.u         Q | Repeat the function with initial value Q until a previous value is found. Return all intermediate values
  s          | Summation
   m.!sd     | For each character 'd' in the string, convert to integer and take the factorial
        +Nk  | Convert function argument to string
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), 6 bytes
```
U¡oṁΠd
```
[Try it online!](https://tio.run/##yygtzv7/P/TQwvyHOxvPLUj5//@/obERAA "Husk – Try It Online")
[Answer]
# Axiom, 231 bytes
```
l(a:NNI):List NNI==(r:List NNI:=[];repeat(r:=cons(a rem 10,r);a:=a quo 10;a=0=>break);r)
g(a:NNI):NNI==reduce(+,[factorial(x) for x in l(a)])
h(a:NNI):List NNI==(r:=[a];repeat(a:=g(a);member?(a,r)=>break;r:=cons(a,r));reverse(r))
```
not golfed functions and some test
```
-- convert one NNI in its list of digits
listify(a:NNI):List NNI==
    r:List NNI:=[]
    repeat
        r:=cons(a rem 10,r)
        a:=     a quo 10
        a=0=>break
    r
-- g(1234)=1!+2!+3!+4!
SumfactorialDigits(a:NNI):NNI==reduce(+,[factorial(x) for x in listify(a)])
ListGenerateFromSumFactorialDigits(a:NNI):List NNI==
    r:=[a]
    repeat
       a:=SumfactorialDigits(a)
       member?(a,r)=>break
       r:=cons(a,r)
    reverse(r)
(9) -> h 132
   (9)
   [132, 9, 362880, 81369, 403927, 367953, 368772, 51128, 40444, 97, 367920,
    368649, 404670, 5810, 40442, 75, 5160, 842, 40346, 775, 10200, 6, 720,
    5043, 151, 122, 5, 120, 4, 24, 26, 722, 5044, 169, 363601, 1454]
```
[Answer]
# Java 7, 220 bytes
```
String c(int n){String r=n+",",c;for(;!r.matches("^"+(c=(n=d(n))+",")+".*|.*,"+c+".*");r+=c);return r;}int d(int n){int s=0;for(String i:(n+"").split(""))s+=f(new Long(i));return s;}long f(long x){return x<2?1:x*f(x-1);}
```
**Explanation:**
```
String c(int n){                            // Method with integer parameter and String return-type
  String r=n+",",                           //  Result-String (which starts with the input integer + a comma
         c;                                 //  Temp String
  for(;!r.matches(                          //  Loop as long as the result-String doesn't match the following regex:
    "^"+(c=(n=d(n))+",")+".*|.*,"+c+".*");  //    "^i,.*|.*,i,.*" where `i` is the current integer
                                            //   `n=d(n)` calculates the next integer in line
                                            //   `c=(n=d(n))+","` sets the temp String to this integer + a comma
    r+=c                                    //   And append the result-String with this temp String
  );                                        //  End of loop
  return r;                                 //  Return the result-String
}                                           // End of method
int d(int n){                               // Separate method (1) with integer parameter and integer return-type
  int s=0;                                  //  Sum
  for(String i:(n+"").split(""))            //  Loop over the digits of `n`
    s+=f(new Long(i));                      //   And add the factorial of these digits to the sum
                                            //  End of loop (implicit / single-line body)
  return s;                                 //  Return the sum
}                                           // End of separate method (1)
long f(long x){                             // Separate method (2) with long parameter and long return-type (calculates the factorial)
                                            // (NOTE: 2x `long` and the `new Long(i)` is shorter than 2x `int` and `new Integer(i)`, hence long instead of int)
  return x<2?                               //  If `x` is 1:
      1                                     //   return 1
    :                                       //  Else:
      x*f(x-1);                             //   return `x` multiplied by the recursive-call of `x-1`
}                                           // End of method (2)
```
**Test code:**
[Try it here.](https://tio.run/nexus/java-openjdk#PY4xb4MwEIX3/IqrpzugVki3uFbnSs2UMUol1wFiCQyyTUtF@e3UIFoP99757PedrpX3cBrnc3DGVqDR2ACWxq130qYsY5kWZetQPDjeqKDvhUf2zlLUEq28oSVaXsXCkx@eZCzVi2UkXCp1rEXonQUnpiX99sdYxMv9Gr3xzBEjkBH3XW0CRkc@lSXa4gveWluhof84L6Y6XkGJqww0boPh@fCSH4ekxOExJzHNAF3/URsNPqgQ5bM1N2iUsRv2cgVF4w7iOX/7UDS87QPv4ijUdmWfkLhe3asNRVU4VJf9leIy8de0m@Y5fzr8Ag)
```
class M{
  String c(int n){String r=n+",",c;for(;!r.matches("^"+(c=(n=d(n))+",")+".*|.*,"+c+".*");r+=c);return r;}int d(int n){int s=0;for(String i:(n+"").split(""))s+=f(new Long(i));return s;}long f(long x){return x<2?1:x*f(x-1);}
  
  public static void main(String[] a){
    System.out.println(new M().c(132));
  }
}
```
**Output:**
```
132,9,362880,81369,403927,367953,368772,51128,40444,97,367920,368649,404670,5810,40442,75,5160,842,40346,775,10200,6,720,5043,151,122,5,120,4,24,26,722,5044,169,363601,1454,
```
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 44 bytes
```
~]{..)\;10base{,1\{)*}/}%{+}*.@\+@@?)!}do);`
~                                             eval input
 ]                                            initialization
  {                                   }do     do...
   ..)\;                                          initialization
        10base                                    get digits
              {,1\{)*}/}%                         factorial each
                         {+}*                     sum
                             .@\+@@?)!        while result not found
                                         );   drop last element
                                           `  tostring
```
[Try it online!](https://tio.run/nexus/golfscript#@18XW62npxljbWiQlFicWq1jGFOtqVWrX6tarV2rpecQo@3gYK@pWJuSr2md8P@/obERAA "GolfScript – TIO Nexus")
The factorial part is from [here](https://codegolf.stackexchange.com/a/629/48934).
[Answer]
## C, 161 bytes
```
f(a){return a?a*f(a-1):1;}
a(l){return l?f(l%10)+a(l/10):0;}
c,t,o;r(i){for(t=o=i;t=a(t),o=a(a(o)),c=t^o;);for(t=i;t^c;printf("%d ",t),c=c|t^o?c:o,t=a(t),o=a(o));}
```
[See it work online.](https://ideone.com/FiF0VM)
[Answer]
# TI-BASIC, ~~85~~ ~~79~~ ~~64~~ 60 bytes
```
:Prompt L₁                             //Get input as 1 length list, 4 bytes
:Lbl C                                //create marker for looping, see below, 3 bytes
:int(10fPart(Xseq(10^(~A-1),A,0,log(X //split input into list of digits, 20 bytes
:sum(Ans!→X                           //factorial and sum the list, write to new input, 6 bytes
:If prod(L₁-X                         //Test to see if new element is repeated, see below, 7 bytes
:Then                                 //Part of If statement, 2 bytes
:augment(L₁,{X→L₁                     //Push new input to List 1, 10 bytes
:Goto C                               //Loop back to beginning, 3 bytes
:Else                                 //Part of If statement, 2 bytes
:L₁                                   //Print Answer, 2 bytes
```
Since this is running on a graphing calculator, there is limited RAM. Try testing it with numbers that loop quickly, like `169`.
**More Explanation:**
```
:int(10fPart(Xseq(10^(~A-1),A,0,log(X
              seq(10^(~A-1),A,0,log(X //Get a list of powers of 10 for each digit (i.e. 1, 0.1, 0.01, etc.)
             X                        //Multiply by input
       fPart(                         //Remove everything but the decimal
     10                               //Multiply by 10 (move one digit in front of the decimal
:int(                                 //Truncate to an integer
```
`If prod(L₁-X` works by subtracting the new element from the old list, then multiplying all the elements of the list together. If the element was already in the list, the product will be `0`, a falsey value. Otherwise, the product will be a positive integer, a truthy value.
[Answer]
# [J](http://jsoftware.com/), 40 31 bytes
Edit: 9 bytes saved using the improvements by FrownyFrog. Thanks!
```
f=.$:@,~`]@.e.~[:+/@:!10#.inv{:
```
Original code:
```
f=.[`($:@,)@.([:-.e.~)[:+/!@("."0&":@{:)
```
In this case I decided to count the bytes for the verb definition, since otherwise it doesn't work in the interpreter. 
Explanation:
```
                         (        {:) - Takes the last element of the array
                               ":@    - converts it to string
                          "."0&       - converts each character back to integer
                       !@             - finds the factorials
                     +/               - sums them
                   [:                 - cap (there are 2 derived verbs above, we need 3 for a fork)
          (    e.~)                   - check if the result is present in the list    
             -.                       - negates the above check
           [:                         - cap
        @.                            - Agenda conjunction, needed for the recursion
  ($:@,)                              - if the result is not in the list, add it to the list and recur
[`                                    - if the result is in the list, display it and stop    
```
[Try it online!](https://tio.run/##y/r/P81WLzpBQ8XKQUfTQU8j2kpXL1WvTjPaSltf0UFDSU/JQE3JyqHaSvN/anJGvkKagqGR8X8A "J – Try It Online")
[Answer]
# [Tcl](http://tcl.tk/), 143 bytes
```
proc P {n L\ ""} {proc F n {expr $n?($n)*\[F $n-1]:1}
while {[set n [expr [join [lmap d [split $n ""] {F $d}] +]]] ni $L} {lappend L $n}
set L}
```
[Try it online!](https://tio.run/##HY69DoMwDIT3PMUJMfRHHWg3lm6dMrAHDwgiNVVqIkjVSlGePTVMPtnf3TmOvpSwzCM6JIbuUVUZad88wEj2FxbUfD/UfDz15iH60lDbZPV9Om@RzGqjgGYHzWt2ov17CJhg1uBdFIeEEpJ4p0w4ExHYodZS5IcQLE/QQmW1Relcdrt0q@Z2Vds3n7jKve3ZdDIpl/IH "Tcl – Try It Online")
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), ~~17~~ ~~16~~ 15 bytes
Saved 1 byte thanks to @[Adám](https://codegolf.stackexchange.com/users/43319/ad%c3%a1m) and another later
```
f←(#+.(!⍎)⍕)⌂traj
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/P@1R2wQNZW09DcVHvX2aj3qnaj7qaSopSswCSikYGhsBAA "APL (Dyalog Extended) – Try It Online")
`traj` is a function in the dfns workspace that runs a function until a cycle is detected. Here, that function is `#+.(!⍎)⍕`. `⍕` turns the argument into a string. Each character/digit (`¨`) is executed/turned into a number (`⍎`). `!` finds the factorial of each of these digits. Then `+` adds up all these factorials. `#` is used because `#⍎foo` just executes `foo`, so it's `#f.⍎` is practically the same as `{f/⍎¨⍵}` here.
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~25~~ 20 bytes
Saved 5 bytes thanks to @[Adám](https://codegolf.stackexchange.com/users/43319/ad%c3%a1m)!
```
1↓{⍵,⍨+/!⍎¨⍕⊃⍵}⍣(⊃∊)
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R2wTDR22Tqx/1btV51LtCW1/xUW/foRWPeqc@6moGCtY@6l2sAWJ2dGkClSsYGhsBAA "APL (Dyalog Unicode) – Try It Online")
Output is reversed.
This is very similar to the code above, but uses the power operator (`⍣`) to run the dfn until a cycle is reached, then drops the first element (`1↓`) because it runs 1 extra time. `{⍵,⍨+/!⍎¨⍕⊃⍵}` applies the function in the question to the first element of the argument (`⊃⍵`), then prepends it to the argument (`⍵,⍨`). Each time it is called, the list grows by one. The train `⊃∊` is applied with the next result on the left side and the previous result on the right side and tells ⍣ when to stop. `∊` is membership and tells which of the next result's elements are in the previous results (if one of them is repeated, there is a cycle). Then it picks the first of these booleans (`⊃`) because we need a single value and the rest have been checked already in previous iterations.
[Answer]
# [PowerShell Core](https://github.com/PowerShell/PowerShell), 87 bytes
```
param($r)for(;$r-notin$l){$l+=,$r
$r=("$r"|% t*y|%{1.."$_"-ne0-join'*'})-join'+'|iex}$l
```
[Try it online!](https://tio.run/##JcbBCoMwDADQ@75ilEhbXWXqcfgtQ0bEjqyRKOiwfnt22Du9mTeUZUKi8GJB1XmQ4eNA/MjiHiAh8RoTkD@Aqv4GcgHpnQExubiu5TcXR1PXBp4mJLyHN8dkS3v6/yqbI@4nkKo2XfsD "PowerShell Core – Try It Online")
Thanks to mazzy for saving a lot of bytes!
## Explained (old implementation, but close enough)
```
param($r)for(;$r-notin$l                       # Checks that the last computed value isn't an existing one
                        ){$l+=,$r              # Adds it to the list
$r=("$r"|                                      # Converts r as a string
      % t*y|                                   # Converts it to a char array
      %{1.."$_"-ne0-join'*'}                   # Builds the factorial calculation strings and handles 0!. e.g. 1*2*3*4
   )-join'+'|iex}                              # Joins them with "+" and computes it. e.g. 1*2*3*4+1*2*3
$l                                             # Returns all the values in the list
```
[Answer]
# [Perl 5](https://www.perl.org/) `-MList::Util=product,sum -n`, 49 bytes
```
say&&($_=sum map{product 1..$_}/./g)until$k{$_}++
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVJNTUMl3ra4NFchN7GguqAoP6U0uUTBUE9PJb5WX08/XbM0ryQzRyW7GsjX1v7/39DY6F9@QUlmfl7xf11fn8ziEiurUKAKkBE6UO1ACVM9A0OD/7p5AA "Perl 5 – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 72 bytes
```
Most@NestWhileList[Total[IntegerDigits@#!]&,#,DuplicateFreeQ@*List,All]&
```
[Try it online!](https://tio.run/##FctBCsIwEAXQs0ihizKLegAhQhEEKyqCi5DFINN0YJqW5Hv@qPv3FsYsC0PfXKdDHdcCd5WC16wmFy3wzxVs/pwgUfKgUVFcswstNTR8NvtFyCmL3F3393Q0C20defO3rAmum@jBKYrvad@HUL8 "Wolfram Language (Mathematica) – Try It Online")
Keeps applying `sumFac` to it's own output until it sees a duplicate value, then returns a list of all values excluding that final duplicate.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 10 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
│¼µ\Ä▬Éε╩X
```
[Run and debug it](https://staxlang.xyz/#p=b3ace65c8e1690eeca58&i=132)
[Answer]
# [Perl 5](https://www.perl.org/) `-n`, 65 bytes
```
say,(map{$f=1;map{$f*=$_}2..$_;$.+=$f}/./g),$_=$.until$.=$r{$_}++
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVJHIzexoFolzdbQGsLQslWJrzXS01OJt1bR07ZVSavV19NP19RRibdV0SvNK8nMUdGzVSmqBqrS1v7/39DY6F9@QUlmfl7xf11fUz0DQ4P/unkA "Perl 5 – Try It Online")
Uses `map` as regular loops (ignoring return value), and `$.` as a temporary variable (to save space before `until`).
]