Fix gem processing order: flat bonuses before percentage multipliers

The solver now chains gem machines in correct order:
1. Single-input processors (Gem Cutter: 1.4x multiply)
2. Polisher (+$10 flat) — before % machines so they amplify it
3. Same-type combines (Prismatic: 1.15x)
4. QA (1.2x) — last for maximum effect

Previously Polisher was applied after all processors, losing value.
Diamond gem: $5.1K → $5.8K per gem from correct ordering.
Tooltip path updated to match solver order.

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

Author: bod09

js/chain-solver.js

@@ -578,36 +578,47 @@ class ChainSolver {
       if (m.gemType) {
         const gemData = typeof GEMS !== 'undefined' ? GEMS.find(g => g.name === m.gemType) : null;
         let gemVal = gemData?.value || 0;
-        // Find best gem processing
-        let bestProcessed = gemVal;
+
+        // Chain gem processing in correct order:
+        // 1. Single-input processors (gem_cutter: multiply 1.4x)
+        // 2. Flat modifiers (polisher: +$10) — before percentages to maximize
+        // 3. Same-type combines (prismatic: gem+gem combine 1.15x)
+        // 4. QA (percent 1.2x) — last for max effect
+
+        // Step 1: Find and apply single-input gem processors (multiply/flat)
+        let processed = gemVal;
+        const skipEff = new Set(["chance", "transport", "split", "overflow", "filter", "gate", "duplicate", "preserve", "set", "combine"]);
         for (const [procId, procM] of this.registry.machines) {
           if (!this.registry.isAvailable(procId, this.config)) continue;
-          if (!procM.inputs) continue;
-          const acceptsGem = procM.inputs.some(inp =>
-            inp === "gem" || inp.split("|").includes("gem") || inp === "any"
-          );
-          if (!acceptsGem) continue;
-          const skipEff = new Set(["chance", "transport", "split", "overflow", "filter", "gate", "duplicate", "preserve", "set"]);
+          if (!procM.inputs || procM.inputs.length !== 1) continue;
           if (skipEff.has(procM.effect)) continue;
-          if (procM.inputs.length > 1) {
-            const allGem = procM.inputs.every(inp => inp === "gem" || inp.split("|").includes("gem"));
-            if (!allGem) continue;
-          }
-          let processed = gemVal;
-          if (procM.effect === "flat") processed += procM.value;
-          else if (procM.effect === "multiply") processed *= procM.value;
-          else if (procM.effect === "combine") {
-            processed = gemVal * procM.inputs.length * procM.value / procM.inputs.length;
-          }
-          if (processed > bestProcessed) bestProcessed = processed;
+          const acceptsGem = procM.inputs.some(inp => inp === "gem" || inp.split("|").includes("gem"));
+          if (!acceptsGem) continue;
+          if (procM.effect === "multiply") processed *= procM.value;
+          else if (procM.effect === "flat") processed += procM.value;
         }
-        // Stack QA + polisher if safe
-        if (this._oreChainTags?.has("Polished")) bestProcessed += 10;
+
+        // Step 2: Polisher (+$10 flat) — before combines/QA so they amplify it
+        if (this._oreChainTags?.has("Polished")) processed += 10;
+
+        // Step 3: Same-type combines (prismatic: gem+gem → 1.15x combined)
+        for (const [combId, combM] of this.registry.machines) {
+          if (!this.registry.isAvailable(combId, this.config)) continue;
+          if (combM.effect !== "combine") continue;
+          const allGem = (combM.inputs || []).every(inp => inp === "gem" || inp.split("|").includes("gem"));
+          if (!allGem) continue;
+          const inputCount = (combM.inputs || []).length;
+          // Combined value per gem input: (N gems × value) × multiplier / N
+          processed = processed * inputCount * (combM.value || 1) / inputCount;
+        }
+
+        // Step 4: QA (1.2x percent) — last
         const qa = this.registry.get("quality_assurance");
         if (qa && this.registry.isAvailable("quality_assurance", this.config)) {
-          bestProcessed *= (1 + qa.value);
+          processed *= (1 + qa.value);
         }
-        byproductValue = bestProcessed * ds;
+
+        byproductValue = processed * ds;
       } else if (m.byproducts?.[0]?.type) {
         const bpResult = this._solve(m.byproducts[0].type, baseOreValue);
         byproductValue = bpResult?.value || 0;

js/graph-builder.js

@@ -390,34 +390,40 @@ class FlowGraphBuilder {
               const gemData = typeof GEMS !== 'undefined' ? GEMS.find(g => g.name === gemType) : null;
               nodeValue = gemData?.value || step.byproductValue || 0;
               secondaryValue = step.value || 0;
-              // Build processing path for tooltip
+              // Build processing path for tooltip — must match solver order:
+              // 1. Single-input processors (Gem Cutter)
+              // 2. Polisher (+flat, before % machines)
+              // 3. Same-type combines (Prismatic)
+              // 4. QA (% last)
               const path = [gemType + ' Gem'];
-              const gemProcessors = [];
+              const skipEff = new Set(['chance','transport','split','overflow','filter','gate','duplicate','preserve','set','combine']);
+
+              // Step 1: single-input gem processors
               for (const [gpId, gpM] of registry.machines) {
                 if (!registry.isAvailable(gpId, config)) continue;
-                const acceptsGem = (gpM.inputs || []).some(inp => inp === 'gem' || inp.split('|').includes('gem'));
+                if (!gpM.inputs || gpM.inputs.length !== 1) continue;
+                if (skipEff.has(gpM.effect)) continue;
+                const acceptsGem = gpM.inputs.some(inp => inp === 'gem' || inp.split('|').includes('gem'));
                 if (!acceptsGem) continue;
-                const skip = new Set(['chance','transport','split','overflow','filter','gate','duplicate','preserve','set']);
-                if (skip.has(gpM.effect)) continue;
-                if (gpM.inputs.length > 1 && !gpM.inputs.every(inp => inp === 'gem' || inp.split('|').includes('gem'))) continue;
-                gemProcessors.push({ id: gpId, name: gpM.name || gpId, effect: gpM.effect });
-              }
-              // Sort: single-input first (gem_cutter), then combine (prismatic)
-              gemProcessors.sort((a, b) => {
-                const am = registry.get(a.id);
-                const bm = registry.get(b.id);
-                return (am?.inputs?.length || 1) - (bm?.inputs?.length || 1);
-              });
-              for (const gp of gemProcessors) path.push(gp.name);
-              // Polisher and QA are applied by solver if available
-              const oreChainTags = [];
-              // Check what tags the ore chain has by looking at ore processing machines
-              for (const [mid, mm] of registry.machines) {
-                if (mm.tag && registry.isAvailable(mid, config)) oreChainTags.push(mm.tag);
+                path.push(gpM.name || gpId);
               }
-              if (oreChainTags.includes("Polished") && registry.isAvailable("polisher", config)) {
+
+              // Step 2: Polisher (flat, before combines/QA)
+              const polisher = registry.get("polisher");
+              if (polisher?.tag && registry.isAvailable("polisher", config)) {
                 path.push('Polisher');
               }
+
+              // Step 3: same-type gem combines (Prismatic)
+              for (const [gpId, gpM] of registry.machines) {
+                if (!registry.isAvailable(gpId, config)) continue;
+                if (gpM.effect !== 'combine') continue;
+                const allGem = (gpM.inputs || []).every(inp => inp === 'gem' || inp.split('|').includes('gem'));
+                if (!allGem) continue;
+                path.push(gpM.name || gpId);
+              }
+
+              // Step 4: QA (percent, last)
               if (registry.isAvailable("quality_assurance", config)) {
                 path.push('QA');
               }