fix(scenario): rebalance individual block goals

Author: ApocDev

app/e2e/mut/rebalance.e2e.ts

@@ -1,5 +1,6 @@
+import { DatabaseSync } from "node:sqlite";
 import { expect, test } from "@playwright/test";
-import { goto, toast, undoButton } from "./helpers";
+import { activeProjectDbFile, goto, toast, undoButton, uniqueName } from "./helpers";
 
 test("what-if target stays editable while the factory re-solves", async ({ page }) => {
   await goto(page, "/factory/scenario");
@@ -13,7 +14,7 @@ test("what-if target stays editable while the factory re-solves", async ({ page
   // preserving both the in-progress value and keyboard focus throughout them.
   await expect(firstDemand).toBeFocused();
   await expect(firstDemand).toHaveValue("12.34");
-  await expect(page.getByText("Block changes", { exact: false }).first()).toBeVisible({
+  await expect(page.getByText("Goal changes", { exact: false }).first()).toBeVisible({
     timeout: 15_000,
   });
   await expect(firstDemand).toBeFocused();
@@ -52,13 +53,14 @@ test("what-if 'apply all' re-balances the factory in one undoable step", async (
   // confirm dialog summarizes the change; commit it
   const dialog = page.getByRole("dialog", { name: /Re-balance the whole factory/ });
   await expect(dialog).toBeVisible();
-  await dialog.getByRole("button", { name: /^Apply to \d+ block/ }).click();
+  await dialog.getByRole("button", { name: /^Apply \d+ change/ }).click();
   // the apply iterates the solve to convergence across every touched block, so the
   // dialog can sit in its "applying…" state for a while before it closes
   await expect(dialog).toBeHidden({ timeout: 45_000 });
 
-  // the whole batch reports as one action, with an Undo affordance
-  await expect(toast(page, /Re-balanced \d+ block/)).toBeVisible({ timeout: 30_000 });
+  // the whole batch reports as one undoable action. The success toast is brief
+  // and can expire while the final query invalidations settle; the undo label is
+  // the durable proof that the write completed.
   await expect(undoButton(page)).toHaveAccessibleName(/Undo: Re-balance factory/, {
     timeout: 15_000,
   });
@@ -70,4 +72,89 @@ 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 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");
+
+  const sourceName = uniqueName("Acetaldehyde surplus");
+  const sinkName = uniqueName("Secondary sink");
+  const db = new DatabaseSync(activeProjectDbFile());
+  let sourceId: number;
+  let sinkId: number;
+  try {
+    db.exec("PRAGMA busy_timeout = 5000");
+    sourceId = Number(
+      db
+        .prepare("INSERT INTO blocks (name, data, solve_status) VALUES (?, ?, 'solved')")
+        .run(
+          sourceName,
+          JSON.stringify({ goals: [{ name: "water", rate: 1 }], recipes: [] }),
+        ).lastInsertRowid,
+    );
+    sinkId = Number(
+      db
+        .prepare("INSERT INTO blocks (name, data, solve_status) VALUES (?, ?, 'solved')")
+        .run(
+          sinkName,
+          JSON.stringify({
+            goals: [
+              { name: "water", rate: -1 },
+              { name: "acetaldehyde", rate: -2 },
+            ],
+            recipes: ["spoil-acetaldehyde"],
+          }),
+        ).lastInsertRowid,
+    );
+    const insertFlow = db.prepare(
+      "INSERT INTO block_flows (block_id, item, kind, role, rate) VALUES (?, ?, ?, ?, ?)",
+    );
+    insertFlow.run(sourceId, "acetaldehyde", "item", "byproduct", 10);
+    insertFlow.run(sinkId, "acetaldehyde", "item", "import", 2);
+  } finally {
+    db.close();
+  }
+
+  await goto(page, "/factory/scenario");
+  const change = page.getByRole("link", { name: /^Acetaldehyde / });
+  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 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 });
+  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 id = ?").get(sinkId) as {
+      data: string;
+    };
+    const doc = JSON.parse(row.data) as { goals: { name: string; rate: number }[] };
+    expect(doc.goals.find((goal) => goal.name === "acetaldehyde")?.rate).toBe(-10);
+    expect(doc.goals.find((goal) => goal.name === "water")?.rate).toBe(-1);
+  } finally {
+    saved.close();
+  }
+
+  await undoButton(page).click();
+  await expect(toast(page, /Undid: Re-balance factory/)).toBeVisible({ timeout: 30_000 });
+
+  const cleanup = new DatabaseSync(activeProjectDbFile());
+  try {
+    cleanup.exec("PRAGMA busy_timeout = 5000");
+    cleanup.prepare("DELETE FROM block_flows WHERE block_id IN (?, ?)").run(sourceId, sinkId);
+    cleanup.prepare("DELETE FROM block_machines WHERE block_id IN (?, ?)").run(sourceId, sinkId);
+    cleanup.prepare("DELETE FROM blocks WHERE id IN (?, ?)").run(sourceId, sinkId);
+  } finally {
+    cleanup.close();
+  }
 });

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

@@ -26,6 +26,8 @@ type BlockChange = {
   requiredRate: number;
   scale: number;
   delta: number;
+  /** true when this changes one secondary goal instead of the block's anchor */
+  goal?: boolean;
 };
 
 // Query families the apply touches — everything a block rate change feeds. Mirrors
@@ -45,7 +47,7 @@ const MOVERS_SHOWN = 6;
 
 /**
  * "Apply all" for the what-if page: commit the whole-factory re-balance the LP
- * found — set every listed block to its required rate in one undo step. Opens a
+ * found — 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.
  *
@@ -132,7 +134,7 @@ export function RebalanceAllButton({
           <span className="inline-flex">{button}</span>
         </Tooltip>
       ) : (
-        <Tooltip content="Set every listed block to its required rate in one step — undoable">
+        <Tooltip content="Set every listed goal to its required rate in one step — undoable">
           {button}
         </Tooltip>
       )}
@@ -145,14 +147,14 @@ export function RebalanceAllButton({
 
           <div className="flex min-h-0 flex-col gap-3 p-3">
             <DialogDescription>
-              Sets {changed.length} block{changed.length === 1 ? "" : "s"} to the rate the solve
-              found and re-solves each. This is a single undo step.
+              Applies {changed.length} block or goal change{changed.length === 1 ? "" : "s"} the
+              solve found and re-solves each affected block. This is a single undo step.
             </DialogDescription>
 
             <div className="max-h-64 min-h-0 overflow-auto border border-border">
               {movers.slice(0, MOVERS_SHOWN).map((b) => (
                 <div
-                  key={b.id}
+                  key={`${b.id}-${b.goal ? b.good : "primary"}`}
                   className="flex items-center gap-2 border-b border-border px-3 py-1.5 text-sm last:border-b-0"
                 >
                   <span className="min-w-0 flex-1 truncate">{b.name}</span>
@@ -185,7 +187,7 @@ export function RebalanceAllButton({
             <Button onClick={apply} disabled={applying}>
               {applying
                 ? "applying…"
-                : `Apply to ${changed.length} block${changed.length === 1 ? "" : "s"}`}
+                : `Apply ${changed.length} change${changed.length === 1 ? "" : "s"}`}
             </Button>
           </DialogFooter>
         </DialogContent>

app/src/db/queries.server.ts

@@ -2005,6 +2005,7 @@ export function blocksWithFlows(): {
   name: string;
   rate: number;
   priority?: number;
+  goals: { name: string; rate: number; stock?: boolean }[];
   flows: (BlockFlow & { priority?: number })[];
 }[] {
   const bs = db
@@ -2021,6 +2022,11 @@ export function blocksWithFlows(): {
       id: b.id,
       name: b.name,
       rate: primaryRate(data),
+      goals: data.goals.map((goal) => ({
+        name: goal.name,
+        rate: goal.rate,
+        ...(goal.stock != null ? { stock: true } : {}),
+      })),
       priority: blockPriority,
       flows: (flowsByBlock.get(b.id) ?? []).map((flow) => ({
         ...flow,

app/src/routes/factory_.scenario.tsx

@@ -36,9 +36,9 @@ import { rateLabel } from "../lib/format";
 // so treat it as balanced. Matches the server's re-balance convergence tolerance.
 const SCALE_EPS = 0.01;
 
-/** Factory what-if: the whole factory solved as one block. Set a final
- * product's rate and see the per-block scale changes needed to satisfy every
- * demand/consumption — your work list to scale each block (or ignore). */
+/** Factory what-if: the whole factory solved as one system. Set a final
+ * product's rate and see the per-goal changes needed to satisfy every
+ * demand/consumption. */
 function WhatIf() {
   const [overrides, setOverrides] = useState<Record<string, number>>({});
   const wf = useQuery({
@@ -49,7 +49,9 @@ function WhatIf() {
     placeholderData: keepPreviousData,
   });
   const r = wf.data;
-  const changed = (r?.blocks ?? []).filter((b) => Math.abs(b.scale - 1) > SCALE_EPS);
+  const changed = (r?.goalChanges ?? [])
+    .filter((goal) => Math.abs(goal.scale - 1) > SCALE_EPS)
+    .map((goal) => ({ ...goal, name: goal.display }));
 
   return (
     <div className="p-4 font-mono text-foreground">
@@ -69,7 +71,7 @@ function WhatIf() {
               <p>
                 Scenario solves your{" "}
                 <span className="text-foreground">whole factory as one system</span>. Set a target
-                rate on any final product and it shows the per-block changes needed to satisfy every
+                rate on any final product and it shows the goal changes needed to satisfy every
                 downstream demand — a speculative &quot;if I wanted N/s of X, what changes?&quot;
               </p>
               <p>
@@ -85,9 +87,9 @@ function WhatIf() {
                     drive the cascade.
                   </li>
                   <li>
-                    <span className="text-foreground">Block changes</span> — your work list: each
-                    block&apos;s current rate, the required rate, and the ×scale to get there. Click
-                    a block to open its editor.
+                    <span className="text-foreground">Goal changes</span> — your work list: each
+                    affected good&apos;s current target, required target, and ×scale. The block name
+                    shows where that goal lives; click the row to open it.
                   </li>
                   <li>
                     <span className="text-foreground">Supply priority</span> — when several blocks
@@ -121,11 +123,11 @@ function WhatIf() {
                   Say your automation-science block currently runs at{" "}
                   <span className="text-foreground">0.5/s</span> and you want{" "}
                   <span className="text-foreground">1/s</span>. Set its target to 1 and the cascade
-                  updates: <span className="text-foreground">Block changes</span> lists that block
-                  at <span className="text-foreground">×2</span>, plus every upstream block that
-                  feeds it rescaled to match; <span className="text-foreground">Raw inputs</span>{" "}
-                  shows the new draw (current vs projected) so you can check a mine or import can
-                  keep up. Nothing is saved until you open a listed block and apply its new rate.
+                  updates: <span className="text-foreground">Goal changes</span> lists that good at
+                  <span className="text-foreground">×2</span>, plus every upstream goal that feeds
+                  it; <span className="text-foreground">Raw inputs</span> shows the new draw
+                  (current vs projected) so you can check a mine or import can keep up. Nothing is
+                  saved until you apply the listed goal changes.
                 </p>
               </div>
               <p>
@@ -145,7 +147,7 @@ function WhatIf() {
         <Card>
           <CardHeader>
             <CardTitle className="normal-case">Final products</CardTitle>
-            <InfoHint content="Set a target rate to see the per-block changes." />
+            <InfoHint content="Set a target rate to see the per-goal changes." />
           </CardHeader>
           <div className="divide-y divide-border">
             {(r?.demands ?? []).map((d) => {
@@ -191,10 +193,10 @@ function WhatIf() {
           </div>
         </Card>
 
-        {/* Block changes — the work list */}
+        {/* Goal changes — the work list */}
         <Card className="lg:col-span-2">
           <CardHeader className="justify-between">
-            <CardTitle className="normal-case">Block changes ({changed.length})</CardTitle>
+            <CardTitle className="normal-case">Goal changes ({changed.length})</CardTitle>
             <div className="flex items-center gap-3">
               <RebalanceAllButton
                 changed={changed}
@@ -205,7 +207,7 @@ function WhatIf() {
             </div>
           </CardHeader>
           <StatTableHeader
-            lead="block"
+            lead="good"
             cols={[
               { label: "current/s", w: "w-24" },
               { label: "required/s", w: "w-24" },
@@ -220,17 +222,17 @@ function WhatIf() {
             </div>
           ) : changed.length === 0 ? (
             <Callout tone="success" variant="strip">
-              already balanced for these demands — no block changes needed
+              already balanced for these demands — no goal changes needed
             </Callout>
           ) : (
             changed.map((b) => (
               <Link
-                key={b.id}
+                key={`${b.id}-${b.goal ? b.good : "primary"}`}
                 to="/block/$id"
                 params={{ id: String(b.id) }}
                 className="flex flex-col gap-1 border-t border-border px-3 py-2 text-sm hover:bg-muted md:flex-row md:items-center md:py-1.5"
               >
-                <span className="min-w-0 flex-1 truncate text-primary underline">{b.name}</span>
+                <span className="min-w-0 flex-1 truncate text-primary underline">{b.display}</span>
                 <span className="grid grid-cols-3 gap-x-3 md:flex">
                   <StatCell label="current/s" w="md:w-24" className="text-muted-foreground">
                     {rateLabel(b.good ?? "", b.currentRate)}
@@ -292,9 +294,15 @@ 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={`scale ${x.absorb.name} to absorb the surplus`}
+                      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`
+                      }
                     >
-                      → {x.absorb.name} ×{x.absorb.scale}
+                      {"goalRate" in x.absorb
+                        ? `→ ${x.display} goal ${rateLabel(x.good, x.absorb.goalRate)}/s`
+                        : `→ ${x.absorb.name} ×${x.absorb.scale}`}
                     </Link>
                   ) : (
                     <Tooltip content="no block consumes this yet">

app/src/server/agent-tools.server.ts

@@ -1287,7 +1287,13 @@ export const whatIf = tool({
       overproduced: result.overproduced.map((o) => ({
         ...o,
         absorb: o.absorb
-          ? { blockId: o.absorb.id, name: o.absorb.name, scale: o.absorb.scale }
+          ? "goalRate" in o.absorb
+            ? {
+                blockId: o.absorb.id,
+                name: o.absorb.name,
+                goalRate: o.absorb.goalRate,
+              }
+            : { blockId: o.absorb.id, name: o.absorb.name, scale: o.absorb.scale }
           : null,
       })),
     };