diff --git a/src/main/java/gregtech/api/metatileentity/implementations/MTEMultiBlockBase.java b/src/main/java/gregtech/api/metatileentity/implementations/MTEMultiBlockBase.java
index 6a1c84baae6..76d70beecab 100644
--- a/src/main/java/gregtech/api/metatileentity/implementations/MTEMultiBlockBase.java
+++ b/src/main/java/gregtech/api/metatileentity/implementations/MTEMultiBlockBase.java
@@ -2,6 +2,7 @@
 
 import static gregtech.api.enums.GTValues.V;
 import static gregtech.api.enums.GTValues.VN;
+import static gregtech.api.recipe.check.SingleRecipeCheck.getDisplayString;
 import static gregtech.api.util.GTUtility.filterValidMTEs;
 import static gregtech.api.util.GTUtility.formatNumbers;
 import static gregtech.api.util.GTUtility.min;
@@ -2077,6 +2078,19 @@ public void getWailaBody(ItemStack itemStack, List<String> currentTip, IWailaDat
             int tAverageTime = tag.getInteger("averageNS");
             currentTip.add("Average CPU load of ~" + formatNumbers(tAverageTime) + " ns");
         }
+        // Always show locked recipe information if the machine is locked to a recipe
+        if (tag.getBoolean("isLockedToRecipe")) {
+            String lockedRecipe = tag.getString("lockedRecipeName");
+            if (!lockedRecipe.isEmpty()) {
+                // Split the string on "\n" and add each line separately.
+                String[] lines = lockedRecipe.split("\n");
+                currentTip.add("Locked Recipe:");
+                for (String line : lines) {
+                    currentTip.add(line);
+                }
+            }
+        }
+
         super.getWailaBody(itemStack, currentTip, accessor, config);
     }
 
