feat(scenario): cache results and report solve progress

Persist completed factory scenarios by their effective inputs so route visits can reuse current results. Make recalculation explicit after edits and surface each long-running solver phase without hiding the previous preview.\n\nCloses #156

Author: ApocDev

app/e2e/mut/factory-debug.e2e.ts

@@ -15,15 +15,22 @@ test("Advanced settings captures a structured Scenario solver trace", async ({ p
 
     await page.setViewportSize({ width: 3840, height: 1080 });
     await goto(page, "/factory/scenario");
+    const status = page.getByTestId("scenario-status");
+    await expect(status).toBeVisible();
+    await expect(status).toHaveAttribute("data-state", /^(current|stale|empty|calculating)$/);
+    if (["empty", "calculating"].includes((await status.getAttribute("data-state")) ?? ""))
+      await expect(status).toHaveAttribute("data-state", "current", { timeout: 90_000 });
+    await status.getByRole("button", { name: "Recalculate" }).click();
+    await expect(status).toHaveAttribute("data-state", "current", { timeout: 90_000 });
     await expect(page.getByText("Goal changes", { exact: false }).first()).toBeVisible({
       timeout: 30_000,
     });
     const workspace = await page.getByTestId("scenario-workspace").boundingBox();
     expect(workspace?.width).toBeLessThanOrEqual(1600);
     expect(workspace?.x).toBeGreaterThan(1_000);
-    await expect(page.getByText("Factory use/s", { exact: true })).toBeVisible();
-    await expect(page.getByText("Block output/s", { exact: true })).toBeVisible();
-    await expect(page.getByText("Surplus/s", { exact: true })).toBeVisible();
+    await expect(page.getByText("Factory use/s", { exact: true }).first()).toBeVisible();
+    await expect(page.getByText("Block output/s", { exact: true }).first()).toBeVisible();
+    await expect(page.getByText("Surplus/s", { exact: true }).first()).toBeVisible();
 
     await goto(page, "/settings?tab=advanced");
     await page.getByRole("button", { name: "Refresh" }).click();

app/e2e/mut/rebalance.e2e.ts

@@ -12,6 +12,18 @@ async function dismissDataDriftPrompt(page: Page) {
   }
 }
 
+async function recalculateScenario(page: Page) {
+  const status = page.getByTestId("scenario-status");
+  await expect(status).toBeVisible({ timeout: 30_000 });
+  await expect(status).toHaveAttribute("data-state", /^(current|stale|empty|calculating)$/, {
+    timeout: 30_000,
+  });
+  const state = await status.getAttribute("data-state");
+  if (state === "stale")
+    await status.getByRole("button", { name: "Recalculate" }).click();
+  await expect(status).toHaveAttribute("data-state", "current", { timeout: 90_000 });
+}
+
 test("factory pins can add and persist a consumption target", async ({ page }) => {
   await goto(page, "/factory/scenario");
   await dismissDataDriftPrompt(page);
@@ -24,8 +36,11 @@ test("factory pins can add and persist a consumption target", async ({ page }) =
   const input = page.getByRole("spinbutton", { name: "Acetaldehyde factory pin" });
   await expect(input).toBeVisible();
   await input.fill("-2");
-  await input.blur();
   await expect(input).toHaveValue("-2");
+  await page.getByTestId("scenario-status").getByRole("button", { name: "Recalculate" }).click();
+  await expect(page.getByTestId("scenario-status")).toHaveAttribute("data-state", "current", {
+    timeout: 90_000,
+  });
   await expect
     .poll(() => {
       const db = new DatabaseSync(activeProjectDbFile(), { readOnly: true });
@@ -47,24 +62,55 @@ test("factory pins can add and persist a consumption target", async ({ page }) =
   await expect(persisted).toBeHidden();
 });
 
-test("what-if target stays editable while the factory re-solves", async ({ page }) => {
+test("Scenario target waits for explicit recalculation and reports progress", async ({ page }) => {
+  test.setTimeout(120_000);
   await goto(page, "/factory/scenario");
   await dismissDataDriftPrompt(page);
+  await recalculateScenario(page);
 
   const firstDemand = page.getByRole("spinbutton").first();
   await expect(firstDemand).toBeVisible();
+  const originalTarget = await firstDemand.inputValue();
   await firstDemand.selectText();
   await firstDemand.pressSequentially("12.34", { delay: 100 });
 
-  // Each character starts another solve. The demand list must remain mounted,
-  // 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("Goal changes", { exact: false }).first()).toBeVisible({
-    timeout: 15_000,
-  });
+  // Typing is now a cheap draft: it preserves focus and marks the previous
+  // result stale instead of launching a whole-factory solve per character.
   await expect(firstDemand).toBeFocused();
   await expect(firstDemand).toHaveValue("12.34");
+  const status = page.getByTestId("scenario-status");
+  await expect(status).toHaveAttribute("data-state", "stale");
+  await expect(status).toContainText("Targets or factory inputs changed");
+
+  await status.getByRole("button", { name: "Recalculate" }).click();
+  await expect(status).toHaveAttribute("data-state", "calculating");
+  await expect(status).toContainText(/Preparing|response models|Solving factory|Validating blocks/);
+  await expect(status).toHaveAttribute("data-state", "current", { timeout: 90_000 });
+  await expect(status).toContainText("Scenario is up to date");
+
+  // Restore the shared scratch project's target and its cached result for the
+  // remaining tests in this serial mutating suite.
+  await firstDemand.fill(originalTarget);
+  await expect(status).toHaveAttribute("data-state", "stale");
+  await status.getByRole("button", { name: "Recalculate" }).click();
+  await expect(status).toHaveAttribute("data-state", "current", { timeout: 90_000 });
+});
+
+test("revisiting Scenario reuses the current persisted result", async ({ page }) => {
+  test.setTimeout(120_000);
+  await goto(page, "/factory/scenario");
+  await dismissDataDriftPrompt(page);
+  await recalculateScenario(page);
+  const status = page.getByTestId("scenario-status");
+  const calculatedAt = await status.getAttribute("data-calculated-at");
+  expect(calculatedAt).toBeTruthy();
+
+  await page.getByRole("link", { name: "Connections", exact: true }).click();
+  await expect(page).toHaveURL(/\/factory\/connections$/);
+  await page.getByRole("link", { name: "Scenario", exact: true }).click();
+  await expect(page).toHaveURL(/\/factory\/scenario$/);
+  await expect(status).toHaveAttribute("data-state", "current");
+  await expect(status).toHaveAttribute("data-calculated-at", calculatedAt!);
 });
 
 /**
@@ -84,6 +130,7 @@ test("applying a scenario re-balances the factory in one undoable step", async (
   test.setTimeout(120_000);
   await goto(page, "/factory/scenario");
   await dismissDataDriftPrompt(page);
+  await recalculateScenario(page);
 
   // the Factory pins card is the first place with numeric (spinbutton) inputs
   const firstDemand = page.getByRole("spinbutton").first();
@@ -92,6 +139,11 @@ test("applying a scenario 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));
 
+  await page.getByTestId("scenario-status").getByRole("button", { name: "Recalculate" }).click();
+  await expect(page.getByTestId("scenario-status")).toHaveAttribute("data-state", "current", {
+    timeout: 90_000,
+  });
+
   // 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 });
@@ -171,6 +223,7 @@ test("Scenario zeros an unpinned consume goal without saving the preview", async
 
   try {
     await goto(page, "/factory/scenario");
+    await recalculateScenario(page);
     const change = page.getByRole("link", { name: /^Acetaldehyde / });
     await expect(change).toContainText("-2");
     await expect(change).toContainText("Next goal/s0");
@@ -223,6 +276,7 @@ test("Scenario scales a goal beyond recovered coproduct supply", async ({ page }
   try {
     await goto(page, "/factory/scenario");
     await dismissDataDriftPrompt(page);
+    await recalculateScenario(page);
 
     await expect(page.getByRole("link", { name: /^Creosote / })).toBeVisible({
       timeout: 60_000,
@@ -264,6 +318,7 @@ test("Scenario explains which proposed block goals failed validation", async ({
   try {
     await goto(page, "/factory/scenario");
     await dismissDataDriftPrompt(page);
+    await recalculateScenario(page);
 
     const diagnostic = page.getByTestId("scenario-validation");
     await expect(diagnostic.getByText("Scenario validation failed")).toBeVisible({

app/src/components/whatif/factory-pins-card.tsx

@@ -35,7 +35,7 @@ export function FactoryPinsCard({
     ) => setFactoryPinsFn({ data: rows }),
     onSuccess: async () => {
       await qc.invalidateQueries({ queryKey: ["factoryPins"] });
-      await qc.invalidateQueries({ queryKey: ["whatif"] });
+      await qc.invalidateQueries({ queryKey: ["factoryScenarioSnapshot"] });
     },
   });
   const rows = pins.data ?? [];
@@ -90,12 +90,6 @@ export function FactoryPinsCard({
                     step="0.01"
                     value={value}
                     onChange={(event) => onOverride(pin.good, Number(event.target.value) || 0)}
-                    onBlur={() => {
-                      if (Math.abs(value) <= 1e-9) return;
-                      persist(
-                        rows.map((row) => (row.good === pin.good ? { ...row, rate: value } : row)),
-                      );
-                    }}
                     className="w-24 text-right"
                     aria-label={`${pin.display} factory pin`}
                   />

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

@@ -35,7 +35,7 @@ type BlockChange = {
 // Query families the apply touches — everything a block rate change feeds. Mirrors
 // undo-client's UNDO_QUERY_KEYS (this is a bulk block write) plus the what-if solve.
 const REFRESH_KEYS = [
-  ["whatif"],
+  ["factoryScenarioSnapshot"],
   ["blocks"],
   ["block"],
   ["blocksForGood"],
@@ -59,11 +59,17 @@ export function RebalanceAllButton({
   changed,
   overrides,
   status,
+  previewStale,
+  onProgressStart,
+  onProgressEnd,
   onApplied,
 }: {
   changed: BlockChange[];
   overrides: Record<string, number>;
   status: string | undefined;
+  previewStale: boolean;
+  onProgressStart: (requestId: string) => void;
+  onProgressEnd: () => void;
   onApplied: () => void;
 }) {
   const qc = useQueryClient();
@@ -72,8 +78,9 @@ export function RebalanceAllButton({
 
   const notOptimal = status != null && status !== "Optimal";
   const applyingScenario = Object.keys(overrides).length > 0;
-  const disabledReason =
-    changed.length === 0
+  const disabledReason = previewStale
+    ? "Recalculate the Scenario before applying these targets"
+    : changed.length === 0
       ? "Nothing to re-balance — every block already meets demand"
       : notOptimal
         ? `The solve is ${status} — the target can't be met, so there's nothing safe to apply`
@@ -84,8 +91,11 @@ export function RebalanceAllButton({
 
   const apply = async () => {
     setApplying(true);
+    const requestId = globalThis.crypto.randomUUID();
+    onProgressStart(requestId);
+    let refreshScenario = false;
     try {
-      const res = await applyPinnedFactoryFn({ data: { demands: overrides } });
+      const res = await applyPinnedFactoryFn({ data: { demands: overrides, requestId } });
       // a non-Optimal solve is left unapplied server-side — say so and stop
       if (res.status !== "Optimal") {
         toast({
@@ -97,7 +107,7 @@ export function RebalanceAllButton({
       await Promise.all(
         REFRESH_KEYS.map((queryKey) => qc.invalidateQueries({ queryKey: [...queryKey] })),
       );
-      onApplied();
+      refreshScenario = true;
       if (res.applied.length) {
         const n = res.applied.length;
         undoToast(qc, `Balanced ${n} block${n === 1 ? "" : "s"} from the factory pins`);
@@ -110,9 +120,11 @@ export function RebalanceAllButton({
       if (!res.applied.length && !res.broken.length)
         toast({ message: "Already balanced — nothing to apply", tone: "success" });
     } finally {
+      onProgressEnd();
       setApplying(false);
       setOpen(false);
     }
+    if (refreshScenario) onApplied();
   };
 
   const button = (