fix(solver): scale goals beyond coproduct plateaus

Author: ApocDev

app/e2e/mut/rebalance.e2e.ts

@@ -199,7 +199,7 @@ test("Scenario zeros an unpinned consume goal without saving the preview", async
   }
 });
 
-test("Scenario explains an infeasible material balance", async ({ page }) => {
+test("Scenario scales a goal beyond recovered coproduct supply", async ({ page }) => {
   test.setTimeout(120_000);
   const db = new DatabaseSync(activeProjectDbFile());
   const pins = db.prepare("SELECT value FROM meta WHERE key = 'factory_pins_v1'").get() as
@@ -224,18 +224,11 @@ test("Scenario explains an infeasible material balance", async ({ page }) => {
     await goto(page, "/factory/scenario");
     await dismissDataDriftPrompt(page);
 
-    const diagnostic = page.getByTestId("scenario-validation");
-    await expect(diagnostic.getByText("Scenario solve failed: Infeasible")).toBeVisible({
+    await expect(page.getByRole("link", { name: /^Creosote / })).toBeVisible({
       timeout: 60_000,
     });
-    const conflicts = diagnostic.getByRole("region", { name: "Factory material conflicts" });
-    await expect(conflicts.getByText(/Creosote shortage:/)).toBeVisible();
-    await expect(conflicts.getByText(/required · .* available/).first()).toBeVisible();
-    await expect(conflicts.getByRole("link", { name: "Simple circuit board" }).first()).toBeVisible();
-    await expect(conflicts.getByRole("link", { name: "Coal gas" })).toBeVisible();
-    await expect(
-      conflicts.getByText("The configured Creosote goal has no additional scalable output."),
-    ).toBeVisible();
+    await expect(page.getByTestId("scenario-validation")).toBeHidden();
+    await expect(page.getByRole("button", { name: "Balance factory" })).toBeEnabled();
   } finally {
     const cleanup = new DatabaseSync(activeProjectDbFile());
     if (pins)

app/src/server/factory-plan.server.ts

@@ -38,6 +38,8 @@ type Column = {
   kind: string;
   sign: 1 | -1;
   priority: number;
+  /** Whether this marginal basis is active at the reference goal vector. */
+  activeAtReference: boolean;
   flows: Flow[];
 };
 type FixedFlow = { item: string; kind: string; net: number };
@@ -256,9 +258,9 @@ function signedBoundary(
  * A multi-goal block is one coupled LP: probing each goal with every sibling at
  * zero can combine mutually incompatible recipe bases. Finite differences at
  * the solved full vector recover the active LP basis, including negative
- * marginal flows when increasing one goal reduces another recipe. A separate
- * zero-activity solve captures operational estimates such as incidental
- * spoilage without mistaking a non-smooth recipe-basis change for fixed flow.
+ * marginal flows when increasing one goal reduces another recipe. The affine
+ * intercept makes the response pass through that full solved reference point,
+ * retaining operational and activation flows that have zero local derivative.
  * Final apply validation catches a target that crosses into another basis. */
 async function responseColumns(
   row: NonNullable<ReturnType<typeof q.getBlock>>,
@@ -272,40 +274,81 @@ async function responseColumns(
       const baseResult = await computeBlock(reference);
       if (baseResult.broken || baseResult.status !== "solved") return { columns: [], fixed: [] };
       const base = signedBoundary(reference, baseResult);
-      const idle: SolveInput = {
-        ...reference,
-        goals: reference.goals.map((goal) => ({
-          ...goal,
-          rate: 0,
-          direction: goalConsumes(goal) ? "consume" : "produce",
-        })),
-      };
-      const idleResult = await computeBlock(idle);
+      const anchorResult = reference.goals.some(
+        (goal, index) => goal.rate !== doc.goals[index]?.rate,
+      )
+        ? await computeBlock(doc)
+        : baseResult;
+      const anchor =
+        anchorResult.broken || anchorResult.status !== "solved"
+          ? new Map<string, { kind: string; net: number }>()
+          : signedBoundary(doc, anchorResult);
       const columns = await Promise.all(
         reference.goals.map(async (goal, goalIndex): Promise<Column | null> => {
           const sign: 1 | -1 = goalConsumes(goal) ? -1 : 1;
-          const delta = Math.max(1e-3, Math.abs(goal.rate) * 1e-3);
-          const perturbed: SolveInput = {
-            ...reference,
-            goals: reference.goals.map((candidate, index) =>
-              index === goalIndex
-                ? { ...candidate, rate: candidate.rate + sign * delta }
-                : candidate,
-            ),
+          const solveBoundaryAt = async (rate: number) => {
+            const perturbed: SolveInput = {
+              ...reference,
+              goals: reference.goals.map((candidate, index) =>
+                index === goalIndex ? { ...candidate, rate } : candidate,
+              ),
+            };
+            const result = await computeBlock(perturbed);
+            if (result.broken || result.status !== "solved" || result.unmade?.includes(goal.name))
+              return null;
+            return signedBoundary(perturbed, result);
           };
-          const result = await computeBlock(perturbed);
-          if (result.broken || result.status !== "solved" || result.unmade?.includes(goal.name))
-            return null;
-          const next = signedBoundary(perturbed, result);
+          let delta = Math.max(1e-3, Math.abs(goal.rate) * 1e-3);
+          let previous = base;
+          let next = await solveBoundaryAt(goal.rate + sign * delta);
+          if (!next) return null;
+
+          // A sibling goal can already make more of this good than its own
+          // minimum asks for. A tiny perturbation then consumes only that
+          // existing surplus: total block output stays flat and the local
+          // derivative is zero even though the goal becomes scalable after the
+          // surplus is exhausted. Coupled goals can create the same plateau by
+          // substituting one recipe basis for another. Search outward for the
+          // next segment where the goal changes its own boundary flow, then
+          // measure that segment locally so the plateau does not dilute its
+          // true marginal response.
+          const localOwnNet =
+            ((next.get(goal.name)?.net ?? 0) - (base.get(goal.name)?.net ?? 0)) / delta;
+          const activeAtReference = sign * localOwnNet > EPS;
+          const coveredRate = sign * (base.get(goal.name)?.net ?? 0);
+          if (sign * localOwnNet <= EPS) {
+            let segmentMagnitude =
+              Math.max(Math.abs(goal.rate), coveredRate, RATE_CHANGE_ABS_TOL) * 1.001;
+            for (let attempt = 0; attempt < 6; attempt += 1) {
+              const segmentDelta = Math.max(1e-3, segmentMagnitude * 1e-3);
+              const segmentStart = sign * segmentMagnitude;
+              const segmentBase = await solveBoundaryAt(segmentStart);
+              const segmentNext = await solveBoundaryAt(segmentStart + sign * segmentDelta);
+              const segmentOwnNet =
+                segmentBase && segmentNext
+                  ? ((segmentNext.get(goal.name)?.net ?? 0) -
+                      (segmentBase.get(goal.name)?.net ?? 0)) /
+                    segmentDelta
+                  : 0;
+              if (segmentBase && segmentNext && sign * segmentOwnNet > EPS) {
+                previous = segmentBase;
+                next = segmentNext;
+                delta = segmentDelta;
+                break;
+              }
+              segmentMagnitude *= 2;
+            }
+          }
+
           const priority = doc.supplyPriorities?.[goal.name] ?? doc.supplyPriority ?? 0;
-          const goods = new Set([...base.keys(), ...next.keys()]);
+          const goods = new Set([...previous.keys(), ...next.keys()]);
           const flows: Flow[] = [...goods].flatMap((good) => {
-            const marginal = ((next.get(good)?.net ?? 0) - (base.get(good)?.net ?? 0)) / delta;
+            const marginal = ((next.get(good)?.net ?? 0) - (previous.get(good)?.net ?? 0)) / delta;
             if (Math.abs(marginal) <= EPS) return [];
             return [
               {
                 item: good,
-                kind: next.get(good)?.kind ?? base.get(good)?.kind ?? "item",
+                kind: next.get(good)?.kind ?? previous.get(good)?.kind ?? "item",
                 role:
                   marginal < 0
                     ? "import"
@@ -325,46 +368,33 @@ async function responseColumns(
             kind,
             sign,
             priority,
+            activeAtReference,
             flows,
           };
         }),
       );
       const solvedColumns = columns.filter(
         (column): column is Column => column != null && !FREE_GOODS.has(column.good),
       );
-      const fixedBoundary =
-        idleResult.broken || idleResult.status !== "solved"
-          ? new Map<string, { kind: string; net: number }>()
-          : signedBoundary(idle, idleResult);
-      if (reference.goals.some((goal) => FREE_GOODS.has(goal.name))) {
-        const withoutFree: SolveInput = {
-          ...reference,
-          goals: reference.goals.map((goal) =>
-            FREE_GOODS.has(goal.name)
-              ? {
-                  ...goal,
-                  rate: 0,
-                  direction: goalConsumes(goal) ? "consume" : "produce",
-                }
-              : goal,
-          ),
-        };
-        const withoutFreeResult = await computeBlock(withoutFree);
-        if (!withoutFreeResult.broken && withoutFreeResult.status === "solved") {
-          const withoutFreeBoundary = signedBoundary(withoutFree, withoutFreeResult);
-          for (const item of new Set([...base.keys(), ...withoutFreeBoundary.keys()])) {
-            const frozen = (base.get(item)?.net ?? 0) - (withoutFreeBoundary.get(item)?.net ?? 0);
-            if (Math.abs(frozen) <= EPS) continue;
-            const current = fixedBoundary.get(item);
-            fixedBoundary.set(item, {
-              kind:
-                base.get(item)?.kind ??
-                withoutFreeBoundary.get(item)?.kind ??
-                current?.kind ??
-                "item",
-              net: (current?.net ?? 0) + frozen,
-            });
-          }
+      // fixed = anchor - J * anchor goals. This local affine intercept retains
+      // flows that switch on with an active recipe but stay flat under tiny
+      // perturbations; an idle-only intercept silently dropped them on every
+      // re-linearization pass. A marginal basis found beyond a coproduct
+      // plateau is excluded because that segment is not active at the current
+      // reference point.
+      const fixedBoundary = new Map(
+        [...anchor].map(([item, flow]) => [item, { ...flow }] as const),
+      );
+      for (const column of solvedColumns) {
+        if (!column.activeAtReference) continue;
+        const anchorGoal = doc.goals.find((goal) => goal.name === column.good);
+        const magnitude = Math.abs(anchorGoal?.rate ?? 0);
+        for (const flow of column.flows) {
+          const current = fixedBoundary.get(flow.item);
+          fixedBoundary.set(flow.item, {
+            kind: current?.kind ?? flow.kind,
+            net: (current?.net ?? 0) - magnitude * flow.rate * (flow.role === "import" ? -1 : 1),
+          });
         }
       }
       const fixed = [...fixedBoundary].flatMap(([item, flow]) =>

app/src/server/factory-plan.test.ts

@@ -11,6 +11,7 @@ let ashSinkAdditive = 0;
 let infeasibleIronAbove = Number.POSITIVE_INFINITY;
 let nonlinearElectricity = false;
 let recoveredIronPerCoke = 10;
+let ironGoalScalable = true;
 let solveVersion = 0;
 const blocks = [
   {
@@ -111,11 +112,11 @@ vi.mock("./block-compute.server.ts", () => ({
       const cokeRate = Math.abs(cokeGoal.rate);
       const ironRate = Math.abs(recoveredIronGoal.rate);
       const recoveredIron = cokeRate * recoveredIronPerCoke;
-      const dedicatedIron = Math.max(0, ironRate - recoveredIron);
+      const dedicatedIron = ironGoalScalable ? Math.max(0, ironRate - recoveredIron) : 0;
       return {
         broken: false,
         status: "solved",
-        unmade: [],
+        unmade: !ironGoalScalable && ironRate > recoveredIron ? ["iron"] : [],
         imports: [{ name: "ore", kind: "item", rate: cokeRate * 3 + dedicatedIron * 2 }],
         exports:
           recoveredIron > ironRate
@@ -230,6 +231,7 @@ beforeEach(() => {
   infeasibleIronAbove = Number.POSITIVE_INFINITY;
   nonlinearElectricity = false;
   recoveredIronPerCoke = 10;
+  ironGoalScalable = true;
   for (const doc of docs.values()) doc.updatedAt = new Date(++solveVersion * 1000);
   blocks.splice(4);
   docs.delete(5);
@@ -352,7 +354,7 @@ describe("pinned factory solve", () => {
     expect(saved?.goals.find((goal) => goal.name === "iron")?.rate).toBeCloseTo(4);
   });
 
-  it("reports the material and blocks that make the factory LP infeasible", async () => {
+  it("scales a goal past supply recovered from a sibling goal", async () => {
     recoveredIronPerCoke = 2;
     blocks.push({
       id: 5,
@@ -384,6 +386,51 @@ describe("pinned factory solve", () => {
 
     const result = await plan.solvePinnedFactory();
 
+    expect(result.status).toBe("Optimal");
+    expect(result.validation).toBeNull();
+    expect(result.goalChanges).toContainEqual(
+      expect.objectContaining({
+        id: 5,
+        good: "iron",
+        requiredRate: 4,
+        projectedOutput: 4,
+      }),
+    );
+  });
+
+  it("reports a configured goal whose output is genuinely not scalable", async () => {
+    recoveredIronPerCoke = 2;
+    ironGoalScalable = false;
+    blocks.push({
+      id: 5,
+      name: "Coke and iron",
+      rate: 0,
+      goals: [
+        { name: "coke", rate: 0 },
+        { name: "iron", rate: 0 },
+      ],
+      flows: [],
+    });
+    docs.set(5, {
+      id: 5,
+      name: "Coke and iron",
+      updatedAt: new Date(++solveVersion * 1000),
+      data: {
+        goals: [
+          { name: "coke", rate: 0 },
+          { name: "iron", rate: 0 },
+        ],
+        recipes: ["recipe-5"],
+        supplyPriority: 1,
+      },
+    });
+    plan.saveFactoryPins([
+      { good: "science", kind: "item", rate: 1 },
+      { good: "coke", kind: "item", rate: 1 },
+    ]);
+
+    const result = await plan.solvePinnedFactory();
+
     expect(result.status).toBe("Infeasible");
     expect(result.validation?.materialConflicts).toContainEqual(
       expect.objectContaining({
@@ -478,15 +525,14 @@ describe("pinned factory solve", () => {
     expect(result.raws).toContainEqual(expect.objectContaining({ good: "ore", projected: 12 }));
   });
 
-  it("measures validation residue against gross throughput", async () => {
+  it("captures a fixed response offset after re-linearizing", async () => {
     ironImportOffset = 0.02;
 
     const result = await plan.solvePinnedFactory();
 
     expect(result.status).toBe("Optimal");
     expect(result.passes).toBe(2);
-    expect(result.residual).toBeGreaterThan(0);
-    expect(result.residual).toBeLessThan(0.005);
+    expect(result.residual).toBe(0);
   });
 
   it("balances fixed incidental outputs as factory surplus", async () => {

app/src/solver/lp-tiebreak.test.ts

@@ -0,0 +1,36 @@
+import { expect, test, vi } from "vite-plus/test";
+
+const solve = vi
+  .fn()
+  // Machine minimum: feasible, but it makes twice the requested product.
+  .mockReturnValueOnce({ Status: "Optimal", Columns: { x0: { Primal: 1 } } })
+  // Goal-surplus minimum: exact goal at half the recipe rate.
+  .mockReturnValueOnce({
+    Status: "Optimal",
+    Columns: { x0: { Primal: 0.5 }, goalSlack0: { Primal: 0 } },
+  })
+  // Optional machine tie-break: simulate HiGHS rejecting the retained optimum.
+  .mockReturnValueOnce({ Status: "Infeasible", Columns: {} });
+
+vi.mock("highs", () => ({ default: vi.fn(async () => ({ solve })) }));
+
+test("keeps the feasible goal optimum when the machine tie-break fails", async () => {
+  const { solveBlockLp } = await import("./lp.ts");
+  const result = await solveBlockLp({
+    goals: [{ name: "product", rate: 1 }],
+    recipes: [
+      {
+        name: "double-product",
+        energyRequired: 1,
+        ingredients: [],
+        products: [{ kind: "item", name: "product", amount: 2 }],
+      },
+    ],
+  });
+
+  expect(result.status).toBe("solved");
+  expect(result.recipes).toContainEqual(
+    expect.objectContaining({ recipe: "double-product", rate: 0.5 }),
+  );
+  expect(solve).toHaveBeenCalledTimes(3);
+});