feat(scenario): balance factory iteratively

Keep terminal goals pinned while repeatedly adjusting intermediate production and sink goals against freshly solved block flows. Probe valid zero-rate producers so idle configured chains can start.

Closes #147

Author: ApocDev

app/e2e/mut/rebalance.e2e.ts

@@ -1,9 +1,20 @@
 import { DatabaseSync } from "node:sqlite";
-import { expect, test } from "@playwright/test";
+import { expect, type Page, test } from "@playwright/test";
 import { activeProjectDbFile, goto, toast, undoButton, uniqueName } from "./helpers";
 
+async function dismissDataDriftPrompt(page: Page) {
+  const ignore = page.getByRole("button", { name: "Ignore for now" });
+  try {
+    await expect(ignore).toBeVisible({ timeout: 2_000 });
+    await ignore.click();
+  } catch {
+    // Most seeded runs match the installed mods and have no prompt.
+  }
+}
+
 test("what-if target stays editable while the factory re-solves", async ({ page }) => {
   await goto(page, "/factory/scenario");
+  await dismissDataDriftPrompt(page);
 
   const firstDemand = page.getByRole("spinbutton").first();
   await expect(firstDemand).toBeVisible();
@@ -22,8 +33,8 @@ test("what-if target stays editable while the factory re-solves", async ({ page
 });
 
 /**
- * What-if "Apply all" (whole-factory re-balance): overriding a final product's
- * target surfaces the per-block changes, and Apply all commits every one of them
+ * Applying a Scenario target: overriding a final product's target surfaces the
+ * per-block changes, and Apply scenario commits every one of them
  * in a single undoable step. Drives the real flow end-to-end against the isolated
  * mut server, then undoes the factory-wide change so the shared scratch db is left
  * as it was.
@@ -32,11 +43,12 @@ test("what-if target stays editable while the factory re-solves", async ({ page
  * floor (rounding), so the test forces a genuine change by DOUBLING a demand — far
  * above the floor — rather than depending on the seed happening to be imbalanced.
  */
-test("what-if 'apply all' re-balances the factory in one undoable step", async ({ page }) => {
+test("applying a scenario re-balances the factory in one undoable step", async ({ page }) => {
   // applying + undoing a whole-factory re-balance re-solves every touched block, so
   // give the round trips generous room over the default per-test budget
   test.setTimeout(120_000);
   await goto(page, "/factory/scenario");
+  await dismissDataDriftPrompt(page);
 
   // the Final products card is the only place with numeric (spinbutton) inputs
   const firstDemand = page.getByRole("spinbutton").first();
@@ -45,13 +57,13 @@ test("what-if 'apply all' re-balances the factory in one undoable step", async (
   // 2× + 1 guarantees a real increase even if the current target reads 0
   await firstDemand.fill(String(current * 2 + 1));
 
-  // the doubled demand cascades into real per-block changes → Apply all enables
-  const applyAll = page.getByRole("button", { name: "Apply all" });
+  // the doubled demand cascades into real per-block changes → Apply scenario enables
+  const applyAll = page.getByRole("button", { name: "Apply scenario" });
   await expect(applyAll).toBeEnabled({ timeout: 15_000 });
   await applyAll.click();
 
   // confirm dialog summarizes the change; commit it
-  const dialog = page.getByRole("dialog", { name: /Re-balance the whole factory/ });
+  const dialog = page.getByRole("dialog", { name: /Apply this factory scenario/ });
   await expect(dialog).toBeVisible();
   await dialog.getByRole("button", { name: /^Apply \d+ change/ }).click();
   // the apply iterates the solve to convergence across every touched block, so the
@@ -72,14 +84,68 @@ test("what-if 'apply all' re-balances the factory in one undoable step", async (
   await expect(undoButton(page)).toBeEnabled();
   await undoButton(page).click();
   await expect(toast(page, /Undid: Re-balance factory/)).toBeVisible({ timeout: 30_000 });
+});
+
+test("Scenario can start a valid zero-rate producer", async ({ page }) => {
+  test.setTimeout(120_000);
+  // Tar's current byproducts can eventually cover all Coke demand. Disable that
+  // competing incidental source in the scratch project so this test isolates
+  // the idle configured Coke producer rather than supply substitution.
+  const setup = new DatabaseSync(activeProjectDbFile());
+  const tarEnabled = (setup.prepare("SELECT enabled FROM blocks WHERE id = 38").get() as {
+    enabled: number;
+  }).enabled;
+  try {
+    setup.prepare("UPDATE blocks SET enabled = 0 WHERE id = 38").run();
+  } finally {
+    setup.close();
+  }
 
+  try {
+    await goto(page, "/factory/scenario");
+    await dismissDataDriftPrompt(page);
+
+    const change = page.getByRole("link", { name: /^Coke / });
+    await expect(change).toContainText("0");
+    await expect(change).toContainText("start");
+
+    await page.getByRole("button", { name: "Balance factory", exact: true }).click();
+    const dialog = page.getByRole("dialog", { name: /Balance the whole factory/ });
+    await dialog.getByRole("button", { name: /^Apply \d+ change/ }).click();
+    await expect(dialog).toBeHidden({ timeout: 45_000 });
+    await expect(undoButton(page)).toHaveAccessibleName(/Undo: Re-balance factory/, {
+      timeout: 15_000,
+    });
+
+    const saved = new DatabaseSync(activeProjectDbFile(), { readOnly: true });
+    try {
+      const row = saved.prepare("SELECT data FROM blocks WHERE name = 'Coke'").get() as {
+        data: string;
+      };
+      const doc = JSON.parse(row.data) as { goals: { name: string; rate: number }[] };
+      expect(doc.goals.find((goal) => goal.name === "coke")?.rate).toBeGreaterThan(0);
+    } finally {
+      saved.close();
+    }
+
+    await undoButton(page).click();
+    await expect(toast(page, /Undid: Re-balance factory/)).toBeVisible({ timeout: 30_000 });
+  } finally {
+    const restore = new DatabaseSync(activeProjectDbFile());
+    try {
+      restore.prepare("UPDATE blocks SET enabled = ? WHERE id = 38").run(tarEnabled);
+    } finally {
+      restore.close();
+    }
+  }
 });
 
 test("Scenario applies a secondary consume goal independently", async ({ page }) => {
   test.setTimeout(120_000);
   // Resolve the copied project's existing projections before inserting the two
   // self-contained test blocks and their cached factory boundary flows.
   await goto(page, "/factory/scenario");
+  await dismissDataDriftPrompt(page);
 
   const sourceName = uniqueName("Acetaldehyde surplus");
   const sinkName = uniqueName("Secondary sink");
@@ -120,12 +186,12 @@ test("Scenario applies a secondary consume goal independently", async ({ page })
   }
 
   await goto(page, "/factory/scenario");
-  const change = page.getByRole("link", { name: /^Acetaldehyde / });
+  const change = page.getByRole("link", { name: /^Acetaldehyde -2/ });
   await expect(change).toContainText("-2");
   await expect(change).toContainText("-10");
 
-  await page.getByRole("button", { name: "Apply all" }).click();
-  const dialog = page.getByRole("dialog", { name: /Re-balance the whole factory/ });
+  await page.getByRole("button", { name: "Balance factory", exact: true }).click();
+  const dialog = page.getByRole("dialog", { name: /Balance the whole factory/ });
   await dialog.getByRole("button", { name: /^Apply \d+ change/ }).click();
   await expect(dialog).toBeHidden({ timeout: 45_000 });
   await expect(toast(page, /Re-balanced \d+ block/)).toBeVisible({ timeout: 15_000 });

app/src/components/whatif/rebalance-all-button.tsx

@@ -26,8 +26,10 @@ type BlockChange = {
   requiredRate: number;
   scale: number;
   delta: number;
-  /** true when this changes one secondary goal instead of the block's anchor */
+  /** true when this changes a specific goal instead of an opaque block rate */
   goal?: boolean;
+  /** Starts a valid producer whose current goal is zero. */
+  activation?: boolean;
 };
 
 // Query families the apply touches — everything a block rate change feeds. Mirrors
@@ -46,12 +48,12 @@ const REFRESH_KEYS = [
 const MOVERS_SHOWN = 6;
 
 /**
- * "Apply all" for the what-if page: commit the whole-factory re-balance the LP
- * found — set every listed goal to its required rate in one undo step. Opens a
+ * Commit the whole-factory balance pass — set every listed goal to its
+ * required rate in one undo step. Opens a
  * (non-destructive) confirm summarizing the biggest movers first, since it's a
  * factory-wide write; the result is fully reversible via the undo toast.
  *
- * `status` is the LP solve status: a non-Optimal solve means the target can't be
+ * `status` is the balance status: a non-Optimal result means the target can't be
  * met with the current blocks, so applying its partial result could make things
  * worse — the button disables and says why instead.
  */
@@ -71,6 +73,7 @@ export function RebalanceAllButton({
   const [applying, setApplying] = useState(false);
 
   const notOptimal = status != null && status !== "Optimal";
+  const applyingScenario = Object.keys(overrides).length > 0;
   const disabledReason =
     changed.length === 0
       ? "Nothing to re-balance — every block already meets demand"
@@ -122,7 +125,7 @@ export function RebalanceAllButton({
 
   const button = (
     <Button size="sm" disabled={disabledReason != null || applying} onClick={() => setOpen(true)}>
-      {applying ? "applying…" : "Apply all"}
+      {applying ? "applying…" : applyingScenario ? "Apply scenario" : "Balance factory"}
     </Button>
   );
 
@@ -142,7 +145,9 @@ export function RebalanceAllButton({
       <Dialog open={open} onOpenChange={(o) => !applying && setOpen(o)}>
         <DialogContent className="max-w-lg">
           <DialogHeader>
-            <DialogTitle>Re-balance the whole factory?</DialogTitle>
+            <DialogTitle>
+              {applyingScenario ? "Apply this factory scenario?" : "Balance the whole factory?"}
+            </DialogTitle>
           </DialogHeader>
 
           <div className="flex min-h-0 flex-col gap-3 p-3">
@@ -168,7 +173,7 @@ export function RebalanceAllButton({
                     </span>
                   </span>
                   <span className="w-16 shrink-0 text-right text-muted-foreground tabular-nums">
-                    ×{b.scale}
+                    {b.activation ? "start" : `×${b.scale}`}
                   </span>
                 </div>
               ))}

app/src/routes/factory_.scenario.tsx

@@ -50,7 +50,7 @@ function WhatIf() {
   });
   const r = wf.data;
   const changed = (r?.goalChanges ?? [])
-    .filter((goal) => Math.abs(goal.scale - 1) > SCALE_EPS)
+    .filter((goal) => goal.activation || Math.abs(goal.scale - 1) > SCALE_EPS)
     .map((goal) => ({ ...goal, name: goal.display }));
 
   return (
@@ -77,7 +77,8 @@ function WhatIf() {
               <p>
                 <span className="text-foreground">vs Overview.</span> Overview shows your factory as
                 it is now; Scenario is a sandbox — it doesn&apos;t change anything until you open a
-                block and apply.
+                block, select <span className="text-foreground">Balance factory</span>, or apply an
+                edited scenario.
               </p>
               <div>
                 <div className="font-semibold text-foreground">How to use it</div>
@@ -99,7 +100,8 @@ function WhatIf() {
                   </li>
                   <li>
                     <span className="text-foreground">Raw inputs</span> — what the new target draws
-                    in from outside (current vs projected).
+                    in from outside (current vs projected), including a required good no enabled
+                    block can currently supply.
                   </li>
                   <li>
                     <span className="text-foreground">Overproduced</span> — anything the target
@@ -133,9 +135,9 @@ function WhatIf() {
               <p>
                 <span className="text-foreground">The solve pill</span> (next to this button)
                 reports the whole-factory solve. <span className="text-foreground">Optimal</span>{" "}
-                means it found a consistent set of rates; any other status means the target
-                can&apos;t be met with the current recipes and blocks — treat it as a prompt to add
-                a producer or relax the target, and open the affected block to see why.
+                means it found a settled set of rates; any other status means an affected block
+                became infeasible or the passes did not converge — open those blocks to inspect
+                conflicting goals or pins.
               </p>
             </HelpButton>
           </>
@@ -245,7 +247,7 @@ function WhatIf() {
                     {rateLabel(b.good ?? "", b.requiredRate)}
                   </StatCell>
                   <StatCell label="×scale" w="md:w-20" className="text-muted-foreground">
-                    ×{b.scale}
+                    {b.activation ? "start" : `×${b.scale}`}
                   </StatCell>
                 </span>
               </Link>
@@ -294,15 +296,9 @@ function WhatIf() {
                       to="/block/$id"
                       params={{ id: String(x.absorb.id) }}
                       className="ml-2 bg-muted/60 px-1.5 py-0.5 text-sm text-primary hover:bg-muted"
-                      title={
-                        "goalRate" in x.absorb
-                          ? `change ${x.absorb.name}'s ${x.display} consume goal to absorb the surplus`
-                          : `scale ${x.absorb.name} to absorb the surplus`
-                      }
+                      title={`change ${x.absorb.name}'s ${x.display} consume goal to absorb the surplus`}
                     >
-                      {"goalRate" in x.absorb
-                        ? `→ ${x.display} goal ${rateLabel(x.good, x.absorb.goalRate)}/s`
-                        : `→ ${x.absorb.name} ×${x.absorb.scale}`}
+                      → {x.display} goal {rateLabel(x.good, x.absorb.goalRate)}/s
                     </Link>
                   ) : (
                     <Tooltip content="no block consumes this yet">