feat(block): add best recipe goal shortcut

Use Ctrl+Click or Command+Click on a goal to add the first currently unlocked recipe from the picker's logistic-cost ranking. Exclude barreling choices and keep normal clicks opening the picker.\n\nCloses #152

Author: ApocDev

app/e2e/mut/goal-recipe-shortcut.e2e.ts

@@ -0,0 +1,24 @@
+import { expect, test } from "@playwright/test";
+import { addGoal, createBlock, expectUndoTop } from "./helpers";
+
+test("Ctrl+Click adds the picker's best currently unlocked goal recipe", async ({ page }) => {
+  await createBlock(page);
+  await addGoal(page, "iron plate", "Iron plate");
+  await expectUndoTop(page, /Undo: Edit block "Iron plate"/);
+
+  const goal = page.getByRole("button", { name: "add a recipe that makes Iron plate" });
+  await goal.click();
+  const picker = page.getByRole("dialog", { name: "Recipes that make Iron plate" });
+  await expect(picker.getByText("Unlocked now", { exact: true })).toBeVisible();
+  const best = picker.locator("[data-recipe-candidate]").first();
+  const bestName = await best.getAttribute("data-recipe-candidate");
+  expect(bestName).toBeTruthy();
+  expect(bestName).not.toMatch(/barrel/i);
+  await page.keyboard.press("Escape");
+  await expect(picker).toBeHidden();
+
+  await goal.click({ modifiers: ["Control"] });
+  await expect(page.locator(`[data-recipe-row="${bestName}"]`)).toBeVisible();
+  await expect(picker).toBeHidden();
+  await expectUndoTop(page, /Undo: Add recipe/);
+});

app/src/components/block/goal-card.tsx

