text:
Oreoorererereoo
Oreoorererereoo
Given an input string that is similar to the word "oreo", give an ASCII representation of the cookie that is as wide as the input string (to ensure cookie stability).
Rules

The input is lowercase, a non-empty string with no whitespace containing any combination of the strings "o" and "re", and containing only those strings.
The string "o" represents the solid cookie, while the string "re" represents the filling.
The output must be a stacked cookie that is as wide as the input string.
The output may not be an array of strings
The cookie must overlap the filling by one character on each side
The characters used for the output don't have to match the output below (█ and ░), they just have to be different non-whitespace characters for the two parts of the cookie
The whitespace padding on the left side of the filling is required, and any trailing whitespace is optional

Examples
Input: oreo
Output:
████
 ░░
████

Input: o
Output:
█

Input: re
Output: (two spaces)

Input: rere
Output:
 ░░
 ░░

Input: oreoorererereoo
Output:
███████████████
 ░░░░░░░░░░░░░
███████████████
███████████████
 ░░░░░░░░░░░░░
 ░░░░░░░░░░░░░
 ░░░░░░░░░░░░░
 ░░░░░░░░░░░░░
███████████████
███████████████

Since this is code golf the shortest answer wins, good luck :)

"The whitespace padding on each side of the filling is required". Does this actually mean that there must be a space character at the end of each line of filling? If so why? As long as it works visually then what does this requirement add to the challenge?

@ ElPedro Good point, I modified the rules
and @Dennis I edited the rules so the comments should be okay to clean up

@JonathanAllan Since it's printing "ascii-art" I removed that rule, it looks like I forgot to update the question. Should be updated now.

@GammaGames, if whitespace on the right is not required anymore, I assume the output for test case re should be now acceptable as 1 or 2 spaces, not necessarily 2?

@KirillL. That would be correct, yes. When I originally designed it I accidentally didn't use general ascii rules, but I modified them as to be more flexible.

Jelly,  16 14  13 bytes
-1 Thanks to Erik the Outgolfer
OḂƇẒṁ€aØ.¦€⁶Y

Uses 1 for the cream and 0 for the cookie.
Try it online!
How?
OḂƇẒṁ€aØ.¦€⁶Y - Main Link: list of characters, V    e.g. 'orereo'
O             - ordinal (vectorises)                     [111,114,101,114,101,111]
  Ƈ           - filter keep those for which:
 Ḃ            -   modulo 2                               [111,    101,    101,111]
   Ẓ          - is prime? (vectorises)                   [  0,      1,      1,  0]
    ṁ€        - mould each like V                        [[0,0,0,0,0,0],[1,1,1,1,1,1],[1,1,1,1,1,1],[0,0,0,0,0,0]]
          €   - for each:
         ¦    -   sparse application...
       Ø.     -   ...to indices: literal [0,1] (0 is the rightmost index, 1 is the leftmost)
      a       -   ...apply: logical AND with:
           ⁶  -               space character           [[0,0,0,0,0,0],[' ',1,1,1,1,' '],[' ',1,1,1,1,' '],[0,0,0,0,0,0]]
            Y - join with newline characters            [0,0,0,0,0,0,'\n',' ',1,1,1,1,' ','\n',' ',1,1,1,1,' ','\n',0,0,0,0,0,0]
              - implicit print                       ...smashes everything together:
              -                                         000000
              -                                          1111
              -                                          1111
              -                                         000000

Previous 16 byter:
ḟ”eẋ€Ly@Ø.¦€⁾r Y

Uses r for the cream and o for the cookie.
Try it online!

I was hoping for a Jelly entry, such an interesting language!

Pepe, 364 bytes
Unfortunately the online interpreter does not take care of compressing comments, hence all o characters will be replaced by a space.. Neither the spaces nor the o are necessary, so this could be 295 bytes, but I like it more this way:
rEeEEeeEeEororEEoreoreeeEeeeeeorEEEEeoREeoreorEeEEeEEEEororEEoreorEEEEEoREeoreorEeEEEeeEeororEEoreoReoREoREEEeoREEEEEoreorEorEEEeorEEEEEoreEoREeoreoREEeoREEEEeEeeoREEEeoREeeEoREEEeoREEEEEEEorEEEeEorEEEeoREoREEEeoREEEEEoREEoReoreorEEEeEoREEEEEEeorEEEeoReEoREoREEEeoREEoReoroReEeoREoREEEeorEEEEeoReeoREEEeoREeeEoREEEeoREEEEEEEoreoReoReoREoREEEeoREEEEEoreeeeeEeEeoRee

Try it online!
Ungolfed
There might be some golfing oppurtunities with flags which I missed, but I'm done for now:
# "function" for 'e'
rEeEEeeEeE rrEE
  re          # remove duplicated argument
  reeeEeeeee  # print space
  rEEEEe      # decrement counter twice
REe re

# "function" for 'o'
rEeEEeEEEE rrEE
  re      # remove duplicated argument
  rEEEEE  # increment counter
REe re

# "function for 'r'
rEeEEEeeEe rrEE
  re Re              # remove duplicated argument & char
  RE REEEe REEEEE    # push 1
  re rE rEEEe rEEEEE # replace 1
  reE                # goto 1
REe re

# Main

REEe REEEEeEee                # read input & reverse
REEEe REeeE REEEe REEEEEEE    # push length-1 & move to r

rEEEeE rEEEe # dummy loop-var (fucking do-whiles...)
RE REEEe REEEEE REE  # while [label-1]

  # Call the right procedure depending on current character,
  # sets stacks up as follows:
  #   R [ .... *currentChar ]
  #   r [ (N-1) *count ]
  Re re          # pop 1 & loop-counter
  rEEEeE         # duplicate counter
  REEEEEEe rEEEe # copy current char to other stack
  ReE            # jeq to 'o'-label or 'e'-label

  # Output currentChar count times:
  RE REEEe REE # while [label-0]:
    Re         #   pop 0
    rReEe      #   print character
    RE REEEe   #   push 0
    rEEEEe     #   decrement counter
  Ree

  REEEe REeeE REEEe REEEEEEE  # push length-1 & move to r
  re Re Re                    # pop 0, counter and 9((((currentChar
  RE REEEe REEEEE             # push 1
  reeeeeEeEe                  # print new-line

Ree

I moved this conversation to chat for you.

Canvas, 19 18 17 bytes
e ∙╋
：r≠＊┤］；Ｌ×⁸↔⁸

Try it here!
Uses the annoyingly long code of ：r≠＊┤］ to remove rs from the input..

That's a handy feature, and cool language!

Japt -R, 16 15 bytes
re ¬£çX sX²èrÃû

Try it
                    :Implicit input of string U
re                  :Remove all "e"s
   ¬                :Split to array of characters
    £               :Map each X
     çX             :  Repeat X to the length of U
        s           :  Slice from index
         X²         :   Duplicate X
           èr       :   Count the occurrences of "r"
             Ã      :End map
              û     :Centre pad each element with spaces to the length of the longest
                    :Implicitly join with newlines and output

Alternatives
re ¬ËpUÊaD²èrÃû
re ¬£îX rr²i^Ãû

05AB1E, 18 17 16 bytes
'eKεD'rQ2*Igα×}.c

-1 byte thanks to @Emigna
Uses o for the cookie and r for the filling.
Try it online or verify all test cases.
Explanation:
'eK                 '# Remove all "e" from the (implicit) input
                     #  i.e. "orereo" → "orro"
   ε         }       # Map all characters to:
    D                #  Duplicate the current character
     'rQ            '#  Check if it's an "r" (1 if truthy; 0 if falsey)
                     #   i.e. "r" → 1
                     #   i.e. "o" → 0
        ·            #  Double that
                     #   i.e. 1 → 2
                     #   i.e. 0 → 0
         Ig          #  Take the length of the input
                     #   i.e. "orereo" → 6
           α         #  Take the absolute difference between the two
                     #   i.e. 2 and 6 → 4
                     #   i.e. 0 and 6 → 6
            ×        #  Repeat the duplicated character that many times
                     #   i.e. "r" and 4 → "rrrr"
                     #   i.e. "o" and 6 → "oooooo"
              .c     # Then centralize it, which also imlicitly joins by newlines
                     # (and the result is output implicitly)
                     #  i.e. ["oooooo","rrrr","rrrr","oooooo"]
                     #   → "oooooo\n rrrr\n rrrr\noooooo"

Creative solution, But it does not solve the problem entirely:
oro would give a wrong answer

@MarkSmit oro isn't a possible input, since the input will only contain os and res. Regardless, oro still seems to output correctly following the spec, since it outputs ooo\n r\nooo. What is wrong about it?

This is invalid: "The whitespace padding on each side of the filling is required"

2* can be · and the missing whitespace can be fixed by changing ».c to .c.B»

@Emigna Ah, can't believe I haven't thought about ·, thanks! :) And always nice to have changing specs during the challenge, sigh..

Trailing whitespace is now optional!

@P1h3r1e3d13 Thanks for letting me know. :)

C# (Visual C# Interactive Compiler), 95 bytes
n=>n.Replace("o",new String('-',n.Length)+"\n").Replace("re"," ".PadRight(n.Length-1,'|')+"\n")

Try it online!
Alternative using Aggregate, 108 bytes
n=>n.Aggregate("",(d,c)=>d+(c<102?"":c<112?new String('-',n.Length)+"\n":" ".PadRight(n.Length-1,'|')+"\n"))

Try it online!

now it trims trailing spaces..

There was enough feedback that I removed the trailing newline rule. Feel free to update your entry.

Your replace doesn't work when the input is o, since the n.Length-2 will result in -1.

The n.Length-2 is is for when the input has re.

R, 106 bytes
function(s,N=nchar(s)){m=rep(el(strsplit(gsub('re',0,s),'')),e=N)
m[m<1&seq(m)%%N<2]=' '
write(m,1,N,,"")}

Try it online!

-12 bytes thanks to @Giuseppe

Previous version with explanation :
R, 118 bytes
function(s,N=nchar(s)){m=t(replicate(N,el(strsplit(gsub('re',0,s),''))))
m[m<1&row(m)%in%c(1,N)]=' '
write(m,1,N,,'')}

Try it online!

-1 byte thanks to @Giuseppe

Unrolled code and explanation :
function(s){                       # s is the input string, e.g. 'oreo'

  N = nchar(s)                     # store the length of s into N, e.g. 4

  s1 = gsub('re',0,s)              # replace 're' with '0' and store in s1, e.g. 'o0o'

  v = el(strsplit(s1,''))          # split s1 into a vector v of single characters
                                   # e.g. 'o','0','o'

  m = replicate(N,v)               # evaluate N times the vector v and arrange
                                   # the result into a matrix m (nchar(s1) x N)
                                   # e.g.
                                   # 'o' 'o' 'o' 'o'
                                   # '0' '0' '0' '0'
                                   # 'o' 'o' 'o' 'o'

  m = t(m)                         # transpose the matrix

  m[m<1 & row(m)%in%c(1,N)] = ' '  # substitute the zeros (i.e. where < 1)
                                   # on the 1st and last row of the matrix with ' ' (space)
                                   # e.g.
                                   # 'o' ' ' 'o'
                                   # 'o' '0' 'o'
                                   # 'o' '0' 'o'
                                   # 'o' ' ' 'o'

  write(m,1,N,,'')                 # write the matrix to stdout (write function transposes it)
                                   # e.g.
                                   # oooo
                                   #  00
                                   # oooo
}

106 bytes

aaand 104 bytes returning a list of lines, which isn't acceptable here, but it's an interesting idea (essentially my SNOBOL submission translated to R)

