Fix combine machine quantity halving (prismatic 2:1, alloy 2:1)

Two changes to quantity propagation:

1. Same-type combine machines (prismatic: 2 gems → 1, alloy: 2 bars
   → 1 alloy_bar) now correctly multiply demand for ALL edge kinds,
   including enhancement edges. Previously enhancement edges were
   exempted, preventing prismatic from halving quantities in the
   transmute chain.

2. Added forward supply propagation (Phase A2): After demand
   propagation, BFS from ore_source through main/enhancement edges
   sets supply-constrained quantities. Same-type combines halve the
   flow. This ensures quantities match actual ore supply (24 ores)
   rather than unconstrained demand.

Result for Power Core with 24 ores:
  Ore x24 → Smelter x24 → Enhancement x24 → Prismatic x12 (halved!)
  → Gem to Bar x12 → Alloy Furnace x6 (halved!) → consumers x6

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: bod09

index.html

@@ -248,7 +248,7 @@ <h2>Machine Connections</h2>
   <script src="js/data.js?v=367"></script>
   <script src="js/graph.js?v=367"></script>
   <script src="js/chain-solver.js?v=367"></script>
-  <script src="js/graph-builder.js?v=367"></script>
+  <script src="js/graph-builder.js?v=368"></script>
   <script src="js/graph-layout.js?v=367"></script>
   <script src="js/visualizer.js?v=367"></script>
   <script src="js/optimizer.js?v=367"></script>

js/graph-builder.js

@@ -446,9 +446,9 @@ class FlowGraphBuilder {
 
         let demand = nd.quantity;
 
-        // Same-type combine: multiply demand only for MAIN edges (real production).
-        // Enhancement edges pass through 1:1 (same items looping through value transform).
-        if (isSameTypeCombine && edge.kind !== "enhancement") {
+        // Same-type combine (prismatic 2:1, alloy 2:1): always multiply demand.
+        // This is real physical consumption — 2 gems become 1 output, even in enhancement paths.
+        if (isSameTypeCombine) {
           demand = nd.quantity * (machine.inputs?.length || 2);
         }
 
@@ -462,13 +462,47 @@ class FlowGraphBuilder {
       }
     }
 
-    // Special: ore_source gets actualOreCount (externally known total)
-    for (const n of nodes) {
-      if (n.machine === "ore_source" && !n.machine?.startsWith?.("cheap_")) {
-        // Only override non-cheap ore source
-        const key = [...visited.entries()].find(([k, v]) => v === n.id)?.[0];
-        if (key && !key.startsWith("cheap_")) {
-          n.quantity = actualOreCount;
+    // --- Phase A2: Forward supply propagation from ore_source ---
+    // The demand propagation may produce quantities exceeding ore supply.
+    // Fix: set ore_source to actualOreCount, then forward-propagate through
+    // main/enhancement chain, halving at same-type combine machines.
+    // This gives supply-constrained quantities that match what actually flows.
+    const oreSourceNode = nodes.find(n => {
+      if (n.machine !== "ore_source") return false;
+      const key = [...visited.entries()].find(([k, v]) => v === n.id)?.[0];
+      return key && !key.startsWith("cheap_");
+    });
+    if (oreSourceNode) {
+      oreSourceNode.quantity = actualOreCount;
+      // Forward BFS from ore_source through main/enhancement edges
+      const supplyVisited = new Set([oreSourceNode.id]);
+      const supplyQueue = [oreSourceNode.id];
+      while (supplyQueue.length > 0) {
+        const curId = supplyQueue.shift();
+        const curNode = nodeById.get(curId);
+        if (!curNode) continue;
+        // Find edges FROM this node (it feeds downstream consumers)
+        for (const edge of edges) {
+          if (edge.from !== curId || edge.kind === "byproduct") continue;
+          if (supplyVisited.has(edge.to)) continue;
+          supplyVisited.add(edge.to);
+          const downstream = nodeById.get(edge.to);
+          if (!downstream) continue;
+          // Don't override seller/QA — those are demand-driven (productQty)
+          if (downstream.machine === "seller" || downstream.machine === "quality_assurance") continue;
+          // Downstream gets same qty as supplier...
+          let qty = curNode.quantity;
+          // ...unless downstream is a same-type combine (halves)
+          const dsMachine = registry.get(downstream.machine);
+          const dsIsCombine = dsMachine?.effect === "combine" &&
+            dsMachine.inputs?.length >= 2 &&
+            new Set(dsMachine.inputs.flatMap(i => i.split("|"))).size === 1;
+          if (dsIsCombine) {
+            qty = Math.floor(qty / (dsMachine.inputs?.length || 2));
+          }
+          downstream.quantity = qty;
+          edge.quantity = curNode.quantity; // Edge shows items flowing IN
+          supplyQueue.push(edge.to);
         }
       }
     }