@@ -44,6 +44,7 @@ export function GoalCard({
   onGoalMenu,
   onMakeFor,
   onUseFor,
+  onQuickRecipeFor,
   onOpenGoalPicker,
 }: {
   doc: BlockDocStore;
@@ -55,6 +56,7 @@ export function GoalCard({
   onGoalMenu: (e: { clientX: number; clientY: number }, name: string) => void;
   onMakeFor: (name: string) => void;
   onUseFor: (name: string) => void;
+  onQuickRecipeFor: (name: string, mode: "produce" | "consume") => void;
   onOpenGoalPicker: () => void;
 }) {
   const goals = useStore(doc.store, (s) => s.goals);
@@ -123,13 +125,16 @@ export function GoalCard({
                 const extraText = goalMissing ? (
                   "No longer exists in the current data."
                 ) : goalUnmade ? (
-                  `No recipe in this block ${consumes ? "consumes" : "makes"} it. Click to add one.`
+                  `No recipe in this block ${consumes ? "consumes" : "makes"} it. Click to choose one, or Ctrl+Click to add the best unlocked non-barreling recipe.`
                 ) : (
                   <div className="space-y-1">
                     <div>
                       {isFirst ? "Primary goal · names the block" : "Goal"} · right-click for
                       options
                     </div>
+                    <div className="text-muted-foreground">
+                      Ctrl+Click · add best unlocked non-barreling recipe
+                    </div>
                     {incidentalRate > 0 && (
                       <div className="flex items-center gap-1 text-warning">
                         <Timer className="size-3.5" /> {num(incidentalRate)}/s estimated incidental
@@ -192,7 +197,14 @@ export function GoalCard({
                           </button>
                         </div>
                         <button
-                          onClick={() => (consumes ? onUseFor(g) : onMakeFor(g))}
+                          onClick={(event) => {
+                            if (event.ctrlKey || event.metaKey) {
+                              onQuickRecipeFor(g, consumes ? "consume" : "produce");
+                              return;
+                            }
+                            if (consumes) onUseFor(g);
+                            else onMakeFor(g);
+                          }}
                           aria-label={`add a recipe that ${consumes ? "consumes" : "makes"} ${res?.display?.[g] ?? g}`}
                         >
                           <Icon kind={kind} name={g} size="lg" extraText={extraText} />

app/src/lib/recipe-shortcuts.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vite-plus/test";
+import { bestUnlockedNonBarrelingRecipe, isBarrelingRecipe } from "./recipe-shortcuts.ts";
+
+describe("best unlocked recipe shortcut", () => {
+  it("takes the first unlocked non-barreling candidate from picker order", () => {
+    const candidates = [
+      { name: "fill-water-barrel", category: "py-barreling", unlockedNow: true },
+      { name: "pump-water", category: "water", unlockedNow: true },
+      { name: "distill-water", category: "chemistry", unlockedNow: true },
+    ];
+
+    expect(bestUnlockedNonBarrelingRecipe(candidates)?.name).toBe("pump-water");
+  });
+
+  it("does not fall through to horizon, locked, or superseded choices", () => {
+    expect(
+      bestUnlockedNonBarrelingRecipe([
+        { name: "future", unlockedNow: false },
+        { name: "old", unlockedNow: true, superseded: { by: "new" } },
+      ]),
+    ).toBeUndefined();
+  });
+
+  it("recognizes standard categories and custom-category barrel names", () => {
+    expect(isBarrelingRecipe({ name: "fill-water", category: "barrelling" })).toBe(true);
+    expect(isBarrelingRecipe({ name: "mod-fill-water-barrel", category: "chemistry" })).toBe(true);
+    expect(isBarrelingRecipe({ name: "pump-water", category: "water" })).toBe(false);
+  });
+});

app/src/lib/recipe-shortcuts.ts

@@ -0,0 +1,28 @@
+const BARREL_CATEGORIES = new Set(["py-barreling", "py-unbarreling", "barreling", "barrelling"]);
+
+export type RankedRecipeCandidate = {
+  name: string;
+  category?: string | null;
+  unlockedNow: boolean;
+  superseded?: unknown;
+};
+
+/** Barrel fill/empty recipes are transport plumbing, not the production choice
+ * a goal shortcut should make. Category is authoritative; the name fallback
+ * covers modded variants that use a custom category. */
+export function isBarrelingRecipe(recipe: Pick<RankedRecipeCandidate, "name" | "category">) {
+  return (
+    BARREL_CATEGORIES.has(recipe.category ?? "") || recipe.name.toLowerCase().includes("barrel")
+  );
+}
+
+/** Candidates already carry the recipe picker's authoritative ordering:
+ * currently unlocked recipe+machine first, then logistic cost and display name.
+ * Select the first eligible entry rather than recreating that ranking here. */
+export function bestUnlockedNonBarrelingRecipe<T extends RankedRecipeCandidate>(
+  candidates: readonly T[],
+): T | undefined {
+  return candidates.find(
+    (candidate) => candidate.unlockedNow && !candidate.superseded && !isBarrelingRecipe(candidate),
+  );
+}

app/src/routes/block.$id.tsx

@@ -30,6 +30,7 @@ import { blockActionName } from "../lib/undo-names";
 import { launchesForRate, resolveLogistics } from "../lib/logistics";
 import { recordRecent } from "../lib/recents";
 import { createCoalescedRunner } from "../lib/coalesced-runner";
+import { bestUnlockedNonBarrelingRecipe } from "../lib/recipe-shortcuts";
 import { IconProvider, useSpoilables } from "../lib/icons";
 import { ModulesModal } from "../lib/modules-modal";
 import { Callout } from "#/components/ui/callout.tsx";
@@ -156,9 +157,11 @@ function Block({ blockId }: { blockId: number }) {
     toast({ message: `Extracted "${out.name}" into a new block.` });
     void navigate({ to: "/block/$id", params: { id: String(out.id) } });
   };
-  const [pickFor, setPickFor] = useState<{ name: string; mode: "produce" | "consume" } | null>(
-    null,
-  );
+  const [pickFor, setPickFor] = useState<{
+    name: string;
+    mode: "produce" | "consume";
+    quick?: boolean;
+  } | null>(null);
   const [pickMachineFor, setPickMachineFor] = useState<string | null>(null); // recipe whose machine we're choosing
   const [pickFuelFor, setPickFuelFor] = useState<string | null>(null); // recipe whose fuel we're choosing
   const [pickModulesFor, setPickModulesFor] = useState<string | null>(null); // recipe whose modules we're editing
@@ -579,12 +582,33 @@ function Block({ blockId }: { blockId: number }) {
       });
   };
 
+  const quickRecipe = pickFor?.quick
+    ? bestUnlockedNonBarrelingRecipe(picker.data ?? [])
+    : undefined;
+  useEffect(() => {
+    if (!pickFor?.quick || (!picker.isSuccess && !picker.isError)) return;
+    if (picker.isError) {
+      toast({ message: "Could not load recipe choices.", tone: "destructive" });
+      setPickFor(null);
+    } else if (quickRecipe) add(quickRecipe.name);
+    else {
+      toast({
+        message: `No unlocked non-barreling recipe is available for ${res?.display?.[pickFor.name] ?? pickFor.name}.`,
+      });
+      setPickFor(null);
+    }
+    // `add` intentionally consumes the current picker state and closes it.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [pickFor?.quick, picker.isSuccess, picker.isError, quickRecipe?.name]);
+
   // When a flow has exactly one craftable recipe, skip the picker dialog and add
   // it directly. A superseded recipe (its base no longer exists in-game) or one
   // that's already in the block still opens the dialog, so the explanation/state
   // stays visible rather than the click silently doing nothing.
   const loneRecipe =
-    pickFor && picker.data?.length === 1 && !picker.data[0].superseded ? picker.data[0] : null;
+    pickFor && !pickFor.quick && picker.data?.length === 1 && !picker.data[0].superseded
+      ? picker.data[0]
+      : null;
   const autoAddRecipe = loneRecipe && !recipes.includes(loneRecipe.name) ? loneRecipe.name : null;
   useEffect(() => {
     if (autoAddRecipe) add(autoAddRecipe);
@@ -718,6 +742,8 @@ function Block({ blockId }: { blockId: number }) {
           : "linked";
   const makeFor = (name: string) => setPickFor({ name, mode: "produce" });
   const useFor = (name: string) => setPickFor({ name, mode: "consume" });
+  const quickRecipeFor = (name: string, mode: "produce" | "consume") =>
+    setPickFor({ name, mode, quick: true });
   const openCtxMenu = (
     e: { clientX: number; clientY: number },
     d: { name: string; kind: string; link: ItemLink },
@@ -808,6 +834,7 @@ function Block({ blockId }: { blockId: number }) {
           onGoalMenu={(e, name) => setGoalMenu({ x: e.clientX, y: e.clientY, name })}
           onMakeFor={makeFor}
           onUseFor={useFor}
+          onQuickRecipeFor={quickRecipeFor}
           onOpenGoalPicker={() => setGoalPicker({})}
         />
         <BalanceCard
@@ -953,7 +980,7 @@ function Block({ blockId }: { blockId: number }) {
       )}
 
       {/* Recipe picker — floats over everything, dismissable */}
-      {pickFor && !picker.isLoading && !autoAddRecipe && (
+      {pickFor && !pickFor.quick && !picker.isLoading && !autoAddRecipe && (
         <RecipePickerDialog
           mode={pickFor.mode}
           goodDisplay={res?.display?.[pickFor.name] ?? pickFor.name}

docs/guide/blocks.md

@@ -56,7 +56,10 @@ remain unsourced. Right-click an import to jump to the blocks that do produce it
 ## Add recipes
 
 Select a positive goal icon to open **Recipes that make _goal_**. A negative consume goal
-instead opens **Recipes that consume _goal_**. Within a recipe row:
+instead opens **Recipes that consume _goal_**. Ctrl+Click (or Command+Click) a goal icon to
+immediately add its highest-ranked currently unlocked recipe. This shortcut uses the same
+logistic-cost ordering as the picker and ignores barrel fill/empty recipes. Within a recipe
+row:
 
 - Select an ingredient chip to find recipes that make that ingredient.
 - Select a product chip to find recipes that consume that product.