fix(solver): drop phantom dust flows; remove whole-machine mode; purge issue #s from UI

Three block-page fixes from live review:

1. A boundary flow smaller than a tiny fraction of an item's gross
   in-block throughput is now dropped as numerical dust. HiGHS returns
   rates with ~1e-7 relative error; on a covered item (block 20: water
   made by a pump, consumed by a barreler) the net is a near-
   cancellation of large equal terms — 275.0004 produced − 275 consumed
   — which surfaced a phantom 0.0004 water export. A relative floor
   (fraction of gross traffic) drops it without hiding real small flows.

2. Remove whole-machine mode. It only ceil()'d the displayed count while
   leaving the material flows at exact demand — 'artificially ceil for
   display,' as the user put it. Making buildings truly run at 100% would
   create surplus that Factorio actually throttles away in steady state,
   so it'd misrepresent the factory. The honest number is the fractional
   requirement; the factory page still shows the whole-machine build
   target in the count tooltip, and users round up themselves. Drops the
   MIP path from the LP, the doc flag, the toolbar toggle, and the
   sub-block wiring.

3. Sweep issue numbers out of rendered UI strings. Only one had leaked —
   the 'Whole machines (#98)' toolbar tooltip — removed with the mode.
   (Code comments keep their #refs; those aren't displayed.)

Refs #91

Author: ApocDev

app/src/components/block/block-toolbar.tsx

@@ -69,7 +69,6 @@ export function BlockToolbar({
   onOpenIconPicker: () => void;
 }) {
   const blockName = useStore(doc.store, (s) => s.blockName);
-  const wholeMachines = useStore(doc.store, (s) => s.wholeMachines);
   const customIcon = useStore(doc.store, (s) => s.customIcon);
   return (
     <div className="mb-3 flex flex-wrap items-center gap-2">
@@ -118,18 +117,6 @@ export function BlockToolbar({
           ""
         )}
       </span>
-      <Button
-        variant={wholeMachines ? "default" : "outline"}
-        size="sm"
-        onClick={() => {
-          doc.setWholeMachines(!wholeMachines);
-          doc.note(wholeMachines ? "Fractional machine counts" : "Whole-machine counts");
-        }}
-        title="Whole machines (#98): every row's building count becomes an integer the solve commits to — machines may idle, rates stay exact. Off = exact fractional counts."
-        className={wholeMachines ? "" : "text-muted-foreground"}
-      >
-        1×
-      </Button>
       <Button
         variant="outline"
         size="icon-sm"

app/src/components/block/doc-store.ts

@@ -50,8 +50,6 @@ export type BlockDocState = {
   made: ReadonlySet<string> | null;
   /** per-row pins (#91): fixed/cap building counts, consumer shares */
   pins: DocPin[];
-  /** whole-machine mode (#98): integer building counts per row */
-  wholeMachines: boolean;
   /** legacy dispositions payload, kept verbatim until `made` is adopted so the
    * server keeps deriving from it; dropped from the doc after adoption */
   dispositions: Record<string, Disposition>;
@@ -77,7 +75,6 @@ const EMPTY: BlockDocState = {
   disabled: new Set(),
   made: null,
   pins: [],
-  wholeMachines: false,
   dispositions: {},
   spoilRates: {},
   rowGroups: [],
@@ -107,7 +104,6 @@ export function solveInputOf(s: BlockDocState): SolveInput {
     // shipping their dispositions so the server can derive
     ...(s.made ? { made: [...s.made].sort() } : {}),
     ...(s.pins.length ? { pins: s.pins } : {}),
-    ...(s.wholeMachines ? { wholeMachines: true } : {}),
     ...(!s.made && Object.keys(s.dispositions).length ? { dispositions: s.dispositions } : {}),
     ...(Object.keys(s.machines).length ? { machines: s.machines } : {}),
     ...(Object.keys(s.fuels).length ? { fuels: s.fuels } : {}),
@@ -158,7 +154,6 @@ export function createBlockDocStore() {
       disabled: new Set(d.disabledRecipes ?? []),
       made: d.made ? new Set(d.made) : null,
       pins: d.pins ?? [],
-      wholeMachines: d.wholeMachines ?? false,
       dispositions: (d.dispositions ?? {}) as Record<string, Disposition>,
       spoilRates: d.spoilRates ?? {},
       machines: d.machines ?? {},
@@ -375,8 +370,6 @@ export function createBlockDocStore() {
           pin,
         ],
       })),
-    /** whole-machine mode (#98): integer building counts on every row */
-    setWholeMachines: (on: boolean) => edit(() => ({ wholeMachines: on })),
     clearPin: (recipe: string, share?: { item: string }) =>
       edit((s) => ({
         pins: s.pins.filter((p) =>

app/src/components/block/pin-dialog.tsx

@@ -15,7 +15,7 @@ import { Icon } from "../../lib/icons";
 import type { BlockDocStore } from "./doc-store.ts";
 import type { SolveResult } from "./solve-view.ts";
 
-/** Pin editor for one recipe row (#91/#98): fixed building count (always run
+/** Pin editor for one recipe row (#91): fixed building count (always run
  * exactly N — supply-push), built cap (at most N — the reality ceiling), and
  * consumer share pins (this row takes a % of an ingredient's in-block
  * production — the byproduct-routing gesture). One count-or-cap pin per row;

app/src/components/block/row-menu.tsx

@@ -28,7 +28,7 @@ export function RowMenu({
   onNewGroup: () => void;
   onJoinGroup: (groupId: number) => void;
   onLeaveGroup: () => void;
-  /** open the pin editor (#91/#98): fixed/cap counts, input shares */
+  /** open the pin editor (#91): fixed/cap counts, input shares */
   onOpenPins: () => void;
   onClose: () => void;
 }) {

app/src/components/factory/machines-card.tsx

@@ -70,7 +70,7 @@ const HEAD_W: Record<string, string> = {
   short: "w-24 justify-end",
 };
 
-/** A required count: whole-machine blocks (#98) show the integer as-is;
+/** A required count: whole (built) counts show the integer as-is;
  * fractional solves show the exact ratio with the build target in the title. */
 function RequiredCount({ n }: { n: number }) {
   if (isWholeCount(n)) return <>{fmtMachineCount(n)}</>;

app/src/db/schema.ts

@@ -451,9 +451,6 @@ export type BlockData = {
     | { kind: "count" | "cap"; recipe: string; count: number }
     | { kind: "share"; recipe: string; item: string; share: number; base?: "total" | "remaining" }
   )[];
-  // Whole-machine mode (#98): building counts are integers the solve commits
-  // to (rows may idle; rates stay exact). Off = exact fractional counts.
-  wholeMachines?: boolean;
   machines?: Record<string, string>; // recipe → chosen machine
   fuels?: Record<string, string>; // recipe → chosen fuel
   // Reactor farm layout per reactor recipe row (#94): the assumed x×y grid whose

app/src/lib/machine-count.test.ts

@@ -3,7 +3,7 @@ import { describe, expect, it } from "vite-plus/test";
 import { fmtMachineCount, isWholeCount, wholeMachines } from "./machine-count";
 
 /** Machine counts arrive in two shapes (#80): fractional from the default solve
- * (7.28 assemblers) and integer from whole-machine mode (#98) or the game's
+ * (7.28 assemblers) and integer from the game's
  * built counts. Both must render sanely. */
 describe("machine-count helpers", () => {
   it("renders whole counts plain — no fake decimals", () => {

app/src/lib/machine-count.ts

@@ -1,7 +1,7 @@
 /**
  * Machine-count rendering helpers. Block solves report machine counts that are
  * either fractional (the default solve — 7.28 assemblers is the exact ratio) or
- * integer (whole-machine mode, #98) — both flow into the factory machines
+ * integer (from the game's built counts) — both flow into the factory machines
  * table, so it renders each sanely: integers plain, fractions at adaptive
  * precision with the whole-machine build target alongside.
  */
@@ -10,7 +10,7 @@ import { formatQty } from "./format";
 /** Whole machines you must place to cover a (possibly fractional) requirement. */
 export const wholeMachines = (n: number): number => Math.ceil(n - 1e-6);
 
-/** True when a count is (numerically) a whole number — whole-machine-mode
+/** True when a count is (numerically) a whole number — the game's built-count
  * blocks and built counts from the game; fractional solves are not. */
 export const isWholeCount = (n: number): boolean => Math.abs(n - Math.round(n)) < 1e-6;
 

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

@@ -81,7 +81,6 @@ function Block({ blockId }: { blockId: number }) {
     recipes,
     made,
     pins,
-    wholeMachines,
     spoilRates,
     rowGroups,
     recipeGroups,
@@ -119,7 +118,7 @@ function Block({ blockId }: { blockId: number }) {
   const [renamingGroup, setRenamingGroup] = useState<number | null>(null);
   // right-click menu on a recipe row (sub-block actions)
   const [rowMenu, setRowMenu] = useState<{ x: number; y: number; name: string } | null>(null);
-  // pin editor (#91/#98): the recipe whose pins are being edited
+  // pin editor (#91): the recipe whose pins are being edited
   const [pinFor, setPinFor] = useState<string | null>(null);
   // snapshot-history drawer (#85)
   const [historyOpen, setHistoryOpen] = useState(false);
@@ -328,7 +327,6 @@ function Block({ blockId }: { blockId: number }) {
       spoilRates,
       made,
       pins,
-      wholeMachines,
       machineSel,
       fuelSel,
       moduleSel,

app/src/server/block-compute.server.ts

@@ -224,9 +224,6 @@ export type SolveInput = {
    * count = always run exactly N buildings; cap = at most N buildings (built
    * ceiling); share = this consumer takes a % of the item's production. */
   pins?: DocPin[];
-  /** whole-machine mode (#98): every row's building count is an integer the
-   * solve commits to (machines may idle); rates stay exact. */
-  wholeMachines?: boolean;
   machines?: Record<string, string>; // recipe → chosen machine (else fastest)
   fuels?: Record<string, string>; // recipe → chosen fuel (else cheapest available)
   // Reactor farm layout per reactor recipe row (#94): the assumed x×y grid whose
@@ -625,22 +622,12 @@ export async function computeBlock(rawData: SolveInput) {
       rate: p.count * perBuilding,
     });
   }
-  // whole-machine mode (#98): hand the LP each row's real per-building rate so
-  // it can commit to integer counts
-  const machineRates = data.wholeMachines
-    ? Object.fromEntries(
-        defs.flatMap((d) => {
-          const per = craftRate(d.name);
-          return per != null && per > 0 ? [[d.name, per]] : [];
-        }),
-      )
-    : undefined;
   const defaultTemp = (f: string) => q.getFluid(f)?.defaultTemperature ?? null;
   // Sub-blocks v2 (#76): a COMPOSED group is solved as its own module and pulled
   // out of the parent solve, replaced by a synthetic recipe carrying only its
-  // boundary contract (net imports → net exports). Member recipes, pins and
-  // whole-machine rates route into their module; the parent solves normally over
-  // its own recipes + these synthetics. Display-only groups (#7) are untouched.
+  // boundary contract (net imports → net exports). Member recipes and pins route
+  // into their module; the parent solves normally over its own recipes + these
+  // synthetics. Display-only groups (#7) are untouched.
   const composedGroups: ComposedGroup[] = (data.rowGroups ?? [])
     .filter((g) => g.composed)
     .map((g) => ({
@@ -653,11 +640,10 @@ export async function computeBlock(rawData: SolveInput) {
       ...(g.made ? { made: g.made } : {}),
     }));
   const compose = composedGroups.length
-    ? await composeSubBlocks({ defs, groups: composedGroups, pins, machineRates, defaultTemp })
+    ? await composeSubBlocks({ defs, groups: composedGroups, pins, defaultTemp })
     : {
         parentDefs: defs,
         parentPins: pins,
-        parentMachineRates: machineRates,
         subs: [] as SubBlockSolve[],
         memberGroupOf: new Map<string, number>(),
       };
@@ -677,10 +663,7 @@ export async function computeBlock(rawData: SolveInput) {
     { goals, recipes: compose.parentDefs, made: parentMade, pins: compose.parentPins },
     defaultTemp,
   );
-  const lpInput: LpBlockInput = {
-    ...expandedInput,
-    ...(compose.parentMachineRates ? { machineRates: compose.parentMachineRates } : {}),
-  };
+  const lpInput: LpBlockInput = expandedInput;
   const rawResult = await solveBlockLp(lpInput);
   // root-cause cards for the balance card — every member is a clickable gesture.
   // Fold synthetic goods back to the bare fluid (the doc's made marks are bare
@@ -778,9 +761,9 @@ export async function computeBlock(rawData: SolveInput) {
       autoModules,
     } = setup.get(rr.recipe)!;
     const speed = (chosen?.craftingSpeed ?? 1) * fx.speedMult;
-    // whole-machine mode (#98): the LP committed to an integer count (the row
-    // may idle); otherwise the exact fractional requirement
-    const count = result.wholeMachines?.[rr.recipe] ?? rr.machines1x / speed;
+    // fractional building requirement (machine-seconds/sec ÷ speed); the UI
+    // shows this and the whole-machine build target alongside it
+    const count = rr.machines1x / speed;
     const powerW = (chosen?.energyUsageW ?? 0) * count * fx.consMult;
     const pollutionPerMin =
       (chosen?.pollutionPerMin ?? 0) * Math.max(0, count) * fx.consMult * fx.pollutionMult;