fix(solver): byproduct consumers no longer let the plan import-and-restructure

The block-27 failure: adding a consumer for an exported byproduct could
REWRITE the plan. grade-2-crush (a reprocessor) let the LP import
15.4/s grade-2-iron and shut the mine off entirely — cheaper by
machine-seconds, absurd by intent — because the byproduct was a free
good (importable). And a pyvoid did nothing at all: it produces
nothing the objective wants, so it idled at 0 with the export intact.

Three-part fix:

1. The consume-gesture (adding a consumer via a byproduct's chip) now
   marks the good MADE — imports forbidden, so a reprocessor can only
   eat the in-block surplus. On the real block 27: mining trims 58→39
   (recycling legitimately reduces ore demand) instead of dying.

2. New DRAIN pin (net = 0 on the item): the byproduct-disposal
   primitive. Set automatically when the added consumer is a pure sink
   (no products, or only returning less of the same good — the pyvoid
   shape, classified from data). Forces the sink to absorb exactly the
   surplus; coexisting demand-driven consumers are unaffected. Flows
   through temp expansion, diagnosis provenance (with a one-click
   'allow export instead'), snapshot diffs, rename migrations, the pin
   dialog, and the row badge.

3. importedProducible: the solve reports imports of goods an enabled
   in-block recipe produces — the tell-tale of the trap arising any
   other way (search-adds, manual unmarks) — and the import chip
   offers one click to claim the good in-block.

Also hardens e2e: the deps spec scoped its clicks to the sidebar (its
page-wide button match could hit the nav's Undo button, whose
accessible name embeds the last-edited block's name — a mutating
control on the user's real DB; luckily the click never fired) and
waits for hydration before typing.

Refs #91

Author: ApocDev

app/e2e/deps.e2e.ts

@@ -10,13 +10,25 @@ const NONSENSE = "zzz-no-such-thing-e2e";
 test("deps explorer walks requires / required-by for a good", async ({ page }) => {
   await page.goto("/deps");
   await expect(page.getByText("Nothing selected")).toBeVisible();
+  // wait for hydration before typing — a fill that lands on SSR'd markup is
+  // wiped when React mounts, leaving the search silently empty
+  await page.waitForFunction(() => {
+    const nav = document.querySelector("nav");
+    return !!nav && Object.keys(nav).some((k) => k.startsWith("__reactFiber$"));
+  });
 
   // pick a root from the sidebar search (iron plate exists in vanilla and Py alike)
   const search = page.getByPlaceholder("search goods & recipes…");
   await search.fill("iron plate");
-  const first = page.getByRole("button", { name: /iron plate/i }).first();
+  // Scope the click to the SIDEBAR results. A page-wide button match is a
+  // booby trap on the read-only suite: the nav's Undo button embeds the last
+  // edited block's NAME in its accessible name ("Undo: Edit block \"Iron
+  // plate\"") — a loose .first() can click a mutating control on the user's
+  // real database. Never match buttons globally by data-derived names here.
+  const sidebar = page.locator("aside");
+  const first = sidebar.getByRole("button", { name: /iron plate/i }).first();
   try {
-    await first.waitFor({ state: "visible", timeout: 5000 });
+    await first.waitFor({ state: "visible", timeout: 15000 }); // first search builds the whole deps graph server-side
   } catch {
     test.skip(true, "no 'iron plate' in the active project DB");
   }

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

@@ -147,6 +147,27 @@ export function BalanceCard({
                             )}
                           </div>
                         );
+                      if (prov.type === "drain")
+                        return (
+                          <div key={mi} className="flex flex-wrap items-center gap-1.5">
+                            <span>
+                              surplus of {res.display?.[prov.item] ?? prov.item} must be consumed
+                              here (drain)
+                              {short}
+                            </span>
+                            <button
+                              onClick={() => {
+                                doc.clearDrains(prov.item);
+                                doc.note(
+                                  `Stop draining "${res.display?.[prov.item] ?? prov.item}"`,
+                                );
+                              }}
+                              className="bg-warning/25 px-1.5 py-0.5 text-sm text-warning hover:brightness-110"
+                            >
+                              allow export instead
+                            </button>
+                          </div>
+                        );
                       // pin members: name the recipe + offer one-click removal
                       const label =
                         prov.type === "pin-share"
@@ -290,6 +311,21 @@ export function BalanceCard({
                         {/* Locked-as-block-driver state (set via right-click → "Size block by this
                             input"): edit its rate inline + an unlock control. The toggle itself
                             lives in the context menu, so non-locked rows stay uncluttered. */}
+                        {/* the block imports this while an in-block recipe
+                            produces it — usually the import-instead-of-make
+                            trap (block 27); one click claims it in-block */}
+                        {res.importedProducible?.includes(f.name) && (
+                          <button
+                            title="an enabled recipe in this block produces this good, but the plan imports it. Click to mark it made in-block (production must cover consumption)."
+                            onClick={() => {
+                              doc.markMade(f.name);
+                              doc.note(`Mark "${res.display?.[f.name] ?? f.name}" made in-block`);
+                            }}
+                            className="bg-warning/25 px-1.5 py-0.5 text-sm text-warning hover:brightness-110"
+                          >
+                            made here? · make in-block
+                          </button>
+                        )}
                         {lockedInput === f.name && (
                           <>
                             <Input

app/src/components/block/doc-store.ts

@@ -357,27 +357,36 @@ export function createBlockDocStore() {
         next.delete(name);
         return { made: next, dispositions: {} };
       }),
-    /** Set/replace a row pin: one count-or-cap pin per recipe, one share pin
-     * per (recipe, item) edge. */
+    /** Set/replace a row pin: one count-or-cap pin per recipe, one edge pin
+     * (share OR drain) per (recipe, item). */
     setPin: (pin: DocPin) =>
-      edit((s) => ({
-        pins: [
-          ...s.pins.filter((p) =>
-            pin.kind === "share"
-              ? !(p.kind === "share" && p.recipe === pin.recipe && p.item === pin.item)
-              : !(p.kind !== "share" && p.recipe === pin.recipe),
+      edit((s) => {
+        const isEdge = (p: DocPin) => p.kind === "share" || p.kind === "drain";
+        return {
+          pins: [
+            ...s.pins.filter((p) =>
+              isEdge(pin)
+                ? !(isEdge(p) && p.recipe === pin.recipe && p.item === pin.item)
+                : !(!isEdge(p) && p.recipe === pin.recipe),
+            ),
+            pin,
+          ],
+        };
+      }),
+    /** Remove every drain pin on a good (from the IIS card's one-click fix). */
+    clearDrains: (item: string) =>
+      edit((s) => ({ pins: s.pins.filter((p) => !(p.kind === "drain" && p.item === item)) })),
+    clearPin: (recipe: string, edge?: { item: string }) =>
+      edit((s) => {
+        const isEdge = (p: DocPin) => p.kind === "share" || p.kind === "drain";
+        return {
+          pins: s.pins.filter((p) =>
+            edge
+              ? !(isEdge(p) && p.recipe === recipe && p.item === edge.item)
+              : !(!isEdge(p) && p.recipe === recipe),
           ),
-          pin,
-        ],
-      })),
-    clearPin: (recipe: string, share?: { item: string }) =>
-      edit((s) => ({
-        pins: s.pins.filter((p) =>
-          share
-            ? !(p.kind === "share" && p.recipe === recipe && p.item === share.item)
-            : !(p.kind !== "share" && p.recipe === recipe),
-        ),
-      })),
+        };
+      }),
     // Planned spoil loss (#20): rate == null (or <= 0) clears the plan.
     setSpoilRate: (name: string, rate: number | null) =>
       edit((s) => ({

app/src/components/block/pin-dialog.tsx

@@ -39,6 +39,10 @@ export function PinDialog({
     (p): p is { kind: "share"; recipe: string; item: string; share: number } =>
       p.kind === "share" && p.recipe === recipe,
   );
+  const drainPins = pins.filter(
+    (p): p is { kind: "drain"; recipe: string; item: string } =>
+      p.kind === "drain" && p.recipe === recipe,
+  );
   const display = res?.recipeDisplay?.[recipe] ?? recipe;
   const row = res?.rows.find((r) => r.recipe === recipe);
   const [kind, setKind] = useState<"count" | "cap">(rowPin?.kind ?? "count");
@@ -174,6 +178,25 @@ export function PinDialog({
                   route
                 </Button>
               </div>
+              {drainPins.length > 0 && (
+                <div className="mt-1 flex flex-col gap-0.5 text-muted-foreground">
+                  {drainPins.map((p) => (
+                    <span key={p.item} className="flex items-center gap-1.5">
+                      drains all surplus {label(p.item)} (nothing exports)
+                      <button
+                        onClick={() => {
+                          doc.clearPin(recipe, { item: p.item });
+                          doc.note(`Stop draining "${label(p.item)}" into "${display}"`);
+                          onClose();
+                        }}
+                        className="text-muted-foreground underline hover:text-foreground"
+                      >
+                        clear
+                      </button>
+                    </span>
+                  ))}
+                </div>
+              )}
               {sharePins.length > 0 && (
                 <div className="mt-1 flex flex-col gap-0.5 text-muted-foreground">
                   {sharePins.map((p) => (

app/src/components/block/recipe-row.tsx

@@ -91,7 +91,8 @@ export function RecipeRow({
   ) as { kind: "count" | "cap"; count: number } | undefined;
   const shareCount = useStore(
     doc.store,
-    (s) => s.pins.filter((p) => p.kind === "share" && p.recipe === name).length,
+    (s) =>
+      s.pins.filter((p) => (p.kind === "share" || p.kind === "drain") && p.recipe === name).length,
   );
   // v2 solver (#91): rates are ≥ 0 by construction. A row at exactly 0 is
   // idle — nothing in the block pulls it (not an error; often a parked option).

app/src/db/schema.ts

@@ -450,6 +450,9 @@ export type BlockData = {
   pins?: (
     | { kind: "count" | "cap"; recipe: string; count: number }
     | { kind: "share"; recipe: string; item: string; share: number; base?: "total" | "remaining" }
+    // drain: this recipe absorbs the item's surplus (net = 0 on the item) —
+    // the byproduct-disposal gesture; the recipe names the designated sink
+    | { kind: "drain"; recipe: string; item: string }
   )[];
   machines?: Record<string, string>; // recipe → chosen machine
   fuels?: Record<string, string>; // recipe → chosen fuel

app/src/lib/block-diff.ts

@@ -129,11 +129,13 @@ export function diffBlockDocs(from: BlockData, to: BlockData): BlockDiff {
   }
   // pins (#91): keyed per recipe(+item for shares); value compared structurally
   const pinKey = (p: NonNullable<BlockData["pins"]>[number]) =>
-    p.kind === "share" ? `${p.recipe} « ${p.item}` : p.recipe;
+    p.kind === "share" || p.kind === "drain" ? `${p.recipe} « ${p.item}` : p.recipe;
   const pinVal = (p: NonNullable<BlockData["pins"]>[number]) =>
     p.kind === "share"
       ? `${Math.round(p.share * 100)}%${p.base === "total" ? " of total" : ""}`
-      : `${p.kind} ${p.count}`;
+      : p.kind === "drain"
+        ? "drains surplus"
+        : `${p.kind} ${p.count}`;
   const pinsA = Object.fromEntries((from.pins ?? []).map((p) => [pinKey(p), pinVal(p)]));
   const pinsB = Object.fromEntries((to.pins ?? []).map((p) => [pinKey(p), pinVal(p)]));
   const pins = diffMap(pinsA, pinsB);

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

@@ -455,10 +455,33 @@ function Block({ blockId }: { blockId: number }) {
     doc.addRecipe(name);
     // Adding a producer via an item's chip is the linking gesture (#91): the
     // block now claims in-block production for that item. Goal items skip the
-    // mark (a goal already links itself); consume-mode adds (routing a
-    // byproduct) and search-adds never link anything implicitly.
+    // mark (a goal already links itself); search-adds never link implicitly.
     if (pickFor?.mode === "produce" && !goals.some((g) => g.name === pickFor.name))
       doc.markMade(pickFor.name);
+    // Adding a CONSUMER via a byproduct's chip means "deal with MY surplus":
+    // mark the good made — without this, a reprocessing recipe lets the plan
+    // IMPORT the byproduct and shut down the real producers (the block-27
+    // failure). A reprocessor then absorbs surplus on its own (recycling is
+    // cheaper than making more). A pure SINK (void: no products, or only
+    // returning less of the same good) makes nothing the objective wants, so
+    // it also gets a drain pin — "this good's surplus must be consumed here"
+    // (net = 0) — or it would idle at 0 with the export untouched.
+    if (pickFor?.mode === "consume") {
+      const good = pickFor.name;
+      if (!goals.some((g) => g.name === good)) doc.markMade(good);
+      const cand = picker.data?.find((c) => c.name === name);
+      const intake = cand?.ingredients
+        .filter((c) => c.name === good)
+        .reduce((s, c) => s + (c.amount ?? 0), 0);
+      const sameGoodOut = cand?.products
+        .filter((c) => c.name === good)
+        .reduce((s, c) => s + (c.amount ?? 0), 0);
+      const isSink =
+        cand != null &&
+        (cand.products.length === 0 ||
+          (cand.products.every((c) => c.name === good) && (sameGoodOut ?? 0) < (intake ?? 0)));
+      if (isSink) doc.setPin({ kind: "drain", recipe: name, item: good });
+    }
     // label the save for the undo stack — the picker rows carry the display name
     const display = picker.data?.find((c) => c.name === name)?.display;
     doc.note(`Add recipe "${display ?? name}"`);

app/src/server/block-compute.server.ts

@@ -24,7 +24,9 @@ import { migrateToLpInput } from "../solver/migrate";
  * per-building craft rate, so module/beacon changes re-derive the rate. */
 export type DocPin =
   | { kind: "count" | "cap"; recipe: string; count: number }
-  | { kind: "share"; recipe: string; item: string; share: number; base?: "total" | "remaining" };
+  | { kind: "share"; recipe: string; item: string; share: number; base?: "total" | "remaining" }
+  /** this recipe absorbs the item's surplus (net = 0) — byproduct disposal */
+  | { kind: "drain"; recipe: string; item: string };
 import { computeEffects, type BeaconConfig } from "./effects";
 import { resolveLogistics, rowLogistics } from "../lib/logistics";
 import { prodScaledAmount } from "../lib/productivity";
@@ -609,7 +611,13 @@ export async function computeBlock(rawData: SolveInput) {
     return speed / Math.max(1e-9, def.energyRequired ?? 0.5);
   };
   const pins: Pin[] = [];
+  // drain pins constrain the ITEM (net = 0), not a recipe rate — collected
+  // separately; the recipe on the pin is provenance for the UI badge
+  const drains = [
+    ...new Set((data.pins ?? []).flatMap((p) => (p.kind === "drain" ? [p.item] : []))),
+  ];
   for (const p of data.pins ?? []) {
+    if (p.kind === "drain") continue;
     if (p.kind === "share") {
       pins.push({ kind: "share", item: p.item, recipe: p.recipe, share: p.share, base: p.base });
       continue;
@@ -660,7 +668,7 @@ export async function computeBlock(rawData: SolveInput) {
   // goods with selector pseudo-recipes — a pure input transformation; the LP
   // core is untouched. `fold` maps synthetic goods/recipes back for display.
   const { input: expandedInput, fold } = expandTemps(
-    { goals, recipes: compose.parentDefs, made: parentMade, pins: compose.parentPins },
+    { goals, recipes: compose.parentDefs, made: parentMade, pins: compose.parentPins, drains },
     defaultTemp,
   );
   const lpInput: LpBlockInput = expandedInput;
@@ -1033,6 +1041,19 @@ export async function computeBlock(rawData: SolveInput) {
   const fuelItems = [...fuelTotals.keys()]; // for the 🔥 tag in the UI
   const burntItems = [...burntTotals.keys()]; // ash / depleted cells from burning
 
+  // Imports of a good some enabled recipe IN THIS BLOCK produces — the
+  // tell-tale of a plan importing instead of making (a free byproduct + a
+  // reprocessing recipe lets the LP import the byproduct and idle the real
+  // producers). The chip offers one click to mark the good made.
+  const inBlockProducerGoods = new Set(
+    compose.parentDefs.flatMap((d) =>
+      d.products.flatMap((p) => (p.amount > 0 ? [fold.bare(p.name)] : [])),
+    ),
+  );
+  const importedProducible = imports
+    .map((f) => f.name)
+    .filter((n) => inBlockProducerGoods.has(n) && !n.startsWith("pyops-"));
+
   // Which imports are craftable in-block (a recipe exists to make them) vs. true
   // raws (nothing produces them — you must supply them). Drives the import tint.
   const producible = imports
@@ -1164,6 +1185,8 @@ export async function computeBlock(rawData: SolveInput) {
     display,
     recipeDisplay,
     producible,
+    // imports the block could be making itself (see above) — chip warning + fix
+    importedProducible,
     // the block's effective made set (explicit or migrated) — the editor
     // hydrates this into legacy docs so the next save persists it
     made,

app/src/server/migrations.ts

@@ -106,7 +106,7 @@ export function applyRenames(
     // item for shares) — a prototype rename must follow them all
     made: d.made?.map(good),
     pins: d.pins?.map((p) =>
-      p.kind === "share"
+      p.kind === "share" || p.kind === "drain"
         ? { ...p, recipe: recipe(p.recipe), item: good(p.item) }
         : { ...p, recipe: recipe(p.recipe) },
     ),