Retina, 21 19 bytes
L$`.
$.=*$&
r+¶ee

Try it online! Link includes test cases. Explanation:
L$`.
$.=*$&

List each letter on its own line repeated to the length of the original input.
r+¶ee

Remove the lines of rs and replace the first two ees on the next line with a space.
Edit: Saved 2 bytes thanks to @DomHastings.

This breaks the rules: "The whitespace padding on each side of the filling is required"

@NieDzejkob Sorry for overlooking that, should be fixed now.

FYI trailing whitespace requirement lifted.

@Neil You should fix that & :P

Nice, as always! You can save a couple of bytes doing the replace of the rs and ee in one go too: Try it online!

@DomHastings Oh, because the rs are always followed be es?

@DomHastings This version also more obviously admits for a test suite (although I could have done that with the original version by using [oe] instead of ., avoiding the need to remove rs).

Retina, 74 73 bytes
I feel like I haven't posted an answer in a very long time. Well, here I am. Also, Retina has changed a lot, and I feel like I suck at it now.
.+
$0$.0
(\d+)
*
e

o|r
$&¶
_$

+(/_/&`o¶
oo¶
_$

)/_/&`r¶
rr¶
¶$

m`^r

Try it online!

Whoa, what a crazy looking language. I like it!

doesn't include trailing whitespaces..

I like how [or] means o or r instead of [ or ]. Makes my head hurt.

@dzaima The question does not specify that trailing whitespaces are required. A comment asked, but no reply was given.

@nedla2004 That actually helped me notice a way to save a byte. Thanks.

@mbomb007 if I remember correctly, the answer to my question, before it was deleted (because it mentioned the no trailing newline requirement that's now gone) was that they're not mandatory, except if the last line is "re", though I have asked for reclarification

@nedla2004 well, it is regex

71?

49?

Oh wait, Neil already has a 24 (and can use his old 21 since the trailing space requirement has been lifted) byte one

C (gcc), 135 113 109 104 bytes

Saved twenty-two twenty-seven bytes thanks to NieDzejkob.
Saved four bytes thanks to ceilingcat.

#define $ putchar(33
O(char*r){for(char*e,*o=r,x;*r;$-23))for(x=*r++>111,e=x?$-1),r++,o+2:o;*e++;$+x));}

Try it online!

Shave off a few bytes with -D$=putchar

131 bytes if you add a trailing newline as allowed by the rules.

127 bytes if you move the e=o to the condition of the first for loop and then remove the else.

118 bytes if you choose the cookie and filling characters carefully.

113 bytes

So the rules were bent enough to allow a trailing newline ... Thanks for your 22 byte improvement.

@JonathanFrech I think they were just changed: "A line return at the end is optional"

@Rogem I know. But sometimes I refrain from using compiler flags. You are encouraged to fork my answer and implement your golf.

102 bytes-Try it online!

@Logern As I already wrote Rogem, you are encouraged to fork my answer.

-5 bytes since the whitespace rules changed.

@NieDzejkob The specifications really changed ... Thank you.

JavaScript, 72 65 64 bytes
s=>s.replace(/.e?/g,([x,y])=>(y?`
 `:`
`).padEnd(s.length+!y,x))

Try it online

Perl 5 -p, 47 bytes
s|o|X x($i=y///c).$/|ge;s|re|$".O x($i-2).$/|ge

Try it online!

This breaks the rules: "The whitespace padding on each side of the filling is required"

with some variations https://tio.run/##K0gtyjH9/79YJ78mVUdFrUKjUl9fP1lTT0VfJz3VulinqCY1VUVHQSc99////KLUfCCGwPz8f/kFJZn5ecX/dQsA

Nice! I tried combining the two s/// but couldn't make it shorter, however -F can save you a few: Try it online!

JavaScript ES6, 103 bytes
Using replace 103 bytes:
x=>x.replace(/o/g,"-".repeat(s=x.length)+`
`).replace(/re/g," "+"|".repeat(s>1?s-2:0)+`
`).slice(0,-1)

Try it online!
Using split and map 116 bytes:
x=>x.split("re").map(y=>("-"[h='repeat'](r=x.length)+`
`)[h](y.length)).join(" "+"|"[h](r>1?r-2:0)+`
`).slice(0,-1)

Try it online!

JS, nice! You reminded me that I was going to add a rule about not having line returns at the end of the output, I've added it. Sorry about that!

just removing the final newline is 12 bytes

There was enough feedback that I removed the trailing newline rule. Feel free to update your entry.

You can save a byte by using a template string with ${"|".repeat(s>1?s-2:0)} and its whitespaces, instead of using " "+"|".repeat(s>1?s-2:0).

If you use backticks for the string in the first split, you can remove the parentheses around it.

Python 3, 77 bytes
lambda x:x.replace("o","-"*len(x)+"\n").replace("re"," "+'.'*(len(x)-2)+"\n")

Try it online!

Clever! I did intend the output to not be printing whitespace for the filling (it's pretty much oreo ascii), so I have edited the rules accordingly. Sorry about that! And I always love a python answer :)

@JonathanFrech migth as well delete the comments, that approach was invalidated. I'll work on golfing more tomorrow.

You can remove the space at +" \n" to save a byte.

@KevinCruijssen can I? The input program says the whole cookie must be as wide as the input.

I interpreted that as meaning that a trailing space is the same (visually) as no space. That's the beauty of answers to ascii art challenges. If they look right they are right :-)

Rules now say trailing whitespace is optional.

Pyth, 28 bytes
FNzIqN"o"*lzN)IqN"r"+d*-lz2N
FNz                              For each value, N, in input
   IqN"o"                        if the character is "o"
         *lzN                    return the character times the length of the input
             )                   end if
              IqN"r"             if the character is "r"
FNzIqN"o"*lzN)IqN"r"+d*-lz2N
                        *-lz2N   return the character times length - 2
                    +d           padded on the left with " "

Try it here! This one uses a loop.
Pyth, 30 bytes
(As string replace)
::z"o"+*lz"="b"re"++d*-lz2"~"b
 :z"o"                           With the input, replace "o" with
       *lz"="                    "=" times the length of the input
      +      b                   and a newline added to the end
:             "re"               With the input, replace "re" with
                     *    "~"    "~" times
                      -lz2       the length of the input minus 2
                   +d            padded on the left with " "
                  +          b   and a newline added to the end

Try it here! This one uses string replacement.
I really like python (it's what I wrote my original test scripts in), so I thought I'd do a pyth entry for fun :)

Isn't this 37 bytes? I thought Pyth uses default ASCII as its codepage just like Python, if I remember correctly. So even though your code is 33 characters, both █ and ░ are three bytes each. Or am I missing something here?

Good call, I didn't realize that (I couldn't get pyth to work on tio.run, so I used the length counter on the herokuapp page). In the for loop I could just replace the character with N, even saving a few bytes!

Thought something like that happened. :) I once had the same issue with a 05AB1E answer of mine that was using characters outside its code page. Unfortunately TIO displays chars and bytes the same for most golfing languages. For Java or Python TIO will correctly state 33 chars, 37 bytes, but not in golfing languages on TIO. But in your solutions just changing those characters indeed fixes the issue, so it's not that big of a deal here.

@KevinCruijssen Wait, 05AB1E doesn't use an actual SBCS?

@ASCII-only Nope, it uses this codepage. If you use any character not in this codepage you'll have to use a different encoding (like ASCII), increasing the byte-count by A LOT considering the many non-ASCII characters 05AB1E uses itself already.

@KevinCruijssen Isn't that an actual SBCS? Even though 05AB1E can use different encodings, that specific codepage does still have glyphs for all 256 bytes (meaning it can't have muti-byte sequences)

If you're interested, it seems to work effortlessly on TIO for me.

@NieDzejkob Thank you! I updated the post with the tio links

Java 11, 110 106 bytes
s->{int l=s.length();return s.replace("re"," "+"~".repeat(l-2+1/l)+"\n").replace("o","=".repeat(l)+"\n");}

-4 bytes thanks to @ceilingcat.
Uses = for the cookie and ~ for the filling.
Try it online.
Explanation:
s->{                       // Method with String as both parameter and return-type
  int l=s.length();        //  Get the length of the input
  return s                 //  Return the input
          .replace("re",   //  After we've replaced all "re" with:
            " "            //   A space
            +"~".repeat(l-2+1/l)
                           //   Appended with length-2 amount of "~"
                           //   (or length-1 if the input-length was 1)
            +"\n")         //   Appended with a newline
          .replace("o",    //  And we've also replaced all "o" with:
            "=".repeat(l)  //   Length amount of "="
            +"\n");}       //   Appended with a newline

The above solution uses a replace. The following maps over the characters of the input instead:
Java 11, 113 112 bytes
s->s.chars().forEach(c->{if(c>101)System.out.println((c>111?" ":"")+(""+(char)c).repeat(s.length()-2*(~c&1)));})

-1 byte thanks to @Neil.
Try it online.
Explanation:
s->                           // Method with String parameter and no return-type
  s.chars().forEach(c->{      //  Loop over the characters as codepoint-integers
    if(c>101)                 //   If it's not an 'e':
      System.out.println(     //    Print with trailing newline:
       (c>111?                //     If it's an 'r'
         " "                  //      Start with a space
        :                     //     Else (it's an 'o' instead)
         "")                  //      Start with an empty string
       +(""+(char)c).repeat(  //     And append the character itself
          .repeat(            //     Repeated the following amount of times:
           s.length()         //      The input-length
           -2*(~c&1)));})     //      Minus 2 if it's an "r", or 0 if it's an "o"

Can you use ~c&1?

@Neil I indeed can, thanks.

This is invalid: "The whitespace padding on each side of the filling is required"

@NieDzejkob Fixed.. Always nice to have changing specs during the challenge, sigh..

@KevinCruijssen not anymore :P

@ASCII-only Rollbacked. :)

Powershell, 71 69 66 bytes
-2 bytes thanks @Veskah
-3 bytes thanks @AdmBorkBork
$l=$args|% le*
switch($args|% t*y){'o'{'#'*$l}'r'{" "+'%'*($l-2)}}

Less golfed test script:
$f = {

$l=$args|% length
switch($args|% t*y){
    'o'{'#'*$l}
    'r'{" "+'%'*($l-2)}
}

}

@(

,(
'oreo',
'####',
' %%',
'####'
)
,(
'o',
'#'
)
,(
're',
' '
)
,(
'rere',
' %%',
' %%'
)
,(
'oreoorererereoo',
'###############',
' %%%%%%%%%%%%%',
'###############',
'###############',
' %%%%%%%%%%%%%',
' %%%%%%%%%%%%%',
' %%%%%%%%%%%%%',
' %%%%%%%%%%%%%',
'###############',
'###############'
)

) | % {
    $s,$expected = $_
    $result = &$f $s
    "$result"-eq"$expected"
    # $result # uncomment this line to display a result
}

Output:
True
True
True
True
True

Looks like you don't need parens around the $args 69 bytes

The length of [string[]] is an [int[]]... The [int[]] is [int] if the array contains one element only. Great! Thanks!

The OP updated the challenge so you don't need trailing spaces anymore. This means your r can be " "+'%'*($l-2) instead for -3 bytes.

PHP, 100 99 93 bytes
$l=strlen($i=$argv[1]);$r=str_repeat;echo strtr($i,[o=>$r(X,$l)."
",re=>' '.$r(o,$l-2)."
"]);

Try it online!
OUCH. PHP's waaaay_too_long function names strike again!
Output:
$php oreo.php oreo
XXXX
 oo
XXXX

$php oreo.php o
X

$php oreo.php rere
 oo
 oo

$ php oreo.php oreoorererereoo
XXXXXXXXXXXXXXX
 ooooooooooooo
XXXXXXXXXXXXXXX
XXXXXXXXXXXXXXX
 ooooooooooooo
 ooooooooooooo
 ooooooooooooo
 ooooooooooooo
XXXXXXXXXXXXXXX
XXXXXXXXXXXXXXX

Invalid, cream lines need a trailing space

Fixed the trailing space. Thanks!

Oh boy, PHP! Also any trailing whitespace is now optional, there were enough people that pointed out that since it's printing out ascii it shouldn't really be required.

Mathematica, 111 91 bytes
#~StringReplace~{"o"->"O"~Table~(n=StringLength@#)<>"\n","re"->" "<>Table["R",n-2]<>" \n"}&

Try It Online!
This was majorly shortened thanks to Misha's edits.

My original code:
(z=StringRepeat;n=StringLength@#;#~StringReplace~{"o"->"O"~z~n<>"\n","re"->" "<>If[n>2,z["R",n-2],""]<>" \n"})&

This code is not very fancy but it seems too expensive to convert away from strings and then back or to do anything else clever.
In particular, with only 3-4 commands that have the name String, my original approach couldn't save bytes at all by trying to abstract that away. For example, the following is 129 bytes:
(w=Symbol["String"<>#]&;z=w@"Repeat";n=w["Length"]@#;#~w@"Replace"~{"o"->"O"~z~n<>"\n","re"->" "<>If[n>2,z["R",n-2],""]<>" \n"})&

A few improvements: StringRepeat can be Table since <> will convert the list into a string later; the If is unnecessary since we take the re branch only when n is at least 2; we can save on parentheses by defining n only when we use it. Try it online!

@MishaLavrov The If was added because StringRepeat would throw an error on the case of "re"; it doesn't allow you to repeat a string 0 times. Table has no such limitation, so that's a big save!

Bash, 87 bytes
Without sed:
f(){ printf %$1s|tr \  $2;}
c=${1//o/`f ${#1} B`
}
echo "${c//re/ `f $[${#1}-2] F`
}"

