fix(app): gate recipe availability on a tech's full prerequisite closure, not its own cost

techReachedByScience decided 'is this tech reachable in the horizon?' from
the tech's OWN direct science cost. A tech gated purely through prerequisites
has an empty own cost (e.g. Py's TURD-unlocked `neuron`), and [].every() is
vacuously true — so it read as reachable at ANY tier. That surfaced a tier-5
Simple circuit board recipe (scrondrix, via neuron) as 'available now' in an
automation-science-only horizon, misleading the assistant, the recipe
picker, the deps explorer, and machine/TURD gating.

Gate on the full prerequisite-closure packs instead (memoized per project db,
like the horizon's own target-closure cache). Prune already-researched techs
so a researched prerequisite isn't re-demanded in NOW mode. Verified on the
real py-hard-mode data: with target=Simple circuit board (tier 1), the basic
recipe is available (rank 1) and both higher-tier recipes are needs-research.

Unit tests cover the empty-own-cost gating and the researched-prereq prune.

Author: ApocDev

app/src/db/queries.server.ts

@@ -9,7 +9,7 @@
  */
 import { createHash } from "node:crypto";
 import { and, eq, inArray, isNotNull, sql, type AnyColumn } from "drizzle-orm";
-import { db } from "./index.server.ts";
+import { currentDatabaseFile, db } from "./index.server.ts";
 import {
   recipes,
   recipeIngredients,
@@ -2248,14 +2248,7 @@ export function stackBonuses(): StackBonuses {
   const h = getResearchHorizon();
   const out: StackBonuses = { belt: 0, inserter: 0, bulkInserter: 0 };
   for (const r of db.select().from(techStackBonuses).all()) {
-    if (h.mode !== "future") {
-      const science = db
-        .select({ name: techIngredients.name })
-        .from(techIngredients)
-        .where(eq(techIngredients.technology, r.technology))
-        .all();
-      if (!techReachedByScience(r.technology, science, h)) continue;
-    }
+    if (h.mode !== "future" && !techReachedByScience(r.technology, h)) continue;
     if (r.effect === "belt") out.belt += r.modifier;
     else if (r.effect === "inserter") out.inserter += r.modifier;
     else if (r.effect === "bulk-inserter") out.bulkInserter += r.modifier;
@@ -2279,14 +2272,7 @@ export function productivityBonuses(): ProductivityBonuses {
   const h = getResearchHorizon();
   const out: ProductivityBonuses = { mining: 0, recipes: new Map() };
   for (const r of db.select().from(techProductivityBonuses).all()) {
-    if (h.mode !== "future") {
-      const science = db
-        .select({ name: techIngredients.name })
-        .from(techIngredients)
-        .where(eq(techIngredients.technology, r.technology))
-        .all();
-      if (!techReachedByScience(r.technology, science, h)) continue;
-    }
+    if (h.mode !== "future" && !techReachedByScience(r.technology, h)) continue;
     if (r.recipe === "") out.mining += r.modifier;
     else out.recipes.set(r.recipe, (out.recipes.get(r.recipe) ?? 0) + r.modifier);
   }
@@ -2363,6 +2349,45 @@ function packsForTechs(techs: Set<string>): Set<string> {
   );
 }
 
+/** A tech's full prerequisite closure (techs + the union of their science
+ * packs), memoized per active project db — the tech graph is static data, only
+ * changing on a data re-import (like `_horizonCache`, which caches the target's
+ * closure the same way). File-keyed so a project switch reads the right graph. */
+const _closureCache = new Map<string, Map<string, { techs: Set<string>; packs: Set<string> }>>();
+function techClosure(tech: string): { techs: Set<string>; packs: Set<string> } {
+  const file = currentDatabaseFile();
+  let byTech = _closureCache.get(file);
+  if (!byTech) _closureCache.set(file, (byTech = new Map()));
+  let e = byTech.get(tech);
+  if (!e) {
+    const techs = techPrereqClosure(tech);
+    byTech.set(tech, (e = { techs, packs: packsForTechs(techs) }));
+  }
+  return e;
+}
+
+/** Science packs still missing to reach `tech` under the horizon: the packs of
+ * its prerequisite closure MINUS what's already researched, minus what the
+ * horizon supplies. Empty = reachable. Checking the tech's OWN cost alone was
+ * wrong — a tech gated purely through prerequisites has an empty own cost (e.g.
+ * TURD-unlocked `neuron`), so it vacuously read as reachable at any tier; and in
+ * NOW mode a researched prerequisite shouldn't demand its pack again. */
+function reachMissingPacks(tech: string, h: ResearchHorizon): string[] {
+  if (h.researched.has(tech)) return [];
+  const { techs, packs } = techClosure(tech);
+  // researched techs are prerequisite-closed, so dropping them from the closure
+  // prunes their (already-done) subtrees; only the unresearched frontier's packs
+  // must be supplied. Target mode has no researched set → the full closure.
+  const relevant = h.researched.size ? packsForTechs(setDiff(techs, h.researched)) : packs;
+  return [...relevant].filter((p) => !h.packs.has(p));
+}
+
+function setDiff(a: Set<string>, b: ReadonlySet<string>): Set<string> {
+  const out = new Set<string>();
+  for (const x of a) if (!b.has(x)) out.add(x);
+  return out;
+}
+
 /** The technology that first lets you make a good: among the techs unlocking a
  * recipe that produces it, the lowest-tier one (fewest distinct science packs in
  * its prerequisite closure, ties broken by name). null if it's start-craftable or
@@ -2547,15 +2572,12 @@ export function allSciencePacks(): string[] {
   return packs.sort((a, b) => tier.get(a)! - tier.get(b)! || a.localeCompare(b));
 }
 
-/** A tech is "reached" if explicitly researched, or all its science packs are
- * within your available set (you produce them, so you'll research it in time). */
-function techReachedByScience(
-  tech: string,
-  science: { name: string }[],
-  h: ResearchHorizon,
-): boolean {
-  if (h.researched.has(tech)) return true;
-  return science.every((s) => h.packs.has(s.name));
+/** A tech is "reached" if explicitly researched, or every science pack in its
+ * full prerequisite closure is within your available set (you produce them, so
+ * you'll research it in time). See reachMissingPacks for why the closure — not
+ * the tech's own cost — is the correct gate. */
+function techReachedByScience(tech: string, h: ResearchHorizon): boolean {
+  return reachMissingPacks(tech, h).length === 0;
 }
 
 /** TURD choice state for a sub-tech given current selections:
@@ -2603,14 +2625,14 @@ function computeAvail(
   let research: RecipeAvail["research"];
   let needs: string[] = [];
   if (enabled) research = "enabled";
-  else if (unlocks.some((u) => techReachedByScience(u.tech, u.science, h))) research = "available";
   else {
-    research = "needs-research";
-    needs = [
-      ...new Set(
-        unlocks.flatMap((u) => u.science.map((s) => s.name)).filter((p) => !h.packs.has(p)),
-      ),
-    ];
+    // reachable via ANY unlocking tech; else the missing packs across all of them
+    const missing = unlocks.map((u) => reachMissingPacks(u.tech, h));
+    if (missing.some((m) => m.length === 0)) research = "available";
+    else {
+      research = "needs-research";
+      needs = [...new Set(missing.flat())];
+    }
   }
   const reached = research !== "needs-research";
   // availableNow: a 'pickable' (researched-but-undecided) master counts — picking

app/src/db/queries.test.ts

@@ -15,6 +15,7 @@ import {
   listGroups,
   machineSufficiency,
   productivityBonuses,
+  recipeCandidates,
   saveBlockRow,
   setBlockGroup,
   setBuiltMachines,
@@ -350,3 +351,68 @@ describe("listBlocks health: sink goals need a consumer, not a producer", () =>
     expect(health(bad).unmadeGoals).toEqual(["plate"]);
   });
 });
+
+describe("recipeCandidates availability: prerequisite-gated techs (empty own cost)", () => {
+  const seed = () => {
+    db.run(sql`
+      INSERT INTO items (name, display) VALUES ('circuit','Circuit')
+    `);
+    db.run(sql`
+      INSERT INTO recipes (name, kind, hidden, enabled) VALUES ('circuit-basic','real',0,0),('circuit-exotic','real',0,0)
+    `);
+    db.run(sql`
+      INSERT INTO recipe_products (recipe, idx, kind, name, amount) VALUES
+        ('circuit-basic',0,'item','circuit',1),
+        ('circuit-exotic',0,'item','circuit',1)
+    `);
+    db.run(sql`
+      INSERT INTO technologies (name, display) VALUES ('t-basic','Basic'),('t-exotic','Exotic'),('t-prereq','Prereq')
+    `);
+    db.run(sql`
+      INSERT INTO tech_ingredients (technology, name, amount) VALUES
+        ('t-basic','automation-science-pack',1),
+        ('t-prereq','py-science-pack-1',1)
+    `);
+    // t-exotic has NO own science cost — it's gated purely through its prerequisite
+    db.run(sql`INSERT INTO tech_prerequisites (technology, prerequisite) VALUES ('t-exotic','t-prereq')`);
+    db.run(sql`
+      INSERT INTO tech_unlocks (technology, recipe) VALUES
+        ('t-basic','circuit-basic'),
+        ('t-exotic','circuit-exotic')
+    `);
+  };
+
+  it("a tech with empty own cost is gated by its prerequisites, not vacuously reachable", () => {
+    seed();
+    // the horizon supplies only automation science (the basic tier)
+    setResearchHorizon({ mode: "now", packs: ["automation-science-pack"], researched: [] });
+    const cands = recipeCandidates("circuit", "produce");
+    const basic = cands.find((c) => c.name === "circuit-basic")!;
+    const exotic = cands.find((c) => c.name === "circuit-exotic")!;
+    // basic (automation only) is available now
+    expect(basic.avail.research).toBe("available");
+    expect(basic.avail.availableNow).toBe(true);
+    // exotic's unlocking tech has an EMPTY own cost but its prereq needs
+    // py-science-1 — before the fix [].every() made it vacuously "available"
+    expect(exotic.avail.research).toBe("needs-research");
+    expect(exotic.avail.availableNow).toBe(false);
+    expect(exotic.avail.needs).toContain("py-science-pack-1");
+    // so the basic recipe ranks ABOVE the exotic one
+    expect(cands.findIndex((c) => c.name === "circuit-basic")).toBeLessThan(
+      cands.findIndex((c) => c.name === "circuit-exotic"),
+    );
+  });
+
+  it("a researched prerequisite is not re-demanded (NOW mode)", () => {
+    seed();
+    // you produce only automation science, but t-prereq is already researched →
+    // t-exotic is now reachable (its remaining frontier costs nothing you lack)
+    setResearchHorizon({
+      mode: "now",
+      packs: ["automation-science-pack"],
+      researched: ["t-prereq"],
+    });
+    const exotic = recipeCandidates("circuit", "produce").find((c) => c.name === "circuit-exotic")!;
+    expect(exotic.avail.research).toBe("available");
+  });
+});