@@ -2095,6 +2109,11 @@ public void getWailaNBTData(EntityPlayerMP player, TileEntity tile, NBTTagCompou
         tag.setInteger("progress", mProgresstime);
         tag.setInteger("maxProgress", mMaxProgresstime);
         tag.setBoolean("incompleteStructure", (getErrorDisplayID() & 64) != 0);
+        tag.setBoolean("isLockedToRecipe", isRecipeLockingEnabled());
+        SingleRecipeCheck lockedRecipe = getSingleRecipeCheck();
+        tag.setString(
+            "lockedRecipeName",
+            lockedRecipe != null ? getDisplayString(lockedRecipe.getRecipe(), false, true, false, true) : "");
 
         if (mOutputItems != null) {
             int index = 0;
diff --git a/src/main/java/gregtech/api/recipe/check/SingleRecipeCheck.java b/src/main/java/gregtech/api/recipe/check/SingleRecipeCheck.java
index 12d8a387570..1ee9eee9e15 100644
--- a/src/main/java/gregtech/api/recipe/check/SingleRecipeCheck.java
+++ b/src/main/java/gregtech/api/recipe/check/SingleRecipeCheck.java
@@ -29,24 +29,31 @@
 import gregtech.api.util.GTUtility.ItemId;
 
 /**
- * Used by machines that are locked to a single recipe, for faster recipe check.
+ * Used by machines that are locked to a single recipe, for faster recipe checking.
  * <p>
- * Computation time will be like these:
+ * The typical computation times are:
  * <ul>
- * Normal recipe check:
+ * <li>Normal recipe check:
  * <ul>
- * {@link gregtech.api.recipe.FindRecipeQuery#find Find recipe from recipemap}: O(NCR)
- * where N = number of machine inputs, C = average amount of recipe candidates found for specific input,
- * R = computation time to {@link GTRecipe#isRecipeInputEqual check if inputs match to recipe}
+ * <li>{@link gregtech.api.recipe.FindRecipeQuery#find Find recipe from recipemap}: O(NCR)
+ * <ul>
+ * <li>N = number of machine inputs</li>
+ * <li>C = average amount of recipe candidates for a specific input</li>
+ * <li>R = time to execute {@link GTRecipe#isRecipeInputEqual}</li>
  * </ul>
+ * </li>
+ * <li>{@link GTRecipe#isRecipeInputEqual Check if inputs match recipe}: O(NM)
  * <ul>
- * {@link GTRecipe#isRecipeInputEqual Check if inputs match to recipe}: O(NM)
- * where N = number of machine inputs, M = number of recipe inputs
+ * <li>N = number of machine inputs</li>
+ * <li>M = number of recipe inputs</li>
  * </ul>
+ * </li>
  * </ul>
- * <ul>
- * {@link #checkRecipeInputs Single recipe check}: O(N + M)
- * where N = number of machine inputs, M = number of recipe inputs
+ * </li>
+ * <li>
+ * {@link #checkRecipeInputs Single recipe check}: O(N + M), where
+ * N = number of machine inputs and M = number of recipe inputs.
+ * </li>
  * </ul>
  */
 public class SingleRecipeCheck {
@@ -63,6 +70,14 @@ public class SingleRecipeCheck {
     private final int totalItemCost;
     private final int totalFluidCost;
 
+    /**
+     * Private constructor.
+     *
+     * @param recipe    the recipe to check
+     * @param recipeMap the recipe map from which the recipe originates
+     * @param itemCost  an immutable map of item costs (required item amounts)
+     * @param fluidCost an immutable map of fluid costs (required fluid amounts)
+     */
     private SingleRecipeCheck(@Nonnull GTRecipe recipe, @Nonnull RecipeMap<?> recipeMap,
         @Nonnull ImmutableMap<ItemId, Integer> itemCost, @Nonnull ImmutableMap<Fluid, Integer> fluidCost) {
         this.recipe = recipe;
@@ -80,32 +95,51 @@ private SingleRecipeCheck(@Nonnull GTRecipe recipe, @Nonnull RecipeMap<?> recipe
             .sum();
     }
 
+    /**
+     * Returns the recipe associated with this check.
+     *
+     * @return the GTRecipe instance
+     */
     @Nonnull
     public GTRecipe getRecipe() {
         return recipe;
     }
 
+    /**
+     * Returns the RecipeMap from which this recipe originates.
+     *
+     * @return the RecipeMap instance
+     */
     @Nonnull
     public RecipeMap<?> getRecipeMap() {
         return recipeMap;
     }
 
     /**
-     * Returns the number of parallel recipes, or 0 if recipe is not satisfied at all.
+     * Checks the available inputs against the recipe cost and returns the number of parallel recipes
+     * that can be executed. Returns 0 if the recipe is not satisfied at all.
+     * <p>
+     * Optionally, the method can consume (subtract) the used inputs.
+     *
+     * @param consumeInputs if true, subtract the inputs used for the recipe from the provided arrays
+     * @param maxParallel   the maximum number of parallel executions to attempt
+     * @param itemInputs    an array of available item stacks
+     * @param fluidInputs   an array of available fluid stacks
+     * @return the number of parallel recipes that can be executed, or 0 if inputs are insufficient
      */
     public int checkRecipeInputs(boolean consumeInputs, int maxParallel, ItemStack[] itemInputs,
         FluidStack[] fluidInputs) {
         int currentParallel = maxParallel;
 
         if (totalItemCost > 0) {
-            // Create map for item -> stored amount
+            // Create a map for items to their stored amounts.
             Map<ItemId, Integer> itemMap = new HashMap<>();
             for (ItemStack itemStack : itemInputs) {
                 if (itemStack == null) continue;
                 itemMap.merge(ItemId.createNoCopy(itemStack), itemStack.stackSize, Integer::sum);
             }
 
-            // Check how many parallels can it perform for each item
+            // For each item cost, update the maximum parallel executions possible.
             for (Map.Entry<ItemId, Integer> costEntry : itemCost.entrySet()) {
                 currentParallel = Math
                     .min(currentParallel, itemMap.getOrDefault(costEntry.getKey(), 0) / costEntry.getValue());
@@ -116,14 +150,14 @@ public int checkRecipeInputs(boolean consumeInputs, int maxParallel, ItemStack[]
         }
 
         if (totalFluidCost > 0) {
-            // Create map for fluid -> stored amount
+            // Create a map for fluids to their stored amounts.
             Map<Fluid, Integer> fluidMap = new HashMap<>();
             for (FluidStack fluidStack : fluidInputs) {
                 if (fluidStack == null) continue;
                 fluidMap.merge(fluidStack.getFluid(), fluidStack.amount, Integer::sum);
             }
 
-            // Check how many parallels can it perform for each fluid
+            // For each fluid cost, update the maximum parallel executions possible.
             for (Map.Entry<Fluid, Integer> costEntry : fluidCost.entrySet()) {
                 currentParallel = Math
                     .min(currentParallel, fluidMap.getOrDefault(costEntry.getKey(), 0) / costEntry.getValue());
@@ -150,7 +184,7 @@ public int checkRecipeInputs(boolean consumeInputs, int maxParallel, ItemStack[]
                     runningItemCost.put(key, runningCost - paid);
 
                     remainingItemCost -= paid;
-                    // If all item costs are paid, we don't need to iterate inputs furthermore
+                    // If all item costs are paid, break out of the loop.
                     if (remainingItemCost <= 0) {
                         break;
                     }
@@ -172,7 +206,7 @@ public int checkRecipeInputs(boolean consumeInputs, int maxParallel, ItemStack[]
                     runningFluidCost.put(key, runningCost - paid);
 
                     remainingFluidCost -= paid;
-                    // If all fluid costs are paid, we don't need to iterate inputs furthermore
+                    // If all fluid costs are paid, break out of the loop.
                     if (remainingFluidCost <= 0) {
                         break;
                     }
@@ -183,6 +217,14 @@ public int checkRecipeInputs(boolean consumeInputs, int maxParallel, ItemStack[]
         return finalParallel;
     }
 
+    /**
+     * Serializes the recipe check data to an NBTTagCompound.
+     * <p>
+     * The serialized data includes recipe inputs, outputs, chances, energy usage (EUT),
+     * duration, special value, and the computed item/fluid costs.
+     *
+     * @return a new NBTTagCompound containing the serialized recipe check data
+     */
     public NBTTagCompound writeToNBT() {
         // Here we encode recipe input, output and all other important values.
         // At load time we do a recipe check again, so in case the recipe is gone, we can stop tracking.
@@ -238,10 +280,28 @@ public NBTTagCompound writeToNBT() {
         return tag;
     }
 
+    /**
+     * Writes an array of elements into an NBTTagList using the provided serializer function.
+     *
+     * @param arr   the array of elements to write
+     * @param ser   a function that serializes each element into an NBTBase instance
+     * @param <T>   the type of the elements in the array
+     * @param <NBT> the type of NBTBase that the elements are serialized to
+     * @return an NBTTagList containing the serialized elements
+     */
     private static <T, NBT extends NBTBase> NBTTagList writeList(T[] arr, Function<T, NBT> ser) {
         return writeList(Arrays.asList(arr), ser);
     }
 
+    /**
+     * Writes a collection of elements into an NBTTagList using the provided serializer function.
+     *
+     * @param arr   the collection of elements to write
+     * @param ser   a function that serializes each element into an NBTBase instance
+     * @param <T>   the type of the elements in the collection
+     * @param <NBT> the type of NBTBase that the elements are serialized to
+     * @return an NBTTagList containing the serialized elements
+     */
     private static <T, NBT extends NBTBase> NBTTagList writeList(Collection<T> arr, Function<T, NBT> ser) {
         NBTTagList l = new NBTTagList();
         for (T t : arr) {
@@ -250,6 +310,13 @@ private static <T, NBT extends NBTBase> NBTTagList writeList(Collection<T> arr,
         return l;
     }
 
+    /**
+     * Attempts to load a SingleRecipeCheck instance from the given NBTTagCompound.
+     *
+     * @param recipeMap the RecipeMap to use as a fallback in case the stored map is not found
+     * @param tag       the NBTTagCompound containing the serialized recipe check data
+     * @return a SingleRecipeCheck instance if loading is successful, or null if loading fails
+     */
     @Nullable
     public static SingleRecipeCheck tryLoad(RecipeMap<?> recipeMap, NBTTagCompound tag) {
         if (tag == null || tag.hasNoTags()) return null;
@@ -275,6 +342,12 @@ public static SingleRecipeCheck tryLoad(RecipeMap<?> recipeMap, NBTTagCompound t
         return new SingleRecipeCheck(foundRecipe, mapToUse, loadItemCost(tag), loadFluidCost(tag));
     }
 
+    /**
+     * Loads the fluid cost map from the provided NBTTagCompound.
+     *
+     * @param tag the NBTTagCompound containing the fluid cost data
+     * @return an immutable map of Fluid to Integer representing the fluid costs
+     */
     private static ImmutableMap<Fluid, Integer> loadFluidCost(NBTTagCompound tag) {
         return GTUtility.streamCompounds(tag.getTagList("fluidCost", Constants.NBT.TAG_COMPOUND))
             .collect(
@@ -282,12 +355,26 @@ private static ImmutableMap<Fluid, Integer> loadFluidCost(NBTTagCompound tag) {
                     .toImmutableMapSerial(t -> FluidRegistry.getFluid(t.getString("id")), t -> t.getInteger("count")));
     }
 
+    /**
+     * Loads the item cost map from the provided NBTTagCompound.
+     *
+     * @param tag the NBTTagCompound containing the item cost data
+     * @return an immutable map of ItemId to Integer representing the item costs
+     */
     private static ImmutableMap<ItemId, Integer> loadItemCost(NBTTagCompound tag) {
         return GTUtility.streamCompounds(tag.getTagList("itemCost", Constants.NBT.TAG_COMPOUND))
             .collect(
                 GTUtility.toImmutableMapSerial(t -> ItemId.create(t.getCompoundTag("id")), t -> t.getInteger("count")));
     }
 
+    /**
+     * Tries to find the corresponding recipe from the recipe map using the data stored in the NBTTagCompound.
+     * It checks the inputs, outputs, fluid inputs, fluid outputs, chances, duration, EUT, and special value.
+     *
+     * @param recipeMap the RecipeMap to search for the recipe
+     * @param tag       the NBTTagCompound containing the serialized recipe data
+     * @return the matching GTRecipe, or null if no match is found or if the data does not match
+     */
     private static GTRecipe tryFindRecipe(@Nonnull RecipeMap<?> recipeMap, NBTTagCompound tag) {
         ItemStack[] inputs = GTUtility.streamCompounds(tag.getTagList("inputs", Constants.NBT.TAG_COMPOUND))
             .map(GTUtility::loadItem)
@@ -320,6 +407,12 @@ private static GTRecipe tryFindRecipe(@Nonnull RecipeMap<?> recipeMap, NBTTagCom
         return found;
     }
 
+    /**
+     * Builds an immutable map of item costs from an array of input ItemStacks.
+     *
+     * @param inputs an array of ItemStacks representing the inputs
+     * @return an immutable map of ItemId to Integer representing the cost per item
+     */
     private static ImmutableMap<ItemId, Integer> buildItemMap(ItemStack[] inputs) {
         Map<ItemId, Integer> itemMap = new HashMap<>();
         for (ItemStack itemStack : inputs) {
@@ -329,6 +422,12 @@ private static ImmutableMap<ItemId, Integer> buildItemMap(ItemStack[] inputs) {
         return ImmutableMap.copyOf(itemMap);
     }
 
+    /**
+     * Builds an immutable map of fluid costs from an array of FluidStacks.
+     *
+     * @param fluids an array of FluidStacks representing the fluids
+     * @return an immutable map of Fluid to Integer representing the cost per fluid
+     */
     private static ImmutableMap<Fluid, Integer> buildFluidMap(FluidStack[] fluids) {
         Map<Fluid, Integer> fluidMap = new HashMap<>();
         for (FluidStack fluidStack : fluids) {
@@ -338,16 +437,173 @@ private static ImmutableMap<Fluid, Integer> buildFluidMap(FluidStack[] fluids) {
         return ImmutableMap.copyOf(fluidMap);
     }
 
+    /**
+     * Returns a new Builder instance for constructing a SingleRecipeCheck.
+     *
+     * @param recipeMap the RecipeMap that will be used in this recipe check
+     * @return a new Builder instance
+     */
     public static Builder builder(@Nonnull RecipeMap<?> recipeMap) {
         return new Builder(Objects.requireNonNull(recipeMap));
     }
 
+    /**
+     * Returns a human-friendly string representing the recipe.
+     * The caller can choose whether to include inputs and/or outputs.
+     * 
+     * @param recipe           GT recipe
+     * @param includeInputs    if true, include item and fluid inputs.
+     * @param includeOutputs   if true, include item and fluid outputs.
+     * @param showStackAmounts if true, display the stack amounts for items/fluids; otherwise only their names are
+     *                         shown.
+     * @param multiLine        if true, format the recipe string over multiple lines; otherwise format it as a single
+     *                         line.
+     * @return the formatted recipe string.
+     */
+    public static String getDisplayString(GTRecipe recipe, boolean includeInputs, boolean includeOutputs,
+        boolean showStackAmounts, boolean multiLine) {
+        StringBuilder sb = new StringBuilder();
+
+        if (multiLine) {
+            // Process outputs first if requested.
+            if (includeOutputs) {
+                boolean hasOutput = false;
+                if (recipe.mFluidOutputs != null && recipe.mFluidOutputs.length > 0) {
+                    sb.append("Fluid Outputs:\n");
+                    for (FluidStack fluid : recipe.mFluidOutputs) {
+                        if (fluid == null) continue;
+                        sb.append("- ");
+                        sb.append(fluid.getLocalizedName());
+                        if (showStackAmounts) {
+                            sb.append(" (")
+                                .append(fluid.amount)
+                                .append("L)");
+                        }
+                        sb.append("\n");
+                    }
+                    hasOutput = true;
+                }
+                if (recipe.mOutputs != null && recipe.mOutputs.length > 0) {
+                    sb.append("Item Outputs:\n");
+                    for (ItemStack item : recipe.mOutputs) {
+                        if (item == null) continue;
+                        sb.append("- ");
+                        sb.append(item.getDisplayName());
+                        if (showStackAmounts) {
+                            sb.append(" x")
+                                .append(item.stackSize);
+                        }
+                        sb.append("\n");
+                    }
+                }
+                if (hasOutput) {
+                    sb.append("\n");
+                }
+            }
+
+            // Process inputs if requested.
+            if (includeInputs) {
+                if (recipe.mFluidInputs != null && recipe.mFluidInputs.length > 0) {
+                    sb.append("Fluid Inputs:\n");
+                    for (FluidStack fluid : recipe.mFluidInputs) {
+                        if (fluid == null) continue;
+                        sb.append("- ");
+                        sb.append(fluid.getLocalizedName());
+                        if (showStackAmounts) {
+                            sb.append(" (")
+                                .append(fluid.amount)
+                                .append("L)");
+                        }
+                        sb.append("\n");
+                    }
+                    sb.append("\n");
+                }
+                if (recipe.mInputs != null && recipe.mInputs.length > 0) {
+                    sb.append("Item Inputs:\n");
+                    for (ItemStack item : recipe.mInputs) {
+                        if (item == null) continue;
+                        sb.append("- ");
+                        sb.append(item.getDisplayName());
+                        if (showStackAmounts) {
+                            sb.append(" x")
+                                .append(item.stackSize);
+                        }
+                        sb.append("\n");
+                    }
+                }
+            }
+        } else { // Single-line formatting.
+            boolean addedSomething = false;
+            if (includeInputs) {
+                StringBuilder inputSb = new StringBuilder();
+                if (recipe.mInputs != null && recipe.mInputs.length > 0) {
+                    inputSb.append("Item Inputs: ");
+                    inputSb.append(
+                        Arrays.stream(recipe.mInputs)
+                            .filter(Objects::nonNull)
+                            .map(item -> item.getDisplayName() + (showStackAmounts ? " x" + item.stackSize : ""))
+                            .collect(Collectors.joining(", ")));
+                }
+                if (recipe.mFluidInputs != null && recipe.mFluidInputs.length > 0) {
+                    if (inputSb.length() > 0) {
+                        inputSb.append(" | ");
+                    }
+                    inputSb.append("Fluid Inputs: ");
+                    inputSb.append(
+                        Arrays.stream(recipe.mFluidInputs)
+                            .filter(Objects::nonNull)
+                            .map(
+                                fluid -> fluid.getLocalizedName()
+                                    + (showStackAmounts ? " (" + fluid.amount + "L)" : ""))
+                            .collect(Collectors.joining(", ")));
+                }
+                if (inputSb.length() > 0) {
+                    sb.append(inputSb);
+                    addedSomething = true;
+                }
+            }
+            if (includeOutputs) {
+                StringBuilder outputSb = new StringBuilder();
+                if (recipe.mOutputs != null && recipe.mOutputs.length > 0) {
+                    outputSb.append("Item Outputs: ");
+                    outputSb.append(
+                        Arrays.stream(recipe.mOutputs)
+                            .filter(Objects::nonNull)
+                            .map(item -> item.getDisplayName() + (showStackAmounts ? " x" + item.stackSize : ""))
+                            .collect(Collectors.joining(", ")));
+                }
+                if (recipe.mFluidOutputs != null && recipe.mFluidOutputs.length > 0) {
+                    if (outputSb.length() > 0) {
+                        outputSb.append(" | ");
+                    }
+                    outputSb.append("Fluid Outputs: ");
+                    outputSb.append(
+                        Arrays.stream(recipe.mFluidOutputs)
+                            .filter(Objects::nonNull)
+                            .map(
+                                fluid -> fluid.getLocalizedName()
+                                    + (showStackAmounts ? " (" + fluid.amount + "L)" : ""))
+                            .collect(Collectors.joining(", ")));
+                }
+                if (outputSb.length() > 0) {
+                    if (addedSomething) {
+                        sb.append(" => ");
+                    }
+                    sb.append(outputSb);
+                }
+            }
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Builder class for constructing SingleRecipeCheck instances.
+     */
     public static class Builder {
 
         private final RecipeMap<?> recipeMap;
 
-        // In order to compute which items and fluids are consumed by the recipe, we compare the
-        // multi-block's items and fluids before and after inputs are consumed by the recipe.
+        // Used to compute the amount of inputs consumed by comparing the before and after states.
         private Map<ItemId, Integer> beforeItems;
         private Map<Fluid, Integer> beforeFluids;
         private Map<ItemId, Integer> afterItems;
@@ -355,27 +611,57 @@ public static class Builder {
 
         private GTRecipe recipe;
 
+        /**
+         * Private constructor for Builder.
+         *
+         * @param recipeMap the RecipeMap to use for the recipe check
+         */
         private Builder(@Nonnull RecipeMap<?> recipeMap) {
             this.recipeMap = recipeMap;
         }
 
+        /**
+         * Sets the "before" state for the recipe check.
+         *
+         * @param inputs an array of item stacks before the recipe consumes inputs
+         * @param fluids an array of fluid stacks before the recipe consumes inputs
+         * @return this Builder instance for chaining
+         */
         public Builder setBefore(ItemStack[] inputs, FluidStack[] fluids) {
             beforeItems = buildItemMap(inputs);
             beforeFluids = buildFluidMap(fluids);
             return this;
         }
 
+        /**
+         * Sets the "after" state for the recipe check.
+         *
+         * @param inputs an array of item stacks after the recipe has consumed inputs
+         * @param fluids an array of fluid stacks after the recipe has consumed inputs
+         * @return this Builder instance for chaining
+         */
         public Builder setAfter(ItemStack[] inputs, FluidStack[] fluids) {
             afterItems = buildItemMap(inputs);
             afterFluids = buildFluidMap(fluids);
             return this;
         }
 
+        /**
+         * Sets the recipe that will be used for the recipe check.
+         *
+         * @param recipe the GTRecipe to be checked
+         * @return this Builder instance for chaining
+         */
         public Builder setRecipe(@Nonnull GTRecipe recipe) {
             this.recipe = recipe;
             return this;
         }
 
+        /**
+         * Computes and returns an immutable map of item costs by comparing the before and after item states.
+         *
+         * @return an immutable map of ItemId to Integer representing the cost per item
+         */
         private ImmutableMap<ItemId, Integer> buildItemCost() {
             ImmutableMap.Builder<ItemId, Integer> itemCostBuilder = ImmutableMap.builder();
             for (Map.Entry<ItemId, Integer> entry : beforeItems.entrySet()) {
@@ -387,6 +673,11 @@ private ImmutableMap<ItemId, Integer> buildItemCost() {
             return itemCostBuilder.build();
         }
 
+        /**
+         * Computes and returns an immutable map of fluid costs by comparing the before and after fluid states.
+         *
+         * @return an immutable map of Fluid to Integer representing the cost per fluid
+         */
         private ImmutableMap<Fluid, Integer> buildFluidCost() {
             ImmutableMap.Builder<Fluid, Integer> fluidCostBuilder = ImmutableMap.builder();
             for (Map.Entry<Fluid, Integer> entry : beforeFluids.entrySet()) {
@@ -398,11 +689,18 @@ private ImmutableMap<Fluid, Integer> buildFluidCost() {
             return fluidCostBuilder.build();
         }
 
+        /**
+         * Builds and returns a new SingleRecipeCheck instance based on the data provided to the Builder.
+         *
+         * @return a new SingleRecipeCheck instance
+         * @throws IllegalStateException if the recipe has not been set
+         */
         public SingleRecipeCheck build() {
             if (recipe == null) {
                 throw new IllegalStateException("recipe is not set");
             }
             return new SingleRecipeCheck(recipe, recipeMap, buildItemCost(), buildFluidCost());
         }
+
     }
 }