Thanks to @manatwork.
With sed (90 bytes):
f(){ printf %$1s|tr \  $2;}
echo $1|sed "s/o/`f ${#1} B`\n/g;s/re/ `f $[${#1}-2] F` \n/g"

Could you show us some sample usage? I'm a bit confused by your function expecting 2 parameters.

You write that into a script called test.sh. Then, you call test.sh from the command line as follows: bash test.sh oreoorererereoo. f is needed to repeat the character $2 $1 number of times

Oops. I completely misunderstood function f. Some further minor changes could be made there: Try it online!

Nice! Thank you for your suggestions! I will incorporate them into my answer. :)

For the sed based one you could use sed "…"<<<$1 instead of echo $1|sed "…".

75 bytes.

60 bytes

with zsh, 50 bytes

Ruby, 62 60 bytes
->s{s.gsub /./,?r=>" #{(?**z=s.size)[0..-3]}
",?o=>?O*z+?\n}

Try it online!
Uses O for the cookie, * for the filling.
-1 thanks to @manatwork pointing out a silly mistake and another -1 due to relaxation of the rules about whitespaces.

No need for parenthesis around .gsub's parameters.

$/ is an alias for ?\n.

PHP, 96 87 85 bytes
Thanks to @gwaugh    -9 Bytes
Thanks to @manatwork 	 -2 Bytes
<?=strtr($i=$argv[1],[o=>($r=str_repeat)(X,$l=strlen($i))."
",re=>" {$r(o,$l-2)}
"]);

Try it online!
Try it online! (87 Bytes)
Try it online (original 97 bytes submition)!

And a recursive function
PHP, 135 bytes
function f($w,$x=0){$f=str_repeat;echo($x<($l=strlen($w)))?($w[$x]=='o')?$f(█,$l)."
".f($w,$x+1):" ".$f(░,$l-2)."
".f($w,$x+2):"";}

Try it online! (recursive)

by combining the best of our two submissions I was able to get it down to 87 bytes TIO. Would you be game to go in with this as a collaborative submission? :)

I think we can remove 1 more byte by using the command short_tag_open, and instead of <?= we can use <?, or am i mistaken?

2 characters shorter with string interpolation: ' '.$r(o,$l-2)."␤" → " {$r(o,$l-2)}␤".

Thanks @manatwork sometimes i forgot php vars are evaluated in a string if the entire string is declared with "" istead of ''

This can be 3 bytes shorter using $argn: Try it online!

Perl 6, 37 bytes
{m:g/o|r/>>.&({S/rr/ /.say}o*x.comb)}

Try it online!
Anonymous code block that takes a string and prints the oreo, with o as the cookie and r as the cream.
Explanation:
{                                   }   # Anonymous code block
 m:g/o|r/                               # Select all o s and r s
         >>.&(                     )    # Map each letter to
                            *x.comb     # The letter padded to the width
               S/rr/ /                  # Substitute a leading rr with a space
                      .say              # And print with a newline

I didn't realize o could be used in place of ∘. Very nicely golfed.

Brainfuck, 276 268 206 bytes
Technically as the brainfuck only has 8 instructions, that means it needs only 3 bits per character instead of 8 (that also means we could encode brainfuck in base64 with exactly 2 instructions per character), but I'll play fair and say it's 268 bytes long.
It was a fun challenge, thanks!
Edit: now featuring the 3rd rule!
Edit: moving the line feed from the data pool to the display part of the code allowed me to get down to 268 bytes:
>>+<,[<++++++++++[>-----------<-]>-[>-<,>>+<<[-]>>>>[>]>++++[<++++++++>-]+>>++++++++++[<+++++++++++>-]<+>>++++[<++++++++>-]<[<]<<<]>[[-]>>>[>]>+++++++[<+++++>-]+>>+++++++[<+++++>-]>+++++++[<+++++>-]<[<]<<]+<,>>+<<]>>--[>>>+<<<-]>>[.>-[>>>>+<<<<->.<]>>.[-]++++++++++.>]

Here's a more readable version:
The data pool is made like so: [first character, placeholder value used to move the input character count, repeated character, last character]
>>+<,[//start of the loop
<++++++++++[>-----------<-]>-//"o"
[>-<,>>+<<[-]//if it's not a "o", skip one character and:

>>>>[>]//go to the data pool and search for the end
>++++[<++++++++>-]//put " " in memory
+>//put 1 in memory
>++++++++++[<+++++++++++>-]<+>//put a "o" in memory
>++++[<++++++++>-]<//put another " " in memory
[<]<<<//get back to the beginning of the data pool and get back to the program

]>[[-]//else (so if it's a "o"):

>>>[>]//go to the data pool and search for the end
>+++++++[<+++++>-]//put a "#" in memory
+>//put 1 in memory
>+++++++[<+++++>-]//put a "#" in memory
>+++++++[<+++++>-]<//put a "#" in memory
[<]<<//get back to the beginning of the data pool and get back to the program

]+<,>>+<<]//loop until the end of the input line and count the number of characters

>>//go to the number of characters variable
--//substract 2 to it because the first and last characters take one space each
[>>>+<<<-]//copy the value to the next place
>>[.>//start of the loop and display of the first character
-[>>>>+<<<<->.<]//display of the repeated character while copying the character count to the next line
>>.//display of the last character
[-]++++++++++.//display a line feed
>]//loop until the end of the data pool

It works on copy.sh/brainfuck with default settings
(link)
Edit: now down to only 206 Bytes thanks to @RezNesX
>>+<,[<-[>++<-------]>-[,[-]>->+>>[>]>+>+>-[<-->-------]>++++[<<<<++++++++>>>++++++++>-]<[<]<<<]>[[-]>>>[>]->+>->->--[<<<<-->>-->-->+++++++]<[<]<<]+>+<<,]>>--[>>>+<<<-]>>[.>-[>>>>+<<<.<-]>>.[-]++++++++++.>]

The code is quite similar but a lot of optimisation has been done in the creation of the data pool, very interesting.

Fun language, nice entry! :)

Oops, it looks like it breaks the third rule! The output isn't as wide as the input :s

ah sorry, I didn't read that one, thanks I'm gonna work on that

alright the only case where the result is not the expected one is "o"
"re" outputs 2 spaces and "" outputs nothing
but "o" is not doable with the method I chose because the repeated character should be negative here

206 bytes

@RezNesX Awesome job! I'm adding this to the post

Zsh, 67 bytes
a=$#1
o()<<<${(l/a//=/)}
r()<<<\ ${(l/a>1?a-2:0//+/)}
eval ${1///;}

Try it online!
Explanation:

$1: input
#: length
a=: assign to global variable $a
o(): define a function called o:

${(l/a//=/)}: left pad {nothing} with = signs to the width $a (i.e., print this many equals signs)
<<<: print

r(): define a function called r:

${(l///+/)} left pad {nothing} with + signs,
a>1?a-2:0: to the width of $a - 2 if $a > 1 else 0 (because otherwise, if $a - 2 was negative, zsh would use its absolute value)
<<<\ : print with a space before

${1}: input
///;: replace all {empty string}s with ; (effectively intersperses; oreo -> ;o;r;e;o)
eval: evaluate that as zsh code

o and r call the functions defined above
e is a non-existent command, so does nothing
; separates the commands

cunning use of functions!

Charcoal, 19 bytes
Ｆθ≡ιo⟦⭆θ#⟧e«→Ｐ⁻Ｌθ²↙

Try it online! Link is to verbose version of code. Explanation:
Ｆθ

Loop through the characters of the input string.
≡ι

Switch on each character.
o⟦⭆θ#⟧

If it's an o then print the input string replaced with #s on its own line.
e«→Ｐ⁻Ｌθ²↙

If it's an e then move right, print a line of -s that's two less than the length of the input string, then move down and left.

C# (Visual C# Interactive Compiler), 71 bytes
s=>s.Aggregate("",(a,c)=>a+(c>111?" ":"\n".PadLeft(s.Length+c/5-21,c)))

Try it online!
Borrowed some ideas from on Embodiment of Ignorance's answer for sure.
-6 bytes thanks to @ASCIIOnly!
The overall concept is to compute a string aggregate over the input characters following these rules:

If an r is encountered, append a single space  character for indentation. We know the next character will be an e.
If an o or an e is encountered, generate a string by repeating the current character a specific number of times and prepending it to a newline or some padding and a newline.
The number of times to repeat is determined by length of input string and whether the current line is indented.
The PadLeft function is used to generate the repeating character string.

The result is the concatenation of all of these strings.

71

@ASCIIOnly - Thanks :)

The whitespace padding on each side of the filling is required

85?

I didn't notice that :) Although, in reviewing the posted answers about 1/2 have done this incorrectly as well. Good catch though!

Dart, 120 106 107 bytes
f(s)=>s.replaceAll('o',''.padRight(s.length,'#')+'\n').replaceAll('re',' '.padRight(s.length-1,'-')+' \n');

Try it online!

+1 byte : Added trailing whitespace

This is invalid: "The whitespace padding on each side of the filling is required"

Oh, never mind then, I'll correct it soon. Thanks for the info, I missed it

Python 2, 77 76 72 bytes
lambda i:'\n'.join((x*len(i),' '+x*(len(i)-2))[x>'o']for x in i if'e'<x)

Try it online!
The outer part of the cookie is 'o' and the filling is 'r'.

68 bytes. Although I doubt if you can really omit the trailing spaces, the spec does say "The whitespace padding on each side of the filling is required"...

Thanks @EriktheOutgolfer. Thought a lambda would be shorter! Guess in this case not. Had missed the requirement about the mandatory trailing space on the filling. Really can't see the point with an ascii art challenge but if that's what OP requires then I guess my answer is invalid anyway.

Now corrected...

Why bring it back to 76? Just put +' ' after (l-2). Also, you have a typo, *' ' must be +' '.

That's what I did with my current solution. Will take a closer look at your hints tomorrow (later today). It's late here and I have been shoveling snow all day so too tired for golf. Thanks for the tips though :)

It's not a strange reason, if anything it's expected, since most of the like... three existing ASCII-art languages, as well as the matrix based languages output a trailing space anyway. Plus, for some languages the symmetry may even help

I guess that's why in the majority of challenges, trailing whitespace is optional.

Well, it's optional now (yay)

C# (.NET Core), 143 bytes
Without LINQ.
p=>{var q="";foreach(char c in p){if(c!='e'){for(var j=0;j<p.Length;j++)q+=(j<1|j>p.Length-2)&c>'q'?" ":c<'p'?"█":"░";q+="\n";}}return q;};

Try it online!

Sed, 89 characters
(86 characters code + 3 characters command line option)
h;s/./E/g;H;g;s/\n//;:b;s/(o|re)([ore]+)(E*)/\1\3\n\2\3/;tb;s/o//g;s/reE(E*)E/ \L\1 /g

Commented with example for input “oreo”:
h        # copy to hold space
s/./E/g  # change into cookie: EEEE
H        # append to hold space
g        # copy back to pattern space: oreo␤EEEE
s/\n//   # remove the newline: oreoEEEE

:b                                 # split the os and res in separate lines
  s/(o|re)([ore]+)(E*)/\1\3\n\2\3/ # repeating the EEEE for each:
tb                                 # oEEEE␤reEEEE␤oEEEE

s/o//g                # remove the os: EEEE␤reEEEE␤EEEE
s/reE(E*)E/ \L\1 /g   # remove the res, cut edge, change fill: EEEE␤ ee ␤EEEE

Sample run:
bash-4.4$ sed -r 'h;s/./E/g;H;g;s/\n//;:b;s/(o|re)([ore]+)(E*)/\1\3\n\2\3/;tb;s/o//g;s/reE(E*)E/ \L\1 /g' <<< oreoorererereoo
EEEEEEEEEEEEEEE
 eeeeeeeeeeeee
EEEEEEEEEEEEEEE
EEEEEEEEEEEEEEE
 eeeeeeeeeeeee
 eeeeeeeeeeeee
 eeeeeeeeeeeee
 eeeeeeeeeeeee
EEEEEEEEEEEEEEE
EEEEEEEEEEEEEEE

Try it online!

I didn't expect an entry like that, creative!

Same byte count but with newlines - Try it online!

@Logern, thanks for playing with it. This brought to my attention that the TIO code was still the first version, which didn't handled input “re” correctly.

C (gcc), -D$=putchar(33 +  88 = 102 bytes
O(char*r){for(char*e,*o=r,x;*r;$-x),$-23))for(x=*r++>111,e=x?$-1),r++,o+1:o;*++e;$+x));}

Try it online!

APL (Dyalog Extended), 22 bytesSBCS
Anonymous tacit prefix function. Cookies are o, cream is r.
'^rr'⎕R' '⍤1≢⊢⍤/⍪~'e'⍨

Try it online!
…⍨ swap the input for:
 'e' this letter
…~ remove all the "e"s from:
 ⍪ the columnised argument
…⊢⍤/ replicate that single column to be as many columns as:
 ≢ the tally of characters in the input
…⍤1 on each row (lit. on each 1D sub-array):
 '^rr'⎕R' ' PCRE Replace leading "rr" with a single space

Clojure, 137 bytes
(fn[f](let[w(count f)r #(apply str(repeat % %2))](clojure.string/join"\n"(replace{\o(r w \#)\e(str \ (r(- w 2)\-) \ )}(remove #{\r}f)))))

I'm not using the nice characters in the printout in the golfed version since those are expensive. Returns a string to be printed.
Try it online!
See below for explanation.
Pre-golfed:
; Backslashes indicate a character literal
(defn oreo [format-str]
  (let [width (count format-str)

        ; A helper function since Clojure doesn't have built-in string multiplication
        str-repeat #(apply str (repeat % %2))

        ; Define the layers
        cookie (str-repeat width \█)
        cream (str \ (str-repeat (- width 2) \░) \ )]

    (->> format-str ; Take the input string,
         (remove #{\r}) ; remove r for simplcity,
         (replace {\o cookie, \e cream}) ; replace the remaining letters with the layers,
         (clojure.string/join "\n")))) ; and join the layers together with newlines

Stax, 13 bytes
äNëY┬2-]‼Cv6╤

Run and debug it
Uses "o" and "r" characters for the layers.

Oh man, you tied the current lowest! Really cool language too, I appreciate stack-based languages.

Excel, 93 bytes
=SUBSTITUTE(SUBSTITUTE(A4,"o",REPT("O",LEN(A4))&"
"),"re"," "&REPT("r",MAX(0,LEN(A4)-2))&"
")

MAX(0, is needed to handle o.
Uses O and r.

Very cool, though since it is an ascii challenge you should output the text in a stack (probably with CHAR(10) in excel), and you can replace the block characters with letters to cut down a few bytes :)

@GammaGames, \n is included in code and bytecount.  You need to switch on "Wrap text" to see them though.

Ah, gotcha. Thank you for your answer!

Nibbles 10 bytes
&" ",@~.|@%$~
^-,_%$3 # $

explanation
&           # Justify
  " "       # (value to pad in justify)
  ,         # length (size to justify to)
    @       # first input string
  ~         # centered
  .         # map
    |       # filter
      @     # first input string
      %$~   # mod char element 2
    ^       # replicate (begin map body)
     -      # minus
      ,_    # length of first input string
        %$3 # mod char element 3
            # implicit $ (the char element to be replicated)

Coming in lower than jelly! How do I run this?

echo oreoorererereoo | nibbles filename. It isn't on TIO.run yet, but I've contacted them.

Tcl, 216 bytes
set s [gets stdin]
set l [string map {o { o } re { re }} $s]
set n [string length $s]
foreach i $l {
if {$i eq "o"} {
puts [string repeat █ $n]
} elseif {$i eq "re"} {
puts " [string repeat ░ [expr {$n-2}]] "
}
}

Try it online!

Assume valid input and handle “o” and “r” and ignore “e”. For this split $s "" is shorter than string map. You only need $l once, so better skip the assignment to variable and use the expression directly in foreach. If you reverse the conditions, you can remove the spaces: $i eq "o" → "o"eq$i. Use if instead of elseif. no need the braces around expr's argument. Try it online!

SNOBOL4 (CSNOBOL4), 136 bytes
	S =INPUT
	N =SIZE(S)
S	S ('o' | 're') . X REM . S	:F(END)
	OUTPUT =IDENT('o',X) DUPL(X,N)	:S(S)
	OUTPUT =' ' DUPL(0,N - 2) ' '	:(S)
END

Try it online!

Batch, 133 bytes
@set/ps=
@set o=%s:r=o%
@set o=%o:e=o%
@set r=%o:o=-%
@set r= %r:~2%
@set s=%s:e= %
@for %%c in (%s:o=o %)do @call echo %%%%c%%

Takes input on STDIN. Explanation:
@set/ps=

Input the string.
@set o=%s:r=o%
@set o=%o:e=o%

Make a copy of the string with all of the rs and es replaced with os.
@set r=%o:o=-%
@set r= %r:~2%

Make a copy of the string of os, change them to -s and replace the first two with a space.
@set s=%s:e= %
@for %%c in (%s:o=o %)do @call echo %%%%c%%

Change the es into spaces and also add a space after each o, allowing the os and rs to be iterated over, printing the appropriate string each time.

CJam, 27 bytes
q:T'e-{i2%T,'9*_:)2>S\+?N}/

Try it online!
Explanation:
q                            read input:                    | "oreoo"
 :T                          store in variable T            | "oreoo", T="oreoo"
   'e-                       remove all 'e' characters:     | "oroo"
      {                  }/  for each character:            | 'o
       i                       get Unicode value:           | 79
        2%                     modulo 2:                    | 1
          T                    push original input:         | 1 "oreoo"
           ,                   get length:                  | 1 5
            '9*                repeat '9' that many times:  | 1 "99999"
               _               duplicate:                   | 1 "99999" "99999"
                :)             increment every character:   | 1 "99999" ":::::"
                  2>           remove first two characters: | 1 "99999" ":::"
                    S\+        prepend a space:             | 1 "99999" " :::"
                       ?       conditional:                 | "99999"
                        N      add a newline:               | "99999" N
                             (implicit output)              | "99999" N " :::" N "99999" N "99999" N

This breaks the rules: "The whitespace padding on each side of the filling is required"

Sorry, I allowed the optional trailing whitespaces. Nice entry!

Lua, 112 bytes
s=io.read()for t in s:gmatch"."do io.write(t=="o"and t:rep(#s).."\n"or(t=="r"and" "..t:rep(#s-2).." \n"or""))end

Explanation
s = io.read() -- Reads the input
for t in s:gmatch(".") do -- For each character in the input, call it 't' and enter the loop
 io.write(t=="o" and t:rep(#s).."\n" or (t=="r" and " "..t:rep(#s-2).." \n" or ""))

          t=="o" and  -- if 't' is equal to "o" then
                     t:rep(#s).."\n"  -- you have to write 't' repeated N times, where N is
                                      -- is the size of the input s, appended by a new line
                                     or (t=="r" and  -- else, if 't' is equal to "r" then
                                                    " "..t:rep(#s-2).." \n"  -- write a space, followed by 't' repeated N-2 times,
                                                                             -- where N is the size of the input.
                                                                             -- followed by a space and a new line.
                                                                            or "" -- else, just don't write anything.

end

Try it online!

JavaScript, 70 bytes
x=>x.replace(/()()o|re/g,(_,o=1,s=' ')=>s.padEnd(x.length-o,+o)+s+`
`)

Try it online!
Or... If we're allowed to use other characters for whitespace, we can get it down to 65 bytes:
x=>x.replace(/()()o|re/g,(_,o=1,s=' ')=>s.padEnd(x.length-o,+o)+s+`
`)

Try it online!
...but I don't think that counts.

You're right, the padding has to be whitespace. Nice entry!

JavaScript (Node.js), 65 bytes
s=>s[R='replace'](/.e?/g,x=>s[R](/./g,x[0])[R](/^r|r$/g,' ')+`
`)

Try it online!
Thanks to Yair Rand, saves 2 bytes.

You can save a byte by moving the last replace a bit earlier and removing the m flag: s=>s[R='replace'](/re|o/g,x=>s[R](/./g,x[0])[R](/^r|r$/g,' ')+
)

And another byte by using /.e?/g instead of /re|o/g .

x86-64 machine code (Linux), 97 bytes
0000000000000000 <oreo_asm>:
   0:   56                      push   %rsi
   1:   57                      push   %rdi

0000000000000002 <len>:
   2:   48 ff c7                inc    %rdi
   5:   80 3f 00                cmpb   $0x0,(%rdi)
   8:   75 f8                   jne    2 <len>
   a:   49 89 fc                mov    %rdi,%r12
   d:   5f                      pop    %rdi
   e:   49 29 fc                sub    %rdi,%r12
  11:   4d 31 f6                xor    %r14,%r14
  14:   eb 18                   jmp    2e <outer_loop.skip>

0000000000000016 <extra>:
  16:   41 c6 01 20             movb   $0x20,(%r9)
  1a:   c6 03 20                movb   $0x20,(%rbx)
  1d:   49 ff ce                dec    %r14
  20:   eb 06                   jmp    28 <outer_loop>

0000000000000022 <newline>:
  22:   c6 06 0a                movb   $0xa,(%rsi)
  25:   48 ff c6                inc    %rsi

0000000000000028 <outer_loop>:
  28:   49 ff c6                inc    %r14
  2b:   48 ff c7                inc    %rdi

000000000000002e <outer_loop.skip>:
  2e:   44 8a 07                mov    (%rdi),%r8b
  31:   41 80 f8 65             cmp    $0x65,%r8b
  35:   74 df                   je     16 <extra>
  37:   45 84 c0                test   %r8b,%r8b
  3a:   74 23                   je     5f <done>
  3c:   48 89 f3                mov    %rsi,%rbx

000000000000003f <inner_loop>:
  3f:   44 88 06                mov    %r8b,(%rsi)
  42:   49 89 f1                mov    %rsi,%r9
  45:   48 ff c6                inc    %rsi
  48:   48 31 d2                xor    %rdx,%rdx
  4b:   48 89 f0                mov    %rsi,%rax
  4e:   48 2b 04 24             sub    (%rsp),%rax
  52:   4c 29 f0                sub    %r14,%rax
  55:   49 f7 f4                div    %r12
  58:   48 85 d2                test   %rdx,%rdx
  5b:   74 c5                   je     22 <newline>
  5d:   eb e0                   jmp    3f <inner_loop>

000000000000005f <done>:
  5f:   5e                      pop    %rsi
  60:   c3                      retq

This x86-64 function takes in the pointer to the input string in rsi and builds the output starting at the pointer in rdi (these are the registers used to pass the first two arguments from a C function on Linux). For convenience, I've written a C++ wrapper for this which also does nice input sanitization and prints the output. That code can be located here. This also shows the original nasm syntax assembly I wrote for this function (as well as the non-golfed version I got working first).
A few things to note is that this code doesn't respect any callee saved registers, which means that the C++ code likely will crash if run for a while after calling this function. On my machine it doesn't, but that's rather surprising. I also don't add a null byte to delimit the output string, and instead the space allocated for the output string is pre-filled with bytes. (If this isn't allowed I can add the null terminator at a cost of 3 bytes).
The logic for this code is essentially counting the length of the string, then building a line of this length for each 'o' and 'r' characters seen in the input string, and then for any 'e' character seen, replacing the first and last characters on the previous line with space characters.
I can't find anywhere online to compile and run a mix of C++ and nasm source code, so I might write some small wrapper code for this to prove it works. Otherwise you should be able to compile and run this with the makefile in the link I gave with the command:
$ make oreo ASM_FILE=oreo_golf.nasm
$ ./oreo oreoorererereoo --use_asm

I was able to format the assembly to something acceptable by gcc, so try it online!

Oh my, now this is an entry!

Python 2, 70 75 bytes
lambda s:"\n".join((c*(len(s)-2*(c<'f'))).center(len(s))for c in s if'r'>c)

Try it online!
Uses 'o' for cookie, 'e' for filling. Returns a string.
EDIT:
Saved 4 bytes thanks to Jo King.
Explanation:
# anonymous function, returns a string seperated by line breaks
lambda s:"\n".join(.......................................................)
                                                        # iterate through string, return each non-'r' character
                                                        for c in s if'r'>c
                    # duplicate the character until it is the length of the original string,
                    # minus two characters if the current letter is 'e'
                    c*(len(s)-2*(c<'f'))
                   # pad the string with spaces out to the length of the original string
                   (....................).center(len(s))

Sorry, the output should be a single string with line-breaks that can be printed or the program should print the output as it is processed. Arrays of strings aren't allowed, because of the "ascii" part.

@GammaGames Bluh, I should really read the rules more closely. Thank you!

66 bytes

Python 2, 64 bytes
s=input()
for c in s:
	if'n'<c:j='o'<c;print' '*j+c*(len(s)-2*j)

A full program which prints the result.
Try it online! Or see the test-suite.

Vyxal j, 23 bytes
L£\eoƛ\o=[×¥*|ð¥⇩\!*ð++

Try it Online!
L£                      # Store length to register
  \eo                   # Remove es
     ƛ                  # Map...
      \o=[              # If o then
          ×¥*           # (Register) asterisks
             |          # Else...
               ¥⇩\!*    # (Register-2 !s)
              ð     ð++ # Padded with spaces

Perl 5 + -plF, 27 bytes
s!.!$&x@F.$/!ge;s/r+
ee/ /g
Try it online!
Explanation
s///ubstitutes every character (.) with itself repeated the length of the string x@F, followed by a newline ($/). Then replaces any runs of r+\nee with a single space.

Vyxal j, 14 bytes
\eoƛAd⇩?L+*?L⋏

Try it Online!

Coming in lower than the other Vyxal answer, nice work!

APOL, 79 bytes
This could almost certaintly be made shorter.
v(0 i);j(ƒ(R(⁰ "re" "*") ¿(=(∋ "*") +(" " *("r" -(l(⁰) 2))) *("o" l(⁰)))) "\n")
Explanation
v(0 i);  Put user's input at memory index 0
j(  List join
  ƒ(  Listbuilder for
    R(  String replace (being iterated through)
      ⁰  Value at index 0
      "re"  Replace "re"
      "*"  with "*"
    )
    ¿(  Returning if (called for each character in replaced string)
      =(  Equals (condition)
        ∋  Current character
        "*"  The string "*"
      )
      +(  Add (true instruction, used here to join strings)
        " "  The string " " (the padding for the filling)
        *(  Multiply (used here to repeat a string)
          "r"  The string "r" (our filling) by
          -(  Subtract
            l(⁰)  The length of the input
            2  from two (one for each character of padding)
          )
        )
      )
      *(  Multiply (the false condition)
        "o"  The string "o"  (our cookie)
        l(⁰)  by the length of the input
      )
    )
  )
  "\n"  Join each string with a newline
)


text:
Clock (transliterate) Cipher
Introduction:
I have loads of different ciphers stored in a document I once compiled as a kid, I picked a few of the ones I thought were best suitable for challenges (not too trivial, and not too hard) and transformed them into challenges. Most of them are still in the sandbox, and I'm not sure yet whether I'll post all of them, or only a few. Here is the third and easiest one (after the Computer Cipher and Trifid Cipher I posted earlier).

With a Clock Cipher we use the following image to encipher text:

So a sentence like this is a clock cipher would become:
t  h i s     i s     a     c l  o  c k     c i p  h e r    (without additional spaces of course, but added as clarification)
19:7:8:18:00:8:18:00:AM:00:2:11:14:2:10:00:2:8:15:7:4:17

Challenge:
Given a string sentence_to_encipher, encipher it as described above.
Challenge rules:

You can assume the sentence_to_encipher will only contain letters and spaces.
You can use either full lowercase or full uppercase (please state which one you've used in your answer).
You are not allowed to add leading zeros for the single-digit enciphered letters b through j, but two zeros 00 are mandatory for spaces.
You should use : as separator, and an additional leading or trailing : is not allowed.
You are allowed to use lowercase am and pm instead of uppercase AM and PM, as long as it's consistent.

General rules:

This is code-golf, so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
Standard rules apply for your answer with default I/O rules, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
Default Loopholes are forbidden.
If possible, please add a link with a test for your code (i.e. TIO).
Also, adding an explanation for your answer is highly recommended.

Test cases:
Input:  "this is a clock cipher"
Output: "19:7:8:18:00:8:18:00:AM:00:2:11:14:2:10:00:2:8:15:7:4:17"

Input:  "test"
Output: "19:4:18:19"

Input:  "what time is it"
Output: "22:7:AM:19:00:19:8:12:4:00:8:18:00:8:19"

Input:  "acegikmoqsuwy bdfhjlnprtvxz"
Output: "AM:2:4:6:8:10:12:14:16:18:20:22:24:00:1:3:5:7:9:11:13:15:17:19:21:23:PM"

Input:  "easy peazy"
Output: "4:AM:18:24:00:15:4:AM:PM:24"

Related

Is it allowed to output [7, ":", 8, ":", "00", ":", 1, ":", 14, ":", 1] for hi bob, or must one join the result? By the way, neat cipher!

@Mr.Xcoder Sorry, for the sake of the cipher theme I'd say it should be joined to a single string (or the entire thing as a list of characters like ['7', ':', '8', ':', '0', '0', ':', '1', ':', '1', '4', ':', '1']).

@KevinCruijssen there might be a built-in to concatenate lists.

Python 2, 74 72 bytes
lambda s:':'.join(['AM','PM','00',`ord(c)-97`]['az '.find(c)]for c in s)

Try it online!
Takes input as all lowercase

05AB1E, 22 21 bytes
„AM24L„PM00)˜Að«s‡':ý

Try it online!
or as a Test Suite
Some alternate 21 byte solutions:
':ýAð«24L„AMš„PMª00ª‡
00„AM24L„PM)˜AIk>è':ý

Nice answer, I managed to get 23 bytes through multiple approaches (one of which was my currently deleted answer). That's a neat way to arrange your stack to save a byte!

An alternate 22 byter combining our answers: Try it Online!

@Mr.Xcoder: My first idea actually looked like that, but 2 bytes worse because I didn't remember that ª had changed :)

I've found a 20 byter using a portion of @Mr.Xcoder's approach, but I'll let you figure it out yourself before I reveil it. :)

@KevinCruijssen: Well, I've got 5 different versions at 22 now. I feel like I'm probably gonna have a doh! moment when I find/you reveal the 20.

Do you want me to post it, or try some more yourself first?

@KevinCruijssen: I'll let you know after I've looked some more ;)

@KevinCruijssen: I'm stuck! Save me!

I'll give you a tip to perhaps help you narrow down the approaches: It would be 21 bytes with a leading S if I take the input as a string (but 20 bytes if I already take the input as a list of characters and omit the leading S). In the mean time I will start writing the explanation in my answer. :)

@KevinCruijssen: Oh, I didn't consider that it was allowed to take a list of chars. 21 is easy then at least. I'll look for the 20 again now :)

@Emigna Ah, I only see your comment now. My answer is posted, but try to not peek if you still want to figure it out yourself. ;p

Perl 6, 47 bytes
*.ords>>.&{<<00 AM{1..24}PM>>[$_%32]}.join(":")

Try it online!
Anonymous Whatever lambda that takes a string of either case and returns the encrypted string.
Explanation:
*.ords>>.&{                         } # Map the ordinal values to
           <<              >>[$_%32]  # The index in the list
              00 AM{1..24}PM  # 00, AM, the numbers 1 to 24 and PM
                                     .join(":")   # And join with colons

Java (JDK), 86 bytes
s->"".join(":",s.map(c->c<33?"00":c<66?"AM":c>89?"PM":c-65+"").toArray(String[]::new))

Try it online!
Credits

-1 byte thanks to Kevin Cruijssen

One easy golf: char to var. :)

Thanks! So obvious now that you show it to me...

C# (Visual C# Interactive Compiler), 70 bytes
s=>string.Join(":",s.Select(a=>a<33?"00":a<66?"AM":a>89?"PM":a%65+""))

Takes input as a string of lowercase letters. First checks if the char is a space, and if it is, converts it to 00. Next, it checks for if the char is an A, and converts it to AM. It checks again for Z and converts it to PM if it is. Lastly, if the char passes all the checks, it gets converted to its alphabetic order-1.
-2 bytes thanks to @dana
Try it online!
// Input taking a string
s =>
// Join the following IEnumerable<char> with a ":" character
string.Join(":",
// Map all the characters in the string
s.Select(a =>
// Is the char less than 33, aka a space?
a < 33 ?
// If so, it's a "00"
"00"
// Else, is this an 'A'?
: a < 66 ?
// If so, convert it to "AM"
"AM" :
// If it's not 'A' or a space, could it be a 'Z'?
a > 89 ?
// If it is, turn the character into "PM"
"PM" :
// If it fails all of the checks above, get the characters position in the alphabet and subtract one from that.
a % 65 + ""))

Pyth, 25 bytes
j\:m@+++"AM"S24"PM""00"xG

Try it online here, or verify all the test cases at once here.
j\:m@+++"AM"S24"PM""00"xGdQ   Implicit: Q=eval(input()), G=lowercase alphabet
                              Trailing dQ inferred
            S24               [1-24]
       +"AM"                  Prepend "AM"
      +        "PM"           Append "PM"
     +             "00"       Append "00" - this is the dictionary
   m                      Q   Map each element of Q, as d, using:
                       xGd      Get the index of d in G, -1 if not present (i.e. space)
    @                           Get the element from the dictionary at the above index
j\:                           Join the result on ":", implicit print

JavaScript (Node.js),  72  65 bytes
Takes input in lowercase.
s=>[...Buffer(s)].map(c=>c<33?'00':c>121?'PM':c-97||'AM').join`:`

Try it online!

Red, 124 121 110 109 bytes
func[s][replace/all form collect[forall s[keep switch/default
c: -97 + s/1[0['AM]25['PM]-65["00"]][c]]]sp":"]

Try it online!

Ruby, 49 bytes
->a{a.map{|c|["00",:AM,*1..24,:PM][c.ord%32]}*?:}

Try it online!
Port of Jo King's Perl answer.
Takes input as an array of chars, returns a string with AM/PM in uppercase.

05AB1E, 20 bytes
':ýð00:A24L„AMš„PMª‡

Greatly inspired by @Mr.Xcoder's 22-byter in the comment of the existing 05AB1E answer by @Emigna.
Takes the input as a list of lowercase characters (would be 21 bytes with a leading S if I take the input as a string).
Try it online or verify all test cases.
Explanation:
':ý            '# Join the (implicit) input list of characters by ":"
                #  i.e. ["e","a","s","y"," ","p","e","a","z","y"] → "e:a:s:y: :p:e:a:z:y"
ð00:            # Replace all spaces " " with "00"
                #  i.e. "e:a:s:y: :p:e:a:z:y" → "e:a:s:y:00:p:e:a:z:y"
A               # Push the lowercase alphabet
 24L            # Push a list in the range [1,24]
    „AMš        # Prepend "AM" at the start of this list
        „PMª    # And append "PM" at the end of the list
            ‡   # Transliterate; mapping letters to the list-items at the same indices
                # (and output the result implicitly)
                #  i.e. "e:a:s:y:00:p:e:a:z:y" → "4:AM:18:24:00:15:4:AM:PM:24"

Ah yes. Replacing the space separately saves a byte. I should have tried that. Nice :)

Charcoal, 26 bytes
ＵＢ:Ｆθ«→≡ι ×0²a¦AM¦z¦PMＩ⌕βι

Try it online! Link is to verbose version of code. Takes input in lower case (can trivially be changed to upper case). Explanation:
ＵＢ:

Set the background character to :. This fills in the gaps between the output values created by the right movement.
Ｆθ«→

Loop over each character, leaving a gap each time. (The first move has no effect as the canvas is still empty at this point.)
≡ι ×0²a¦AM¦z¦PM

Switch on the character and if it's space, a or z then output the appropriate code. I use ×0² instead of 00 here as the latter would cost two bytes in additional separators.
Ｉ⌕βι

Otherwise output the letter's 0-indexed position in the lower case alphabet as a string.

PowerShell, 72 69 63 bytes
$(switch($args){a{'AM'}z{'PM'}' '{'00'}default{$_-97}})-join':'

Try it online!
Takes a lowercase string and does not add a leading 0.
The string is passed to the function using splatting.
It iterates through all the characters of the string, replacing them with their encoded values.
The resulting items are then joined using ':' as separator.
-6 bytes thanks to mazzy !

? Try it online!

Perl 5 -pl, 46 bytes
s/./("00",AM,1..24,PM)[ord($&)%32].":"/ge;chop

Case doesn't matter. To run as perl -ple '<code>'. -l option passed to perl allows to drop the last colon with chop.
Try it online!

Scala, 69 bytes
_.map(_.-(64)%32)map "00"+:"AM"+:1.to(24).map("".+):+"PM"mkString ":"

Try it in Scastie!

69 bytes. Very nice

Tcl, 100 bytes
proc C s {join [lmap c [split $s ""] {scan $c %c v
expr $v==65?"AM":$v==90?"PM":$v==32?00:$v-65}] :}

Try it online!

C# (Visual C# Interactive Compiler), 98 bytes
s=>string.Join(':',s.Select(c=>"az ".Contains(c)?new[]{"AM","PM","00"}["az ".IndexOf(c)]:c-97+""))

Takes input as a (lowercase) char array. Try it online!

82 bytes: s=>string.Join(':',s.Select(c=>new[]{c-97+"","AM","PM","00"}["az ".IndexOf(c)+1])).

Jelly, 24 bytes
«"⁾PMµØAḊiȯ⁾00µe?€⁾AZj”:

Try it online!

Vyxal, 31 22 bytes
øA‹u025"J`00ṙ§m`2ẇĿ\:j

Thanks to @lyxal!
I'm not familiar with Vyncode so just classic version.
Try it Online!
Explanation:

øA                      # Convert letter to number (space=0 and vectorized by default)
  ‹                     # Increment (vectorized)
   u025                 # Push -1, 0 and 25
       "                # Pair top two items (0 and 25)
        J               # Join -1  (so "J shorter than 3¨ẇ)
         `00ṙ§m`        # This uncompressed to `00ampm` (how?)
                2ẇ      # Split into 2-chunks
                  Ŀ     # Transliterate: replace each item of one value in another value with the corresponding element from a third value
                   \:j  # Join by ":"

Old version for compare:
C97-⟨65N|0|25⟩⟨‛00|‛AM|‛PM⟩Ŀ\:j

Try it Online!

Ask, and you shall recieve: Try it Online! for 18.75 bytes

@lyxal Maybe it's also a good idea to explain how you've compressed them, so lesobrod (or others reading this) know how to do so for future challenges. :)

@KevinCruijssen In general, I figured out myself and will soon write a clarification

@lyxal The only thing I don’t understand is how simple string 00ṙ§m uncompressed to 00ampm without « «

@lesobrod that's dictionary compression: https://codegolf.stackexchange.com/a/225288/78850

18.5 bytes

Wolfram Language (Mathematica), 98 95 bytes
StringRiffle[Switch[#,1,"AM",26,"PM",0,"00",_,ToString@(#-1)]&/@LetterNumber@Characters@#,":"]&

Try it online!

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Execute Triangularity Move
TL;DR for those not interested: Look at the test cases at the bottom. Have a program/function that outputs the 2D list displayed for the given input.
Introduction:
On November 15th, 2018 puzzle designer Raphaël Mouflin revealed his Triangularity puzzle. Here is a picture of that puzzle:

As you can see, the shape is a 3-sided (4-faced) pyramid (a.k.a. tetrahedron), and it has six pieces per face.
So, what makes this puzzle so unique? It's the first puzzle in the shape of a regular platonic solid that is a hybrid of all three twisty puzzle rotational axis systems: face-turning, corner-turning, AND edge-turning. Most puzzles only have a single rotational axis system, like face-turning for the regular 3x3x3 Rubik's Cube; corner-turning for the Pyraminx; edge-turning for the Helicopter Cube; etc. Lately more hybrid puzzles are getting released of which most have two rotational axis systems combined in the same puzzle (usually face- and corner-turning, since that seems to be the easiest hybrid combination to accomplish).
There are some other puzzles with all three rotational axis, like the Truncated Icosidodecahedron or Superstar puzzles, but those use a pretty complex shape in order to accomplish that. Triangularity however is a simple 3-sided pyramid that still has all three rotational axis systems.
Here a video to show those moves.
Challenge:
Input:
The move we are doing, which is one of the following:

E# for an edge-turn, where # is a digit in the range [1,6] (or [0,5]) for the six edges, numbered here. So the blue-red edge is 1; blue-yellow is 2; yellow-red is 3; blue-green is 4; yellow-green is 5; and red-green is 6.
F#D for the face-turn, where # is a digit in the range [1,4] (or [0,3]) for the four faces, numbered here. So the blue face is 1; yellow face is 2; red face is 3; green face is 4. And D is the direction, either C (clockwise) or A (anti/counter clockwise).
C#D for the corner, where # is a digit in the range [1,4] (or [0,3]) for the four corners, numbered here. So the blue-yellow-red corner is 1; blue-green-red corner is 2; blue-yellow-red corner is 3; yellow-red-green corner is 4. And D is the direction, either C (clockwise) or A (anti/counter clockwise).

Optional second input: The initial solved state 2D-array below.
Output:
The output will be the modified 2D-array after we've executed the single given move, where the initial solved configuration pictured above would be:
[[1,2,3,4,5,6],[7,8,9,10,11,12],[13,14,15,16,17,18],[19,20,21,22,23,24]]

Where these numbers indicate the pieces per face, so (using 'outer color - inner color' to indicate the pieces): 1 and 2 are the blue-red pieces; 3 and 4 the blue-yellow pieces; 5 and 6 the blue-green; 7 and 8 the yellow-blue; 9 and 10 the yellow-red; 11 and 12 the yellow-green; 13 and 14 the red-blue; 15 and 16 the red-yellow; 17 and 18 the red-green; 19 and 20 the green-blue; 21 and 22 the green-yellow; and 23 and 24 the green-red. (Looking at the faces in a clockwise direction, the first number is the first you encounter when going clockwise, and the second number the one next to it.)
Challenge rules:

The moves will be done in increments that doesn't change the tetrahedron shape. So even though the puzzle allows 60 degree increments for face-turns, and 90 degree increments for edge-turns, we will only do 180 degree edge turns and 120 degree face- and corner-turns so the puzzle won't shapeshift and will retain its tetrahedron shape.
Since the challenge is mainly about executing the move, and not about compressing the initial state, you can (optionally) take the initial state as additional input.
You are allowed to use either 1-indexed or 0-indexed numbers for the edges, faces, and corners. They do have to be consistent though, so you are not allowed to use [1,6] for the edges, and [0,3] for the corners. It should be either all 1-indexed or all 0-indexed. Please state what you've used in your answer.
I/O is flexible. Input move can be a String, character-array, etc. (You are not allowed to take the input as a list of codepoints, unless you language does this implicitly.) Output can be a 2D array/list, can modify the optional input 2D array/list, can be a string, etc.
You may optionally take the edge turns with a trailing C/A as well if it would save bytes, but the output would be the same in both cases, since the turns are in 180 degrees. (Please state so in your answer if you do take them with a trailing C/A which is ignored.)

General rules:

This is code-golf, so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
Standard rules apply for your answer with default I/O rules, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
Default Loopholes are forbidden.
If possible, please add a link with a test for your code (i.e. TIO).
Also, adding an explanation for your answer is highly recommended.

Test cases / All possible I/O (1-indexed):
Input move    Output                                                                      (cycled pieces)

F1C           [[5,6,1,2,3,4],[7,8,9,10,11,12],[13,14,15,16,17,18],[19,20,21,22,23,24]]    (1→3→5→1 and 2→4→6→2 as 3-cycles)
F1A           [[3,4,5,6,1,2],[7,8,9,10,11,12],[13,14,15,16,17,18],[19,20,21,22,23,24]]    (1→5→3→1 and 2→6→4→2 as 3-cycles)
F2C           [[1,2,3,4,5,6],[11,12,7,8,9,10],[13,14,15,16,17,18],[19,20,21,22,23,24]]    (7→9→11→7 and 8→10→12→8 as 3-cycles)
F2A           [[1,2,3,4,5,6],[9,10,11,12,7,8],[13,14,15,16,17,18],[19,20,21,22,23,24]]    (7→11→9→7 and 8→12→10→8 as 3-cycles)
F3C           [[1,2,3,4,5,6],[7,8,9,10,11,12],[17,18,13,14,15,16],[19,20,21,22,23,24]]    (13→15→17→13 and 14→16→18→14 as 3-cycles)
F3A           [[1,2,3,4,5,6],[7,8,9,10,11,12],[15,16,17,18,13,14],[19,20,21,22,23,24]]    (13→17→15→13 and 14→18→16→14 as 3-cycles)
F4C           [[1,2,3,4,5,6],[7,8,9,10,11,12],[13,14,15,16,17,18],[23,24,19,20,21,22]]    (19→21→23→19 and 20→22→24→20 as 3-cycles)
F4A           [[1,2,3,4,5,6],[7,8,9,10,11,12],[13,14,15,16,17,18],[21,22,23,24,19,20]]    (19→23→21→19 and 20→24→22→20 as 3-cycles)
C1C           [[1,8,9,4,5,6],[7,16,13,10,11,12],[3,14,15,2,17,18],[19,20,21,22,23,24]]    (2→16→8→2 and 3→13→9→3 as 3-cycles)
C1A           [[1,16,13,4,5,6],[7,2,3,10,11,12],[9,14,15,8,17,18],[19,20,21,22,23,24]]    (2→8→16→2 and 3→9→13→3 as 3-cycles)
C2C           [[17,2,3,4,5,14],[7,8,9,10,11,12],[13,24,15,16,19,18],[1,20,21,22,23,6]]    (1→19→17→1 and 6→24→14→6 as 3-cycles)
C2A           [[19,2,3,4,5,24],[7,8,9,10,11,12],[13,6,15,16,1,18],[17,20,21,22,23,14]]    (1→17→19→1 and 6→14→24→6 as 3-cycles)
C3C           [[1,2,3,20,21,6],[5,8,9,10,11,4],[13,14,15,16,17,18],[19,12,7,22,23,24]]    (4→12→20→4 and 5→7→21→5 as 3-cycles)
C3A           [[1,2,3,12,7,6],[21,8,9,10,11,20],[13,14,15,16,17,18],[19,4,5,22,23,24]]    (4→20→12→4 and 5→21→7→5 as 3-cycles)
C4C           [[1,2,3,4,5,6],[7,8,9,22,23,12],[13,14,11,16,17,10],[19,20,21,18,15,24]]    (10→18→22→10 and 11→15→23→11 as 3-cycles)
C4A           [[1,2,3,4,5,6],[7,8,9,18,15,12],[13,14,23,16,17,22],[19,20,21,10,11,24]]    (10→22→18→10 and 11→23→15→11 as 3-cycles)
E1            [[13,14,3,4,5,6],[7,8,9,10,11,12],[1,2,15,16,17,18],[19,20,21,22,23,24]]    (1↔13 and 2↔14 as swaps)
E2            [[1,2,7,8,5,6],[3,4,9,10,11,12],[13,14,15,16,17,18],[19,20,21,22,23,24]]    (3↔7 and 4↔8 as swaps)
E3            [[1,2,3,4,5,6],[7,8,15,16,11,12],[13,14,9,10,17,18],[19,20,21,22,23,24]]    (9↔15 and 10↔16 as swaps)
E4            [[1,2,3,4,19,20],[7,8,9,10,11,12],[13,14,15,16,17,18],[5,6,21,22,23,24]]    (5↔19 and 6↔20 as swaps)
E5            [[1,2,3,4,5,6],[7,8,9,10,21,22],[13,14,15,16,17,18],[19,20,11,12,23,24]]    (11↔21 and 12↔22 as swaps)
E6            [[1,2,3,4,5,6],[7,8,9,10,11,12],[13,14,15,16,23,24],[19,20,21,22,17,18]]    (17↔23 and 18↔24 as swaps)

Can we return by modifying the input state?

@TFeld Yes. It's also stated in the rules (although only very briefly): "I/O is flexible. Input move can be a string, character-array, etc. (You are not allowed to take the input as a list of codepoints, unless you language does this implicitly.) Output can be a 2D array/list, can modify the optional input 2D array/list, can be a string, etc."

Python 2, 384 362 359 344 337 313 bytes
def f((a,b,c),I):
 b=int(b)-1;q=b==1;Q=b==2;j=ord(c)%63;A=b|1+4*q;C=A-5*q;F=2-Q;G=b%2*(b^2);H=C+2-q;J=b%2+G
 if'E'<a:G=F=C=b;A,B,H,J=range(4)
 if'E'==a:j=3;G=b%3-q-Q;A=b+b%2-b/5*2;C=F=(b/3)|2-q;J=G*2;H=J-4
 q,w,e=I[G],I[F],I[C];X=q[A],q[A-5],w[H],w[J],e[J-5],e[J-4];q[A],q[A-5],w[H],w[J],e[J-5],e[J-4]=X[j:]+X[:j]

Try it online!
Takes input with a trailing C/A for every move.
Modifies the input list in-place

Explanation:
First we identify which faces are moved, depending on the move (faces that don't move are blank):
F1C [[ 1, 2, 3, 4, 5, 6], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ]]   ->   [[ 5, 6, 1, 2, 3, 4], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ]]
F1A [[ 1, 2, 3, 4, 5, 6], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ]]   ->   [[ 3, 4, 5, 6, 1, 2], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ]]
F2C [[  ,  ,  ,  ,  ,  ], [ 7, 8, 9,10,11,12], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ]]   ->   [[  ,  ,  ,  ,  ,  ], [11,12, 7, 8, 9,10], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ]]
F2A [[  ,  ,  ,  ,  ,  ], [ 7, 8, 9,10,11,12], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ]]   ->   [[  ,  ,  ,  ,  ,  ], [ 9,10,11,12, 7, 8], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ]]
F3C [[  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [13,14,15,16,17,18], [  ,  ,  ,  ,  ,  ]]   ->   [[  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [17,18,13,14,15,16], [  ,  ,  ,  ,  ,  ]]
F3A [[  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [13,14,15,16,17,18], [  ,  ,  ,  ,  ,  ]]   ->   [[  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [15,16,17,18,13,14], [  ,  ,  ,  ,  ,  ]]
F4C [[  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [19,20,21,22,23,24]]   ->   [[  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [23,24,19,20,21,22]]
F4A [[  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [19,20,21,22,23,24]]   ->   [[  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [21,22,23,24,19,20]]
                                                                                ->
C1C [[  , 2, 3,  ,  ,  ], [  , 8, 9,  ,  ,  ], [13,  ,  ,16,  ,  ], [  ,  ,  ,  ,  ,  ]]   ->   [[  , 8, 9,  ,  ,  ], [  ,16,13,  ,  ,  ], [ 3,  ,  , 2,  ,  ], [  ,  ,  ,  ,  ,  ]]
C1A [[  , 2, 3,  ,  ,  ], [  , 8, 9,  ,  ,  ], [13,  ,  ,16,  ,  ], [  ,  ,  ,  ,  ,  ]]   ->   [[  ,16,13,  ,  ,  ], [  , 2, 3,  ,  ,  ], [ 9,  ,  , 8,  ,  ], [  ,  ,  ,  ,  ,  ]]
C2C [[ 1,  ,  ,  ,  , 6], [  ,  ,  ,  ,  ,  ], [  ,14,  ,  ,17,  ], [19,  ,  ,  ,  ,24]]   ->   [[17,  ,  ,  ,  ,14], [  ,  ,  ,  ,  ,  ], [  ,24,  ,  ,19,  ], [ 1,  ,  ,  ,  , 6]]
C2A [[ 1,  ,  ,  ,  , 6], [  ,  ,  ,  ,  ,  ], [  ,14,  ,  ,17,  ], [19,  ,  ,  ,  ,24]]   ->   [[19,  ,  ,  ,  ,24], [  ,  ,  ,  ,  ,  ], [  , 6,  ,  , 1,  ], [17,  ,  ,  ,  ,14]]
C3C [[  ,  ,  , 4, 5,  ], [ 7,  ,  ,  ,  ,12], [  ,  ,  ,  ,  ,  ], [  ,20,21,  ,  ,  ]]   ->   [[  ,  ,  ,20,21,  ], [ 5,  ,  ,  ,  , 4], [  ,  ,  ,  ,  ,  ], [  ,12, 7,  ,  ,  ]]
C3A [[  ,  ,  , 4, 5,  ], [ 7,  ,  ,  ,  ,12], [  ,  ,  ,  ,  ,  ], [  ,20,21,  ,  ,  ]]   ->   [[  ,  ,  ,12, 7,  ], [21,  ,  ,  ,  ,20], [  ,  ,  ,  ,  ,  ], [  , 4, 5,  ,  ,  ]]
C4C [[  ,  ,  ,  ,  ,  ], [  ,  ,  ,10,11,  ], [  ,  ,15,  ,  ,18], [  ,  ,  ,22,23,  ]]   ->   [[  ,  ,  ,  ,  ,  ], [  ,  ,  ,22,23,  ], [  ,  ,11,  ,  ,10], [  ,  ,  ,18,15,  ]]
C4A [[  ,  ,  ,  ,  ,  ], [  ,  ,  ,10,11,  ], [  ,  ,15,  ,  ,18], [  ,  ,  ,22,23,  ]]   ->   [[  ,  ,  ,  ,  ,  ], [  ,  ,  ,18,15,  ], [  ,  ,23,  ,  ,22], [  ,  ,  ,10,11,  ]]
                                                                                ->
E1  [[ 1, 2,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [13,14,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ]]   ->   [[13,14,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [ 1, 2,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ]]
E2  [[  ,  , 3, 4,  ,  ], [ 7, 8,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ]]   ->   [[  ,  , 7, 8,  ,  ], [ 3, 4,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ]]
E3  [[  ,  ,  ,  ,  ,  ], [  ,  , 9,10,  ,  ], [  ,  ,15,16,  ,  ], [  ,  ,  ,  ,  ,  ]]   ->   [[  ,  ,  ,  ,  ,  ], [  ,  ,15,16,  ,  ], [  ,  , 9,10,  ,  ], [  ,  ,  ,  ,  ,  ]]
E4  [[  ,  ,  ,  , 5, 6], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [19,20,  ,  ,  ,  ]]   ->   [[  ,  ,  ,  ,19,20], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [ 5, 6,  ,  ,  ,  ]]
E5  [[  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,11,12], [  ,  ,  ,  ,  ,  ], [  ,  ,21,22,  ,  ]]   ->   [[  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,21,22], [  ,  ,  ,  ,  ,  ], [  ,  ,11,12,  ,  ]]
E6  [[  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,17,18], [  ,  ,  ,  ,23,24]]   ->   [[  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,  ,  ], [  ,  ,  ,  ,23,24], [  ,  ,  ,  ,17,18]]

These faces are mapped to their index:
F1C [0,0], [0,1], [0,2], [0,3], [0,4], [0,5]   ->   [0,2], [0,3], [0,4], [0,5], [0,0], [0,1]
F1A [0,0], [0,1], [0,2], [0,3], [0,4], [0,5]   ->   [0,1], [0,2], [0,3], [0,4], [0,5], [0,0]
F2C [1,0], [1,1], [1,2], [1,3], [1,4], [1,5]   ->   [1,2], [1,3], [1,4], [1,5], [1,0], [1,1]
F2A [1,0], [1,1], [1,2], [1,3], [1,4], [1,5]   ->   [1,1], [1,2], [1,3], [1,4], [1,5], [1,0]
F3C [2,0], [2,1], [2,2], [2,3], [2,4], [2,5]   ->   [2,2], [2,3], [2,4], [2,5], [2,0], [2,1]
F3A [2,0], [2,1], [2,2], [2,3], [2,4], [2,5]   ->   [2,1], [2,2], [2,3], [2,4], [2,5], [2,0]
F4C [3,0], [3,1], [3,2], [3,3], [3,4], [3,5]   ->   [3,2], [3,3], [3,4], [3,5], [3,0], [3,1]
F4A [3,0], [3,1], [3,2], [3,3], [3,4], [3,5]   ->   [3,1], [3,2], [3,3], [3,4], [3,5], [3,0]

C1C [0,1], [0,2], [2,3], [2,0], [1,1], [1,2]   ->   [2,3], [2,0], [1,1], [1,2], [0,1], [0,2]
C1A [0,1], [0,2], [2,3], [2,0], [1,1], [1,2]   ->   [0,2], [2,3], [2,0], [1,1], [1,2], [0,1]
C2C [3,5], [3,0], [2,1], [2,4], [0,5], [0,0]   ->   [2,1], [2,4], [0,5], [0,0], [3,5], [3,0]
C2A [3,5], [3,0], [2,1], [2,4], [0,5], [0,0]   ->   [3,0], [2,1], [2,4], [0,5], [0,0], [3,5]
C3C [0,3], [0,4], [1,5], [1,0], [3,1], [3,2]   ->   [1,5], [1,0], [3,1], [3,2], [0,3], [0,4]
C3A [0,3], [0,4], [1,5], [1,0], [3,1], [3,2]   ->   [0,4], [1,5], [1,0], [3,1], [3,2], [0,3]
C4C [1,3], [1,4], [2,5], [2,2], [3,3], [3,4]   ->   [2,5], [2,2], [3,3], [3,4], [1,3], [1,4]
C4A [1,3], [1,4], [2,5], [2,2], [3,3], [3,4]   ->   [1,4], [2,5], [2,2], [3,3], [3,4], [1,3]

E1  [0,0], [0,1], [2,2], [2,0]                 ->   [2,2], [2,0], [0,0], [0,1]
E2  [0,2], [0,3], [1,2], [1,0]                 ->   [1,2], [1,0], [0,2], [0,3]
E3  [1,2], [1,3], [2,4], [2,2]                 ->   [2,4], [2,2], [1,2], [1,3]
E4  [0,4], [0,5], [3,2], [3,0]                 ->   [3,2], [3,0], [0,4], [0,5]
E5  [1,4], [1,5], [3,4], [3,2]                 ->   [3,4], [3,2], [1,4], [1,5]
E6  [2,4], [2,5], [3,0], [3,4]                 ->   [3,0], [3,4], [2,4], [2,5]

All indices are swapped in pairs (eg. F1C has (0,0-1),(0,2-3),(0,4-5) swapped to (0,2-3),(0,4-5),(0,0-1)).
Each pair of moves that uses A/C also has the same pairs swapped, only in opposite directions.
This means that the moves F1C and F1A move the same pairs, but in opposite directions. IE C: abcdef -> cdefab and A: abcdef -> efabcd.
This gives us the values of j, which is used to slice the list of indices being moved. abcdef -> [abcedf][:j] + [abcdef][:j].
IE: C: j=2, abcdef -> [abcdef][2:]+[abcdef][:2] = cdef+ab
and A: j=4, abcdef -> [abcdef][4:]+[abcdef][:4] = ef+abcd
For moves with E, we only swap two pairs. This is done by setting j to 3:
abcdef -> [abcdef][3:]+[abcdef][:3] = def+abc. By mapping the pairs that we want to swap to ab and de, and setting candf to the same, this works.
Finally we need to calculate all these indeces as shown in the second list.
By naming each value to as follow (names are a bit random, but what came from golfing):
[G,A], [G,B], [F,H], [F,J], [C,D], [C,E] -> ...

We get the following lists for each variable (also introducing b as x-1):
FxA/C:                               CxA/C:                               Ex:
x b  G  A  B  F  H  J  C  D  E       x b  G  A  B  F  H  J  C  D  E       x b  G  A  B  F  H  J  C  D  E
1 0  0, 0, 1, 0, 2, 3, 0, 4, 5       1 0  0, 1, 2, 2, 3, 0, 1, 1, 2       1 0  0, 0, 1, 2, 2, 0, 2, 1, 2
2 1  1, 0, 1, 1, 2, 3, 1, 4, 5       2 1  3, 5, 0, 2, 1, 4, 0, 5, 0       2 1  0, 2, 3, 1, 2, 0, 1, 1, 2
3 2  2, 0, 1, 2, 2, 3, 2, 4, 5       3 2  0, 3, 4, 1, 5, 0, 3, 1, 2       3 2  1, 2, 3, 2, 4, 2, 2, 3, 4
4 3  3, 0, 1, 3, 2, 3, 3, 4, 5       4 3  1, 3, 4, 2, 5, 2, 3, 3, 4       4 3  0, 4, 5, 3, 2, 0, 3, 1, 2
                                                                          5 4  1, 4, 5, 3, 4, 2, 3, 3, 4
                                                                          6 5  2, 4, 5, 3, 0, 4, 3, 5, 0

All these numbers are then calculated for the current move.
A few dependencies can be seen:
D = (J+1)%6      (equal to J-5, because negative index wraps arund)
E = (J+2)%6      (equal to J-4, .. )
B = (A+1)%6      (equal to A-5, .. )

Which means that we need to calculate the following numbers:
b   0123    0123    012345
    F       C       E
A   0000    1533    022444
C   0123    1033    212333
F   0123    2212    212333
G   0123    0301    001012
H   2222    3155    224240
J   3333    0402    002024

Now all we have to do is golf all of these sequences based on the move...
Introducing two numbers (q: b==1, Q: b==2) we then have:
    F       C           E
A   0       b|1+4*q     b+b%2-b/5*2
C   b       A-5*q       (b/3)|2-q
F   b       2-Q         C
G   b       b%2*(b^2)   b%3-q-Q
H   2       C+2-q       J-4 (also (J+2)%6)
J   3       b%2+G       G*2

j   2/4     2/4         3

All of these are then used to modify the input list, by assigning the indices to themselves, but reordered.

I'm not sure why it works, because I barely understand your magic number calculations (I hope you could add an explanation after you've fully golfed it), but you can save 4 bytes by changing D=A-2*Q;E=-~D%6; to E=(A-2*Q+1)%6;, remove ;D=J+1 at the end of the first if-block, and changing both e[D] to e[J+1] in the else-block.

@KevinCruijssen Thanks :)     I'll try to write up an explanation soon

@KevinCruijssen Phew, writeup done.. I hope it makes sense :)

Ruby, 332 324 bytes
->m,a{g=->x,y,z{"7KN=)&L]idSGWCaf>M!$3?<-".bytes.index x*16+y*4+z+69}
m=m.hex;q=(t=m%16<8)?m%8/4+3:m/16%26-7
(r=[*-2..2]).product(r,r).map{|i|n=g[*i]
d=0
6.times{|j|d+=(i[j%3]*=(26564818>>j%3*8+q&2)-1)**2
j==2&&(t ?i[-k=m%4]>1&&(i[1-k]*=-1;i[2-k]*=-1):i.max<1&&i.rotate!(m%8*((22>>q&2)-1)))}
h=g[*i]
d==10&&a[h/6][h%6]=n}
a}

Try it online!
Takes input as a string, which it then interprets as a hexadecimal number. If it is acceptable to take input as an integer, that would save 8 bytes.
Originally developed to output a 0 indexed 1 dimensional array. On re-reading the spec a 2D array is required, so the solved array is used as a dummy template to be filled with data (the structure is used but none of the data within it is.) Output is 0 indexed; it can be made 1 indexed by changing the second last line to d==10&&a[h/6][h%6]=n+1}
Explanation
A reshaping of the puzzle pieces yields a cubic puzzle. The faces of the tetrahedron are built up with triangular pyramids whose sides are 90 degree isosceles triangles. The edges of the original tetrahedron become diagonals on the faces of the cube. See image of partially unfolded cube, showing the numbers and the positive directions for the x,y and z axes.
A rotation of an edge of the tetrahedron corresponds with a rotation of a face of the cube. A rotation of a corner or face of the tetrahedron corresponds with a rotation of a corner of the cube. The numbers of the edges of the tetrahedron become the numbers of the faces of the cube, and the numbers of the corners and faces of the tetrahedron become those of the corners of the cube.

In the code, each piece has a coordinate which is a permutation of [+/-2,+/-1,0] where the coordinate of magnitude 2 corresponds to the face and the other coordinates correspond to the position on the face. The function generates all possible x,y,z coordinates in the range -2..2 and acts only on those where the square of the euclidean distance is 5. For each set of coordinates that is kept, it looks up (using helper function g) the piece number which corresponds to the coordinates and saves it to n. It then modifies the coordinates (if required) according to the move. Finally it looks up the the number which corresponds to the modified coordinates and saves the value of n to the corresponding cell of the array. Once it has processed all 24 valid sets of coordinates it returns the fully populated array.
Commented code
->m,a{                                                          #Input the moves as a string (and the array which we only use as a structure template)
g=->x,y,z{"7KN=)&L]idSGWCaf>M!$3?<-".bytes.index x*16+y*4+z+69} #Helper function to convert native coordinates to the ones required by the question
m=m.hex                                                         #Convert input to an integer. If the last digit is 0..6 (not A or C) t=true.
q=(t=m%16<8)?m%8/4+3:m/16%26-7                                  #If t false q=0..7 to flip correct axes for the particular F# or C# move. If t true q =3 or 4 (flip all or no axes for E# move.)
(r=[*-2..2]).product(r,r).map{|i|                               #Iterate i=[x,y,z] for values in range -2..2 . For each set of coordinates...
n=g[*i]                                                         #Fetch the value from the array (returns nil without errors if coordinates invalid)
d=0                                                             #Initialize a counter to check for valid coordinates (x*x+y*y+z*z)*2=10
6.times{|j|                                                     #Iterate through all three axes (twice, so that flipped axes get unflipped again)
d+=(i[j%3]*=(26564818>>j%3*8+q&2)-1)**2                         #Flip axis j%3 according to the value of q (use magic number to lookup whether to flip or not.) Add coordinate squared to d.
j==2&&                                                          #If this is the 3rd iteration, flips are in correct state to perform the move, so do something.
  (t ?i[-k=m%4]>1&&(i[1-k]*=-1;i[2-k]*=-1):                     #For E#, if the coordinate in axis -k=m%4 is +2 rotate 180 by flipping the other two axes.
  i.max<1&&i.rotate!(m%8*((22>>q&2)-1)))}                       #For F# or C# if all axes 0 or less, rotate by permuting axes in direction determined by m%8 (A/C) & magic number 22
h=g[*i]                                                         #h = index to store the value in after carrying out move
d==10&&a[h/6][h%6]=n}                                           #If d=(x*x+y*y+z*z)*2=10 coordinates are valid. Store the value in the array according to index h.
a}                                                              #Return array a

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/