Magic state distillation with the $15$ qubit code. How are the transversal $T$ performed? Also via a (lower level) state injection?

Question

I have a code $C1$ that admits native fault-tolerant gates for any element in the Clifford group (for instance via transversal implementation), but that then doesn't have an easy way to perform the $T$ gate.

In practice, to implement the $T$-gate we can use state injection and create a logical ancilla state in the state $|A\rangle=T |+\rangle$.

A way to create the $|A\rangle$ state in a reliable manner is to make use of a code that has a native fault-tolerant $T$ gate. The $15$ qubit code is such example (the $T$-gate is transversal).

In practice, to prepare $|A\rangle$, we then:

1. Regroup $15$ logical qubits of the code $C1$ and encode with them the logical $|+_L\rangle$ state of the $15$ qubit code (hence each qubit of the $15$ qubit code is a logical qubit of $C1$, itself composed of physical qubits).
2. Apply a transversal $T$ to this logical qubit (it is equal to a logical $T$ thanks to the $15$ qubit code properties)
3. Decode the $15$ qubit encoding: we now have a state $|A\rangle$ encoded with the code $C1$, we can perform state injection.

(Of course we have to repeat the procedure to have a reliable state but I skip this un-necessary detail for my question).

My question:

For $C_1$ we do not have a fault-tolerant $T$ gate. However, we need to do a $T$ gate within this code for step 2 of the procedure I described. How is it done? Do we use either one of the following methods? Another thing I am not thinking of?

1. We implement a non-fault-tolerant $T$ gate within $C_1$ (hence super noisy, but it is not "really" a problem thanks to the logic of magic state distillation). In this case, I would be interested to know which operations are performed on the physical qubits for the surface code to perform this "non fault-tolerant logical $T$ gate" (it probably deserves another question).
2. We basically do another state injection technique to perform the $T$ gates. This time we will then use an encoding with the $15$ qubit code but each qubit within this code will now be a physical qubit (we are basically at a "lower level" of encoding).

Answer 1

You start with physically injected magic states, expanded into $C_1$. In the case of the surface code you could use e.g. Li injection.

The error rate of this part is extremely important, as it limits how few levels of distillation you will need to reach target error rates.

Once you have T states you do T gates in the next distillation level via gate teleportation.