fix(solver): a made mark with no producer imports silently, not a nag

Two connected block-page nitpicks:

1. Remove the redundant 'made in this block' strip from the balance
   card — the recipe rows already show what's produced in-block. The
   made set still drives the solve; toggle a good's made state from its
   right-click menu, and the IIS cards still offer 'import it instead'.

2. A made mark whose good nothing in-block produces now degrades
   SILENTLY to an import instead of being reported as unmade. A made
   mark is a soft 'cover this here'; when it can't be honored the
   graceful answer is to import, not to nag in two places at once
   (the case in the screenshot: enriched-water shown both in the 'no
   recipe makes this' strip AND in imports). Only a produce GOAL with
   no producer still earns the 'add a recipe' flag — the user asked
   for that output. The sidebar/editor health tints drop the
   made-no-producer condition to match.

Bonus: this un-deadlocks blocks that migrated a v1 'balance' on an
imported feed into a made mark — block 26 (the fusion chain) went from
artificially infeasible to solved, importing its feeds while the real
temperature mismatch stays flagged by the per-producer temp warnings.

Refs #91

Author: ApocDev

app/e2e/mut/made-links.e2e.ts

@@ -2,51 +2,51 @@ import { expect, test } from "@playwright/test";
 import { createBlock } from "./helpers";
 
 /**
- * The v2 link model (#91): adding a producer through an item's chip marks the
- * item "made in this block" (production covers consumption, imports
- * forbidden); the mark is visible on the balance card's made strip and one
- * click unmarks it — the item flips back to an import and the producer row
- * honestly idles at 0.
+ * The v2 link model (#91): a good's made state is toggled from its right-click
+ * menu (the made set drives the solve but is not shown in a strip — the recipe
+ * rows show what's produced). A made mark with no in-block producer degrades
+ * silently to an import — no warning strip (the #91 nitpick). This drives the
+ * import chip's menu and asserts the good stays an import either way.
  */
-test("chip-adding a producer marks the item made; unmarking flips it back to an import", async ({
-  page,
-}) => {
+test("marking an import made without a producer keeps it a silent import", async ({ page }) => {
   await createBlock(page);
 
-  // goal: iron plate (any solid with a real chain works)
+  // goal: iron plate (a real Py chain); its recipe consumes iron ore, an import
   await page.locator('button[title="add a goal product"]').click();
   const goalDialog = page.getByRole("dialog", { name: "Add a goal product" });
   await goalDialog.getByPlaceholder("search an item or fluid…").fill("iron plate");
   await goalDialog.getByRole("button", { name: "Iron plate", exact: true }).first().click();
   await expect(goalDialog).toBeHidden();
 
-  // producer for the goal itself (goals self-link — no made mark expected)
   await page.locator('button[title^="click to add a recipe that makes this goal"]').click();
   const platePicker = page.getByRole("dialog", { name: /Recipes that make/ });
   await platePicker.getByRole("button", { name: /Iron plate/ }).first().click();
   await expect(platePicker).toBeHidden();
-  await expect(page.getByText("made in this block:")).toBeHidden();
 
-  // the plate recipe consumes iron ore (py.db: iron-plate ← 8 iron-ore),
-  // showing as an import; adding a producer for it is the linking gesture —
-  // the made strip appears with exactly that item
+  const oreImport = page.getByRole("button", { name: /^Iron ore.*(raw input|craftable)/ }).first();
+  await expect(oreImport).toBeVisible();
+
+  // right-click the import → the good menu offers the made gesture
+  await oreImport.click({ button: "right" });
+  const markItem = page.getByRole("menuitem", {
+    name: /Require in-block production|Make in this block/,
+  });
+  await expect(markItem).toBeVisible();
+  await markItem.click();
+
+  // no producer exists for it, so marking made is a non-event: NO "no recipe
+  // makes this" strip, and the good still shows as an import
+  await expect(page.getByText(/No recipe makes/)).toBeHidden();
+  await expect(
+    page.getByRole("button", { name: /^Iron ore.*(raw input|craftable)/ }).first(),
+  ).toBeVisible();
+
+  // the menu now reads "made" — unmarking it back is available and harmless
   await page
     .getByRole("button", { name: /^Iron ore.*(raw input|craftable)/ })
     .first()
-    .click();
-  const ingPicker = page.getByRole("dialog", { name: /Recipes that make/ });
-  await ingPicker.getByRole("button", { name: /Iron ore/ }).first().click();
-  await expect(ingPicker).toBeHidden();
-  await expect(page.getByText("made in this block:")).toBeVisible();
-
-  // unmark via the strip: the mark disappears and the item re-imports (its
-  // producer row stays in the block but idles at 0)
-  await page
-    .getByRole("button", { name: /^Iron ore/, exact: false })
-    .and(page.locator('[title*="Click to unmark"]'))
-    .click();
-  await expect(page.getByText("made in this block:")).toBeHidden();
+    .click({ button: "right" });
   await expect(
-    page.getByRole("button", { name: /^Iron ore.*(raw input|craftable)/ }).first(),
+    page.getByRole("menuitem", { name: /click to import instead/ }),
   ).toBeVisible();
 });

app/e2e/mut/temp-warnings.e2e.ts

@@ -49,8 +49,6 @@ test("fluid-temp mismatch flags the 3000° producer feeding a 4000° generator",
 
   // add b-h (neutron @4000°, satisfies the generator): the dt-he3 mismatch
   // must STAY flagged — one matching producer used to mask it entirely.
-  // Target the generator row's linked ingredient chip: the balance card's
-  // "made in this block" strip also has a Neutron button (it unmarks — #91).
   await page
     .getByRole("button", { name: /^Neutron.*linked/ })
     .first()

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

@@ -1,5 +1,5 @@
 import { useStore } from "@tanstack/react-store";
-import { AlertTriangle, Cloud, Flame, Lock, Plus, Timer, X, Zap } from "lucide-react";
+import { AlertTriangle, Cloud, Flame, Lock, Plus, Timer, Zap } from "lucide-react";
 import { Button } from "#/components/ui/button.tsx";
 import { Callout } from "#/components/ui/callout.tsx";
 import { Card, CardHeader, CardTitle } from "#/components/ui/card.tsx";
@@ -12,7 +12,7 @@ import type { BlockDocStore } from "./doc-store.ts";
 import type { LogiView, SolveResult } from "./solve-view.ts";
 import { fmtW, num } from "./format.ts";
 
-/** The Block balance card: solve status, made-here and planned-spoil strips,
+/** The Block balance card: solve status, the planned-spoil strip,
  * the root-cause (IIS) cards on an infeasible solve, the unmade/temperature
  * warnings, the power line, and the imports/exports chip lists with the
  * sizing-lock controls. */
@@ -53,7 +53,6 @@ export function BalanceCard({
   ) => void;
   onOpenSpoilDialog: (name: string) => void;
 }) {
-  const made = useStore(doc.store, (s) => s.made);
   const spoilRates = useStore(doc.store, (s) => s.spoilRates);
   const spoilables = useSpoilables();
   return (
@@ -67,38 +66,10 @@ export function BalanceCard({
           </span>
         )}
       </CardHeader>
-      {/* Made-here marks (#91) — the block's claimed in-block production. Always
-          visible when any exist (even on an infeasible solve) so a mark can
-          never soft-lock the block: click × to unmark (the item goes free —
-          imports its shortfall, exports its surplus). */}
-      {!!made?.size && (
-        <Callout tone="info" icon={null} className="mx-3 mt-2 px-2 py-1.5">
-          <div className="flex flex-wrap items-center gap-2">
-            <span>made in this block:</span>
-            {[...made]
-              .sort((a, b) => a.localeCompare(b))
-              .map((name) => (
-                <button
-                  key={name}
-                  onClick={() => {
-                    doc.unmark(name);
-                    doc.note(`Unmark "${res?.display?.[name] ?? name}" (import instead)`);
-                  }}
-                  title="production here covers consumption (surplus exports). Click to unmark — the item imports instead."
-                  className="inline-flex items-center gap-1 bg-success/15 px-1.5 py-0.5 text-success ring-1 ring-success/30 hover:brightness-110"
-                >
-                  <Icon
-                    kind={kindOf(name)}
-                    name={name}
-                    size="sm"
-                    title={res?.display?.[name] ?? name}
-                  />
-                  {res?.display?.[name] ?? name} <X className="size-3" />
-                </button>
-              ))}
-          </div>
-        </Callout>
-      )}
+      {/* The made set (#91) drives the solve but isn't listed here — the recipe
+          rows already show what's produced in-block (linked green chips). Toggle
+          a good's made state from its right-click menu; the IIS cards below
+          offer "import it instead" per made item when a block is infeasible. */}
       {/* Planned spoil losses (#20) — always visible when set: the pinned
           surplus never reaches the boundary flows (it rots), so without this
           strip a planned loss would be invisible. */}

app/src/db/queries.server.ts

@@ -1163,14 +1163,12 @@ export function listBlocks() {
     for (const r of blockRecipes)
       for (const p of productsByRecipe.get(r) ?? []) makesInBlock.add(p);
     const unmadeGoals = goalNames(d).filter((g) => goodNames.has(g) && !makesInBlock.has(g));
-    // v2 (#91): made marks whose producer vanished (or was never added) — the
-    // same "unmade" condition the solve reports, derivable here without solving.
-    const unmadeMade = (d.made ?? []).filter((m) => !makesInBlock.has(m));
+    // NB: a made mark with no producer is NOT a health problem (#91 nitpick) — it
+    // degrades silently to an import in the solve, so it doesn't tint the block.
     const health: BlockHealth =
       broken || solveStatus === "infeasible" || solveStatus === "error"
         ? "error"
         : unmadeGoals.length > 0 ||
-            unmadeMade.length > 0 ||
             // stale pre-v2 statuses: the block re-solves (and re-caches) on open
             solveStatus === "relaxed" ||
             solveStatus === "underdetermined"
@@ -1181,7 +1179,6 @@ export function listBlocks() {
       broken,
       health,
       unmadeGoals,
-      unmadeMade,
       // for the delete-block confirm (#83): what the deletion would destroy
       recipeCount: blockRecipes.length,
       goalCount: goalNames(d).length,

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

@@ -514,8 +514,9 @@ function Block({ blockId }: { blockId: number }) {
         : "text-warning";
 
   // Block health for the title tint (mirrors the sidebar verdict): red for broken
-  // refs / infeasible / solver error, amber for unmade goals or made marks /
-  // temperature mismatches, none when clean.
+  // refs / infeasible / solver error, amber for goals with no recipe or
+  // temperature mismatches, none when clean. (A made mark with no producer is
+  // not a warning — it just imports.)
   const editorHealth: "error" | "warn" | null = !res
     ? null
     : res.broken || res.status === "infeasible" || res.status === "error"

app/src/routes/block.tsx

@@ -462,9 +462,7 @@ function Shell() {
         ? "this block has no exact solution — open to fix"
         : b.unmadeGoals.length
           ? `${b.unmadeGoals.length} goal${b.unmadeGoals.length === 1 ? "" : "s"} with no recipe yet — open to add one`
-          : b.unmadeMade.length
-            ? `${b.unmadeMade.length} made-here item${b.unmadeMade.length === 1 ? "" : "s"} with no producer — open to fix`
-            : "this block needs attention — open to see";
+          : "this block needs attention — open to see";
   // worst health among every block in a folder subtree (errors dominate warnings),
   // so a problem nested anywhere bubbles up to the folder header.
   const groupHealth = (groupId: number): Health => {

app/src/solver/lp.test.ts

@@ -216,14 +216,16 @@ test("unmade produce goal is reported, not enforced — the rest still solves",
   expect(rate(res).gear).toBeCloseTo(1);
 });
 
-test("made mark with no producer is reported and dropped, consumers keep running", async () => {
+test("made mark with no producer degrades silently to an import (no unmade nag)", async () => {
   const res = await solveBlockLp({
     goals: [{ name: "gear", rate: 1 }],
     recipes: [gear],
     made: ["plate"], // no plate producer in the block
   });
   expect(res.status).toBe("solved");
-  expect(res.unmade).toEqual(["plate"]);
+  // a made mark that can't be honored just imports — NOT reported as unmade
+  // (only a produce goal with no producer earns that flag)
+  expect(res.unmade).toBeUndefined();
   expect(flow(res.imports, "plate")).toBeCloseTo(2);
 });
 

app/src/solver/lp.ts

@@ -88,9 +88,11 @@ export type LpBlockResult = {
   recipes: { recipe: string; rate: number; machines1x: number }[];
   imports: Flow[];
   exports: Flow[];
-  /** produce goals nothing in-block makes, and `made` items with no producer.
-   * Their constraints are dropped (reported, not enforced) so the rest of the
-   * block still solves — the UI flags exactly these with "add a producer". */
+  /** produce goals nothing in-block makes — the constraint is dropped (reported,
+   * not enforced) so the rest of the block still solves and the UI flags exactly
+   * these with "add a recipe". A `made` mark with no producer is NOT listed here:
+   * it degrades silently to an import (a mark that can't be honored is a
+   * non-event, not a warning). */
   unmade?: string[];
   /** whole-machine mode (#98): recipe → integer building count (the ceiling
    * the solve committed to; the recipe's rate may leave it partly idle) */
@@ -187,7 +189,11 @@ export function buildModel(input: LpBlockInput): BlockModel {
     const c = coeff[item];
     if (!c) continue; // stale mark on an item nothing touches — inert
     if (!produced[item]) {
-      unmade.push(item); // marked made but no producer: report, don't zero consumers
+      // marked made but nothing in-block produces it: degrade silently to an
+      // import (net < 0). A made mark is a soft "cover this here" — when it
+      // can't be honored the graceful answer is to import, NOT to nag. Only a
+      // GOAL with no producer earns the "add a recipe" flag (the user asked
+      // for that output); a made mark that can't be met is a non-event.
       continue;
     }
     constraints.push({

app/src/solver/temps.test.ts

@@ -41,21 +41,22 @@ test("fluids without ranged consumers pass through untouched", () => {
   expect(fold.isSynthetic("anything")).toBe(false);
 });
 
-test("an out-of-range producer cannot feed a ranged consumer — the pool reads unmade", async () => {
-  // only dt-he3 (3000°) present, generator needs 4000°: with neutron made, the
-  // 4000° pool has no producer → reported unmade; the block imports the pool
-  // (temperature is then the player's problem, stated honestly)
+test("an out-of-range producer cannot feed a ranged consumer — the pool imports", async () => {
+  // only dt-he3 (3000°) present, generator needs 4000°: the 4000° pool has no
+  // in-block producer, so it degrades to an IMPORT (a made mark that can't be
+  // honored is a silent import, #91). The temperature mismatch is surfaced
+  // separately by the per-producer temp warnings, not by a double nag here.
   const { res, fold } = solve(
     [dtHe3, mdh4000],
     [{ name: "pyops-electricity", rate: 9600000 }],
     ["neutron"],
   );
   const r = await res;
   expect(r.status).toBe("solved");
-  const unmade = (r.unmade ?? []).map((u) => `${fold.bare(u)} ${fold.tempOf(u) ?? ""}`.trim());
-  expect(unmade).toContain("neutron 4000°");
-  // nothing pulls dt-he3 (its 3000° output can't feed the generator): it
-  // honestly idles instead of running for an exportable byproduct
+  expect(r.unmade ?? []).toEqual([]); // no unmade nag
+  const imports = r.imports.map((f) => `${fold.bare(f.name)} ${fold.tempOf(f.name) ?? ""}`.trim());
+  expect(imports).toContain("neutron 4000°"); // the generator imports the temp it needs
+  // nothing pulls dt-he3 (its 3000° output can't feed the generator): it idles
   const rates = Object.fromEntries(r.recipes.map((x) => [x.recipe, x.rate]));
   expect(rates["dt-he3"]).toBeCloseTo(0);
 });
@@ -114,14 +115,25 @@ test("a goal on an expanded fluid is satisfied by any temperature, variants stay
     ingredients: [{ kind: "fluid", name: "water", amount: 10, maxTemp: 101 }],
     products: [{ kind: "item", name: "gel", amount: 1 }],
   };
-  const { res, fold } = solve([boil, cold], [{ name: "water", rate: 175 }], ["water"]);
+  // gel is a goal too, so the cold consumer actually runs (needs ≤101° water)
+  const { res, fold } = solve(
+    [boil, cold],
+    [
+      { name: "water", rate: 175 },
+      { name: "gel", rate: 1 },
+    ],
+    ["water"],
+  );
   const r = await res;
   expect(r.status).toBe("solved");
   const rates = Object.fromEntries(r.recipes.map((x) => [x.recipe, x.rate]));
-  expect(rates["boil"]).toBeCloseTo(1); // goal met by the 125° variant
-  // the ≤101° pool has no in-range producer → unmade, its consumer imports
-  const unmade = (r.unmade ?? []).map((u) => `${fold.bare(u)} ${fold.tempOf(u) ?? ""}`.trim());
-  expect(unmade).toContain("water ≤101°");
+  expect(rates["boil"]).toBeCloseTo(1); // water goal met by the 125° variant
+  expect(rates["cold-process"]).toBeCloseTo(1); // gel goal drives the ≤101° draw
+  // the ≤101° pool has no in-range producer → it imports silently (no nag);
+  // the cold consumer draws its ≤101° water from the boundary
+  expect(r.unmade ?? []).toEqual([]);
+  const imports = r.imports.map((f) => `${fold.bare(f.name)} ${fold.tempOf(f.name) ?? ""}`.trim());
+  expect(imports).toContain("water ≤101°");
 });
 
 test("share pins follow the consumer onto its pool", async () => {

app/test-results/.last-run.json

@@ -0,0 +1,4 @@
+{
+  "status": "failed",
+  "failedTests": []
+}