diff --git a/spec/System/TestPowerReport_spec.lua b/spec/System/TestPowerReport_spec.lua
new file mode 100644
index 0000000000..1a7d722088
--- /dev/null
+++ b/spec/System/TestPowerReport_spec.lua
@@ -0,0 +1,38 @@
+describe("PowerReportListControl", function()
+	local PowerReportListControl
+
+	before_each(function()
+		LoadModule("Classes/PowerReportListControl")
+		PowerReportListControl = common.classes.PowerReportListControl
+	end)
+
+	local function relist(originalList, showClusters, allocated)
+		local control = {
+			originalList = originalList,
+			showClusters = showClusters or false,
+			allocated = allocated or false,
+		}
+		PowerReportListControl.ReList(control)
+		return control.list
+	end
+
+	it("Show Unallocated excludes allocated nodes", function()
+		local list = relist({
+			{ name = "allocated", power = 10, pathDist = 1, allocated = true },
+			{ name = "unallocated", power = 5, pathDist = 1, allocated = false },
+		}, false, false)
+
+		assert.are.equal(1, #list)
+		assert.are.equal("unallocated", list[1].name)
+	end)
+
+	it("Show Allocated includes allocated nodes", function()
+		local list = relist({
+			{ name = "allocated", power = 10, pathDist = 1, allocated = true },
+			{ name = "unallocated", power = 5, pathDist = 1, allocated = false },
+		}, false, true)
+
+		assert.are.equal(1, #list)
+		assert.are.equal("allocated", list[1].name)
+	end)
+end)
diff --git a/spec/System/TestWeightedScore_spec.lua b/spec/System/TestWeightedScore_spec.lua
new file mode 100644
index 0000000000..6f4d6a472f
--- /dev/null
+++ b/spec/System/TestWeightedScore_spec.lua
@@ -0,0 +1,411 @@
+local WeightedScore = LoadModule("Modules/WeightedScore")
+
+describe("WeightedScore module", function()
+	-- Save and restore maxStatIncrease around the whole suite so we don't
+	-- pollute other spec files that rely on the real game value.
+	local savedMaxStatIncrease
+	before_each(function()
+		savedMaxStatIncrease = data.misc.maxStatIncrease
+		data.misc.maxStatIncrease = 2
+	end)
+	after_each(function()
+		data.misc.maxStatIncrease = savedMaxStatIncrease
+	end)
+
+	-- defaultWeights -----------------------------------------------------------
+
+	it("defaultWeights returns two entries (FullDPS and TotalEHP)", function()
+		local weights = WeightedScore.defaultWeights()
+		assert.are.equal(2, #weights)
+		assert.are.equal("FullDPS", weights[1].stat)
+		assert.are.equal("TotalEHP", weights[2].stat)
+	end)
+
+	-- getWeights ---------------------------------------------------------------
+
+	it("getWeights returns defaults when build is nil", function()
+		local weights = WeightedScore.getWeights(nil)
+		assert.are.same(WeightedScore.defaultWeights(), weights)
+	end)
+
+	it("getWeights returns defaults when statSortSelectionList is empty", function()
+		local mockBuild = {
+			itemsTab = {
+				tradeQuery = { statSortSelectionList = {} }
+			}
+		}
+		local weights = WeightedScore.getWeights(mockBuild)
+		assert.are.same(WeightedScore.defaultWeights(), weights)
+	end)
+
+	it("getWeights returns custom weights when statSortSelectionList is populated", function()
+		local custom = { { stat = "TotalDPS", label = "DPS", weightMult = 2.0 } }
+		local mockBuild = {
+			itemsTab = {
+				tradeQuery = { statSortSelectionList = custom }
+			}
+		}
+		local weights = WeightedScore.getWeights(mockBuild)
+		assert.are.equal(1, #weights)
+		assert.are.equal("TotalDPS", weights[1].stat)
+		assert.are.equal(2.0, weights[1].weightMult)
+	end)
+
+	-- computeRatioScore: basic ranking -----------------------------------------
+
+	it("neutral candidate (identical outputs) scores 1.0 with single unit weight", function()
+		local base = { TotalDPS = 1000 }
+		local new  = { TotalDPS = 1000 }
+		local weights = { { stat = "TotalDPS", weightMult = 1.0 } }
+		assert.are.equal(1.0, WeightedScore.computeRatioScore(base, new, weights))
+	end)
+
+	it("better candidate scores higher than neutral", function()
+		local base    = { TotalDPS = 1000 }
+		local better  = { TotalDPS = 1500 }
+		local weights = { { stat = "TotalDPS", weightMult = 1.0 } }
+		local score   = WeightedScore.computeRatioScore(base, better, weights)
+		assert.is_true(score > 1.0)
+		assert.are.equal(1.5, score)
+	end)
+
+	it("worse candidate scores lower than neutral", function()
+		local base    = { TotalDPS = 1000 }
+		local worse   = { TotalDPS = 500 }
+		local weights = { { stat = "TotalDPS", weightMult = 1.0 } }
+		local score   = WeightedScore.computeRatioScore(base, worse, weights)
+		assert.is_true(score < 1.0)
+		assert.are.equal(0.5, score)
+	end)
+
+	it("empty weights always scores 0", function()
+		local base = { TotalDPS = 1000 }
+		local new  = { TotalDPS = 5000 }
+		assert.are.equal(0.0, WeightedScore.computeRatioScore(base, new, {}))
+	end)
+
+	-- computeRatioScore: edge cases --------------------------------------------
+
+	it("infinite base stat contributes 0 (no crash)", function()
+		local base    = { TotalDPS = math.huge }
+		local new     = { TotalDPS = 1000 }
+		local weights = { { stat = "TotalDPS", weightMult = 1.0 } }
+		assert.are.equal(0.0, WeightedScore.computeRatioScore(base, new, weights))
+	end)
+
+	it("infinite new stat is capped at maxStatIncrease", function()
+		local base    = { TotalDPS = 1000 }
+		local new     = { TotalDPS = math.huge }
+		local weights = { { stat = "TotalDPS", weightMult = 1.0 } }
+		-- maxStatIncrease == 2 (set in before_each)
+		assert.are.equal(2.0, WeightedScore.computeRatioScore(base, new, weights))
+	end)
+
+	it("zero base stat treats denominator as 1 and caps at maxStatIncrease (no div-by-zero crash)", function()
+		local base    = { TotalDPS = 0 }
+		local new     = { TotalDPS = 500 }  -- 500/1 = 500, capped at 2
+		local weights = { { stat = "TotalDPS", weightMult = 1.0 } }
+		assert.are.equal(2.0, WeightedScore.computeRatioScore(base, new, weights))
+	end)
+
+	it("missing stat in both base and new scores 0 (no crash)", function()
+		local base    = {}
+		local new     = {}
+		local weights = { { stat = "TotalDPS", weightMult = 1.0 } }
+		-- 0/1 = 0
+		assert.are.equal(0.0, WeightedScore.computeRatioScore(base, new, weights))
+	end)
+
+	-- computeRatioScore: FullDPS fallback --------------------------------------
+
+	it("uses combined DPS fallback when FullDPS is absent from both outputs", function()
+		-- baseSum = 500+200+300 = 1000, newSum = 750+300+450 = 1500 → ratio 1.5
+		local base    = { TotalDPS = 500, TotalDotDPS = 200, CombinedDPS = 300 }
+		local new     = { TotalDPS = 750, TotalDotDPS = 300, CombinedDPS = 450 }
+		local weights = { { stat = "FullDPS", weightMult = 1.0 } }
+		assert.are.equal(1.5, WeightedScore.computeRatioScore(base, new, weights))
+	end)
+
+	it("does not activate fallback when FullDPS is present (no double-counting)", function()
+		-- If fallback also ran, score would be higher than 1.5 (the FullDPS ratio)
+		local base    = { FullDPS = 1000, TotalDPS = 500, TotalDotDPS = 200, CombinedDPS = 300 }
+		local new     = { FullDPS = 1500, TotalDPS = 750, TotalDotDPS = 300, CombinedDPS = 450 }
+		local weights = { { stat = "FullDPS", weightMult = 1.0 } }
+		-- Only FullDPS direct: 1500/1000 = 1.5
+		assert.are.equal(1.5, WeightedScore.computeRatioScore(base, new, weights))
+	end)
+
+	-- weightsNeedFullDPS: routing helper used by PowerBuilder ------------------
+
+	it("weightsNeedFullDPS returns false for nil weights", function()
+		assert.is_false(WeightedScore.weightsNeedFullDPS(nil))
+	end)
+
+	it("weightsNeedFullDPS returns false for empty weights", function()
+		assert.is_false(WeightedScore.weightsNeedFullDPS({}))
+	end)
+
+	it("weightsNeedFullDPS returns true when FullDPS is the only weight", function()
+		local weights = { { stat = "FullDPS", weightMult = 1.0 } }
+		assert.is_true(WeightedScore.weightsNeedFullDPS(weights))
+	end)
+
+	it("weightsNeedFullDPS returns false when only non-FullDPS weights are present", function()
+		local weights = {
+			{ stat = "TotalEHP", weightMult = 0.5 },
+			{ stat = "TotalDPS", weightMult = 1.0 },
+		}
+		assert.is_false(WeightedScore.weightsNeedFullDPS(weights))
+	end)
+
+	it("weightsNeedFullDPS returns true when FullDPS appears alongside other weights", function()
+		local weights = {
+			{ stat = "TotalEHP", weightMult = 0.5 },
+			{ stat = "FullDPS", weightMult = 1.0 },
+			{ stat = "Life", weightMult = 0.25 },
+		}
+		assert.is_true(WeightedScore.weightsNeedFullDPS(weights))
+	end)
+
+	it("weightsNeedFullDPS returns false when FullDPS weight is zero", function()
+		local weights = { { stat = "FullDPS", weightMult = 0 } }
+		assert.is_false(WeightedScore.weightsNeedFullDPS(weights))
+	end)
+
+	it("weightsNeedFullDPS returns false for custom-stat-only weights", function()
+		local weights = { { stat = "TotalAttr", weightMult = 1.0 } }
+		assert.is_false(WeightedScore.weightsNeedFullDPS(weights))
+	end)
+end)
+
+describe("WeightedScore — TradeQueryGenerator delegation", function()
+	local mock_queryGen = new("TradeQueryGenerator", {
+		itemsTab = {},
+		GetTradeStatusOption = function() return "online" end,
+	})
+
+	-- Pass: WeightedRatioOutputs returns the same value as calling
+	--       WeightedScore.computeRatioScore directly, confirming delegation
+	-- Fail: divergence would indicate the wrapper has extra logic or a copy-paste
+	it("WeightedRatioOutputs delegates to WeightedScore.computeRatioScore", function()
+		local savedMax = data.misc.maxStatIncrease
+		data.misc.maxStatIncrease = 2
+
+		local base    = { TotalDPS = 1000, TotalEHP = 500 }
+		local new     = { TotalDPS = 1200, TotalEHP = 600 }
+		local weights = { { stat = "TotalDPS", weightMult = 1.0 }, { stat = "TotalEHP", weightMult = 0.5 } }
+
+		local direct    = WeightedScore.computeRatioScore(base, new, weights)
+		local delegated = mock_queryGen.WeightedRatioOutputs(base, new, weights)
+
+		data.misc.maxStatIncrease = savedMax
+		assert.are.equal(direct, delegated)
+	end)
+
+	-- Pass: higher-stat candidate ranks above lower-stat candidate
+	-- Fail: regression in delegation would silently return 0 for all, making order random
+	it("higher-stat candidate ranks above lower-stat candidate", function()
+		local base    = { TotalDPS = 1000 }
+		local high    = { TotalDPS = 1500 }
+		local low     = { TotalDPS = 800 }
+		local weights = { { stat = "TotalDPS", weightMult = 1.0 } }
+
+		local highScore = mock_queryGen.WeightedRatioOutputs(base, high, weights)
+		local lowScore  = mock_queryGen.WeightedRatioOutputs(base, low,  weights)
+		assert.is_true(highScore > lowScore)
+	end)
+end)
+
+describe("WeightedScore — tree integration", function()
+	before_each(function()
+		newBuild()
+	end)
+
+	local function findStat(statName)
+		for _, stat in ipairs(data.powerStatList) do
+			if stat.stat == statName then return stat end
+		end
+	end
+
+	local function drainPowerBuild(stat)
+		build.calcsTab.powerBuildFlag = true
+		build.calcsTab.powerStat = stat or findStat("Life")
+		local maxIter = 100000
+		local iter = 0
+		repeat
+			build.calcsTab:BuildPower()
+			iter = iter + 1
+		until not build.calcsTab.powerBuilder or iter >= maxIter
+	end
+
+	-- Pass: WeightedScore entry is registered in the shared power stat list
+	-- Fail: missing registration would mean the mode never appears in the UI
+	it("WeightedScore entry exists in data.powerStatList with isWeightedScore flag", function()
+		local stat = findStat("WeightedScore")
+		assert.is_not_nil(stat)
+		assert.is_true(stat.isWeightedScore)
+	end)
+
+	-- Pass: power builder runs to completion without Lua error
+	-- Fail: a crash in CalculatePowerStat's isWeightedScore branch
+	it("power builder completes without error using WeightedScore stat", function()
+		local stat = findStat("WeightedScore")
+		assert.is_not_nil(stat)
+		drainPowerBuild(stat)
+		assert.is_true(build.calcsTab.powerBuilderInitialized)
+	end)
+
+	-- Pass: powerMax is initialized and singleStat is non-negative
+	-- Fail: negative singleStat would break heatmap colour scaling
+	it("powerMax.singleStat is non-negative after WeightedScore build", function()
+		drainPowerBuild(findStat("WeightedScore"))
+		assert.is_not_nil(build.calcsTab.powerMax)
+		assert.is_true(build.calcsTab.powerMax.singleStat >= 0)
+	end)
+
+	it("power report requests FullDPS for WeightedScore when active weights use FullDPS", function()
+		local stat = findStat("WeightedScore")
+		assert.is_not_nil(stat)
+
+		local originalGetMiscCalculator = build.calcsTab.GetMiscCalculator
+		local originalNodePowerMaxDepth = build.calcsTab.nodePowerMaxDepth
+		local calledUseFullDPS = { }
+		build.calcsTab.nodePowerMaxDepth = 1
+		build.calcsTab.GetMiscCalculator = function()
+			local function calcFunc(_, useFullDPS)
+				calledUseFullDPS[#calledUseFullDPS + 1] = useFullDPS
+				return {
+					FullDPS = 110,
+					TotalEHP = 100,
+					CombinedDPS = 0,
+					TotalDPS = 0,
+					TotalDotDPS = 0,
+				}
+			end
+			return calcFunc, {
+				FullDPS = 100,
+				TotalEHP = 100,
+				CombinedDPS = 0,
+				TotalDPS = 0,
+				TotalDotDPS = 0,
+			}
+		end
+
+		local ok, errMsg = pcall(function()
+			drainPowerBuild(stat)
+		end)
+		build.calcsTab.GetMiscCalculator = originalGetMiscCalculator
+		build.calcsTab.nodePowerMaxDepth = originalNodePowerMaxDepth
+
+		assert.is_true(ok, errMsg)
+		assert.is_true(#calledUseFullDPS > 0, "fixture should exercise candidate calculations")
+		for _, useFullDPS in ipairs(calledUseFullDPS) do
+			assert.is_true(useFullDPS)
+		end
+	end)
+
+	-- Pass: getValue returns a positive score when the new output is better than base
+	-- Fail: reading output["WeightedScore"] (non-existent field) would return 0, giving
+	--       weight1 = (0/1 - 1)*100 = -100 for every fallback node regardless of actual impact
+	it("getValue on WeightedScore entry returns positive score for better output", function()
+		local stat = findStat("WeightedScore")
+		assert.is_not_nil(stat)
+		assert.is_function(stat.getValue)
+		local calcFunc = build.calcsTab:GetMiscCalculator(build)
+		local baseOutput = calcFunc()
+		-- Synthesize a "better" output by doubling FullDPS relative to base
+		local betterOutput = setmetatable({}, { __index = baseOutput })
+		betterOutput.FullDPS = (baseOutput.FullDPS or 0) * 2 + 1
+		local baseScore   = stat.getValue(baseOutput, build)
+		local betterScore = stat.getValue(betterOutput, build)
+		assert.is_true(betterScore > baseScore)
+	end)
+
+	it("getValue on WeightedScore entry reuses provided calcBase", function()
+		local stat = findStat("WeightedScore")
+		assert.is_not_nil(stat)
+		assert.is_function(stat.getValue)
+
+		local originalGetMiscCalculator = build.calcsTab.GetMiscCalculator
+		local getMiscCalculatorCalls = 0
+		build.calcsTab.GetMiscCalculator = function()
+			getMiscCalculatorCalls = getMiscCalculatorCalls + 1
+			return function()
+				return { FullDPS = 1, TotalEHP = 1 }
+			end, { FullDPS = 1, TotalEHP = 1 }
+		end
+
+		local score = stat.getValue(
+			{ FullDPS = 120, TotalEHP = 100, TotalDPS = 0, TotalDotDPS = 0, CombinedDPS = 0 },
+			build,
+			{ FullDPS = 100, TotalEHP = 100, TotalDPS = 0, TotalDotDPS = 0, CombinedDPS = 0 }
+		)
+		build.calcsTab.GetMiscCalculator = originalGetMiscCalculator
+
+		assert.are.equal(0, getMiscCalculatorCalls)
+		assert.is_true(score > 0)
+	end)
+
+	-- Pass: getValue returns a non-zero base score (build has some meaningful output)
+	-- Fail: if getValue silently returned 0 for base, generateFallbackWeights would
+	--       set baseValue=1 and all weights would be computed against 1 instead of the
+	--       real build score, producing incorrect -100 values for all neutral nodes
+	it("getValue on WeightedScore entry returns non-zero score for current build output", function()
+		local stat = findStat("WeightedScore")
+		assert.is_not_nil(stat)
+		local calcFunc = build.calcsTab:GetMiscCalculator(build)
+		local baseOutput = calcFunc()
+		local score = stat.getValue(baseOutput, build)
+		assert.is_true(score ~= 0)
+	end)
+
+	-- Pass: fallbackWeightsList entries for WeightedScore carry getValue
+	-- Fail: if getValue is not copied into the dropdown entry, generateFallbackWeights
+	--       receives selection.getValue = nil and falls back to output["WeightedScore"]
+	--       which is always nil, producing weight = -100 for every node
+	it("WeightedScore fallbackWeightsList entry carries getValue callback", function()
+		local found = nil
+		for _, entry in pairs(data.powerStatList) do
+			if entry.stat == "WeightedScore" and not entry.ignoreForItems and entry.label ~= "Name" then
+				found = {
+					label = "Sort by " .. entry.label,
+					stat = entry.stat,
+					transform = entry.transform,
+					getValue = entry.getValue,
+				}
+				break
+			end
+		end
+		assert.is_not_nil(found, "WeightedScore entry should appear in fallbackWeightsList candidates")
+		assert.is_function(found.getValue, "getValue must be propagated into the dropdown entry")
+	end)
+
+	-- appendEditWeightsAction -----------------------------------------------
+
+	it("appendEditWeightsAction is a no-op when the list has no WeightedScore entry", function()
+		local list = {
+			{ label = "Sort by Name", sortMode = "name" },
+			{ label = "Sort by Life", sortMode = "Life" },
+		}
+		local called = false
+		WeightedScore.appendEditWeightsAction(list, function() called = true end)
+		assert.are.equal(2, #list)
+		assert.is_false(called)
+	end)
+
+	it("appendEditWeightsAction appends an action entry when WeightedScore is present", function()
+		local list = {
+			{ label = "Sort by Name", sortMode = "name" },
+			{ label = "Sort by Weighted Score", sortMode = "WeightedScore", isWeightedScore = true },
+		}
+		local opened = false
+		WeightedScore.appendEditWeightsAction(list, function() opened = true end)
+		assert.are.equal(3, #list)
+		local entry = list[3]
+		assert.is_true(entry.isAction)
+		assert.is_function(entry.action)
+		assert.is_string(entry.label)
+		entry.action()
+		assert.is_true(opened, "calling entry.action must invoke the openEditor callback")
+	end)
+end)
diff --git a/src/Classes/CalcsTab.lua b/src/Classes/CalcsTab.lua
index ce9303856d..a2ef605190 100644
--- a/src/Classes/CalcsTab.lua
+++ b/src/Classes/CalcsTab.lua
@@ -8,6 +8,7 @@ local ipairs = ipairs
 local t_insert = table.insert
 local m_max = math.max
 local m_floor = math.floor
+local WeightedScore = LoadModule("Modules/WeightedScore")
 
 local buffModeDropList = {
 	{ label = "Unbuffed", buffMode = "UNBUFFED" },
@@ -474,7 +475,11 @@ end
 -- Estimate the offensive and defensive power of all unallocated nodes
 function CalcsTabClass:PowerBuilder()
 	-- local timer_start = GetTime()
-	local useFullDPS = self.powerStat and self.powerStat.stat == "FullDPS"
+	local useFullDPS = self.powerStat and (
+		self.powerStat.stat == "FullDPS"
+		or (self.powerStat.isWeightedScore
+			and WeightedScore.weightsNeedFullDPS(WeightedScore.getWeights(self.build)))
+	)
 	local calcFunc, calcBase = self:GetMiscCalculator()
 	local cache = { }
 	local distanceMap = { }
@@ -614,6 +619,12 @@ function CalcsTabClass:PowerBuilder()
 end
 
 function CalcsTabClass:CalculatePowerStat(selection, original, modified)
+	if selection.isWeightedScore then
+		local weights = WeightedScore.getWeights(self.build)
+		local nodeScore = WeightedScore.computeRatioScore(modified, original, weights)
+		local baseScore = WeightedScore.computeRatioScore(modified, modified, weights)
+		return (nodeScore - baseScore) * 1000
+	end
 	if modified.Minion and selection.stat ~= "FullDPS" then
 		original = original.Minion
 		modified = modified.Minion
diff --git a/src/Classes/ItemDBControl.lua b/src/Classes/ItemDBControl.lua
index 3136d1a847..b2ae92ac00 100644
--- a/src/Classes/ItemDBControl.lua
+++ b/src/Classes/ItemDBControl.lua
@@ -8,7 +8,7 @@ local ipairs = ipairs
 local t_insert = table.insert
 local m_max = math.max
 local m_floor = math.floor
-
+local WeightedScore = LoadModule("Modules/WeightedScore")
 
 local ItemDBClass = newClass("ItemDBControl", "ListControl", function(self, anchor, rect, itemsTab, db, dbType)
 	self.ListControl(anchor, rect, 16, "VERTICAL", false)
@@ -36,7 +36,12 @@ local ItemDBClass = newClass("ItemDBControl", "ListControl", function(self, anch
 	end)
 	if dbType == "UNIQUE" then
 		self.controls.sort = new("DropDownControl", {"BOTTOMLEFT",self,"TOPLEFT"}, {0, baseY + 20, 179, 18}, self.sortDropList, function(index, value)
-			self:SetSortMode(value.sortMode)
+			if value.isAction then
+				value.action()
+				self.controls.sort:SelByValue(self.sortMode, "sortMode")
+			else
+				self:SetSortMode(value.sortMode)
+			end
 		end)
 		self.controls.league = new("DropDownControl", {"LEFT",self.controls.sort,"RIGHT"}, {2, 0, 179, 18}, self.leagueList, function(index, value)
 			self.listBuildFlag = true
@@ -198,9 +203,16 @@ function ItemDBClass:BuildSortOrder()
 				itemField=stat.itemField,
 				stat=stat.stat,
 				transform=stat.transform,
+				isWeightedScore=stat.isWeightedScore,
 			})
 		end
 	end
+	WeightedScore.appendEditWeightsAction(self.sortDropList, function()
+		local tq = self.itemsTab.tradeQuery
+		if tq then
+			tq:SetStatWeights(nil, function() self.listBuildFlag = true end)
+		end
+	end)
 	wipeTable(self.sortOrder)
 	if self.controls.sort then
 		self.controls.sort:CheckDroppedWidth(true)
@@ -222,7 +234,27 @@ function ItemDBClass:ListBuilder()
 		end
 	end
 
-	if self.sortDetail and self.sortDetail.stat then -- stat-based
+	if self.sortDetail and self.sortDetail.isWeightedScore then
+		local start = GetTime()
+		local calcFunc, calcBase = self.itemsTab.build.calcsTab:GetMiscCalculator(self.build)
+		local weights = WeightedScore.getWeights(self.itemsTab.build)
+		for itemIndex, item in ipairs(list) do
+			item.measuredPower = 0
+			for slotName, slot in pairs(self.itemsTab.slots) do
+				if self.itemsTab:IsItemValidForSlot(item, slotName) and not slot.inactive and (not slot.weaponSet or slot.weaponSet == (self.itemsTab.activeItemSet.useSecondWeaponSet and 2 or 1)) then
+					local output = calcFunc(item.base.flask and { toggleFlask = item } or item.base.tincture and { toggleTincture = item } or { repSlotName = slotName, repItem = item })
+					local score = WeightedScore.computeRatioScore(calcBase, output, weights)
+					item.measuredPower = m_max(item.measuredPower, score)
+				end
+			end
+			local now = GetTime()
+			if now - start > 50 then
+				self.defaultText = "^7Sorting... ("..m_floor(itemIndex/#list*100).."%)"
+				coroutine.yield()
+				start = now
+			end
+		end
+	elseif self.sortDetail and self.sortDetail.stat then -- stat-based
 		local useFullDPS = self.sortDetail.stat == "FullDPS"
 		local start = GetTime()
 		local calcFunc, calcBase = self.itemsTab.build.calcsTab:GetMiscCalculator(self.build)
diff --git a/src/Classes/NotableDBControl.lua b/src/Classes/NotableDBControl.lua
index d08ec4080c..c3c137d99e 100644
--- a/src/Classes/NotableDBControl.lua
+++ b/src/Classes/NotableDBControl.lua
@@ -11,6 +11,7 @@ local m_max = math.max
 local m_floor = math.floor
 local m_huge = math.huge
 local s_format = string.format
+local WeightedScore = LoadModule("Modules/WeightedScore")
 
 ---@param node table
 ---@return boolean
@@ -33,7 +34,12 @@ local NotableDBClass = newClass("NotableDBControl", "ListControl", function(self
 	self.sortOrder = { }
 	self.sortMode = "NAME"
 	self.controls.sort = new("DropDownControl", {"BOTTOMLEFT",self,"TOPLEFT"}, {0, -22, 360, 18}, self.sortDropList, function(index, value)
-		self:SetSortMode(value.sortMode)
+		if value.isAction then
+			value.action()
+			self.controls.sort:SelByValue(self.sortMode, "sortMode")
+		else
+			self:SetSortMode(value.sortMode)
+		end
 	end)
 	self.controls.search = new("EditControl", {"BOTTOMLEFT",self,"TOPLEFT"}, {0, -2, 258, 18}, "", "Search", "%c", 100, function()
 		self.listBuildFlag = true
@@ -95,9 +101,16 @@ function NotableDBClass:BuildSortOrder()
 				itemField=stat.itemField,
 				stat=stat.stat,
 				transform=stat.transform,
+				isWeightedScore=stat.isWeightedScore,
 			})
 		end
 	end
+	WeightedScore.appendEditWeightsAction(self.sortDropList, function()
+		local tq = self.itemsTab.tradeQuery
+		if tq then
+			tq:SetStatWeights(nil, function() self.listBuildFlag = true end)
+		end
+	end)
 	wipeTable(self.sortOrder)
 	if self.controls.sort then
 		self.controls.sort.selIndex = 1
@@ -139,12 +152,17 @@ function NotableDBClass:ListBuilder()
 		local calcFunc = self.itemsTab.build.calcsTab:GetMiscCalculator()
 		local itemType = self.itemsTab.displayItem.base.type
 		local calcBase = calcFunc({ repSlotName = itemType, repItem = self.itemsTab:anointItem(nil) })
+		local weights = self.sortDetail.isWeightedScore and WeightedScore.getWeights(self.itemsTab.build)
 		self.sortMaxPower = 0
 		for nodeIndex, node in ipairs(list) do
 			node.measuredPower = 0
 			if node.modKey ~= "" then
 				local output = calcFunc({ repSlotName = itemType, repItem = self.itemsTab:anointItem(node) })
-				node.measuredPower = self:CalculatePowerStat(self.sortDetail, output, calcBase)
+				if self.sortDetail.isWeightedScore then
+					node.measuredPower = WeightedScore.computeRatioScore(calcBase, output, weights)
+				else
+					node.measuredPower = self:CalculatePowerStat(self.sortDetail, output, calcBase)
+				end
 				if node.measuredPower == m_huge then
 					t_insert(infinites, node)
 				else
diff --git a/src/Classes/PowerReportListControl.lua b/src/Classes/PowerReportListControl.lua
index 0b08bdd60f..afef1a7317 100644
--- a/src/Classes/PowerReportListControl.lua
+++ b/src/Classes/PowerReportListControl.lua
@@ -102,6 +102,8 @@ function PowerReportListClass:ReList()
 		end
 		if self.allocated then
 			insert = item.allocated
+		elseif item.allocated then
+			insert = false
 		end
 
 		if insert then
diff --git a/src/Classes/TradeQuery.lua b/src/Classes/TradeQuery.lua
index 9e1308bfb9..d3a8ea4317 100644
--- a/src/Classes/TradeQuery.lua
+++ b/src/Classes/TradeQuery.lua
@@ -548,8 +548,12 @@ Highest Weight - Displays the order retrieved from trade]]
 end
 
 -- Popup to set stat weight multipliers for sorting
-function TradeQueryClass:SetStatWeights(previousSelectionList)
+function TradeQueryClass:SetStatWeights(previousSelectionList, onSave)
 	previousSelectionList = previousSelectionList or {}
+	if not self.statSortSelectionList or (#self.statSortSelectionList) == 0 then
+		self.statSortSelectionList = { }
+		initStatSortSelectionList(self.statSortSelectionList)
+	end
 	local controls = { }
 	local statList = { }
 	local sliderController = { index = 1 }
@@ -558,7 +562,7 @@ function TradeQueryClass:SetStatWeights(previousSelectionList)
 	controls.ListControl = new("TradeStatWeightMultiplierListControl", {"TOPLEFT", nil, "TOPRIGHT"}, {-410, 45, 400, 200}, statList, sliderController)
 
 	for id, stat in pairs(data.powerStatList) do
-		if not stat.ignoreForItems and stat.label ~= "Name" then
+		if not stat.ignoreForItems and stat.label ~= "Name" and not stat.isWeightedScore then
 			t_insert(statList, {
 				label = "0      :  "..stat.label,
 				stat = {
@@ -626,6 +630,7 @@ function TradeQueryClass:SetStatWeights(previousSelectionList)
 		for row_idx in pairs(self.resultTbl) do
 			self:UpdateControlsWithItems(row_idx)
 		end
+		if onSave then onSave() end
     end)
 	controls.cancel = new("ButtonControl", { "BOTTOM", nil, "BOTTOM" }, { 0, -10, 80, 20 }, "Cancel", function()
 		if previousSelectionList and #previousSelectionList > 0 then
diff --git a/src/Classes/TradeQueryGenerator.lua b/src/Classes/TradeQueryGenerator.lua
index eeb2fdeaab..46b4e9be73 100644
--- a/src/Classes/TradeQueryGenerator.lua
+++ b/src/Classes/TradeQueryGenerator.lua
@@ -5,6 +5,7 @@
 --
 
 local dkjson = require "dkjson"
+local WeightedScore = LoadModule("Modules/WeightedScore")
 local curl = require("lcurl.safe")
 local m_max = math.max
 local s_format = string.format
@@ -172,32 +173,7 @@ local function canModSpawnForItemCategory(mod, category)
 end
 
 function TradeQueryGeneratorClass.WeightedRatioOutputs(baseOutput, newOutput, statWeights)
-	local meanStatDiff = 0
-	local function ratioModSums(...)
-		local baseModSum = 0
-		local newModSum = 0
-		for _, mod in ipairs({ ... }) do
-			baseModSum = baseModSum + (baseOutput[mod] or 0)
-			newModSum = newModSum + (newOutput[mod] or 0)
-		end
-
-		if baseModSum == math.huge then
-			return 0
-		else
-			if newModSum == math.huge then
-				return data.misc.maxStatIncrease
-			else
-				return math.min(newModSum / ((baseModSum ~= 0) and baseModSum or 1), data.misc.maxStatIncrease)
-			end
-		end
-	end
-	for _, statTable in ipairs(statWeights) do
-		if statTable.stat == "FullDPS" and not (baseOutput["FullDPS"] and newOutput["FullDPS"]) then
-			meanStatDiff = meanStatDiff + ratioModSums("TotalDPS", "TotalDotDPS", "CombinedDPS") * statTable.weightMult
-		end
-		meanStatDiff = meanStatDiff + ratioModSums(statTable.stat) * statTable.weightMult
-	end
-	return meanStatDiff
+	return WeightedScore.computeRatioScore(baseOutput, newOutput, statWeights)
 end
 
 function TradeQueryGeneratorClass:ProcessMod(modId, mod, tradeQueryStatsParsed, itemCategoriesMask, itemCategoriesOverride)
diff --git a/src/Classes/TreeTab.lua b/src/Classes/TreeTab.lua
index 8e16490f57..2ad6092411 100644
--- a/src/Classes/TreeTab.lua
+++ b/src/Classes/TreeTab.lua
@@ -15,6 +15,7 @@ local m_min = math.min
 local m_floor = math.floor
 local m_abs = math.abs
 local s_format = string.format
+local WeightedScore = LoadModule("Modules/WeightedScore")
 local s_gsub = string.gsub
 local s_byte = string.byte
 local dkjson = require "dkjson"
@@ -250,7 +251,14 @@ local TreeTabClass = newClass("TreeTab", "ControlHost", function(self, build)
 
 	-- Control for selecting the power stat to sort by (Defense, DPS, etc)
 	self.controls.treeHeatMapStatSelect = new("DropDownControl", { "LEFT", self.controls.nodePowerMaxDepthSelect, "RIGHT" }, { 8, 0, 150, 20 }, nil, function(index, value)
-		self:SetPowerCalc(value)
+		if value.isAction then
+			value.action()
+			if self.build.calcsTab.powerStat then
+				self.controls.treeHeatMapStatSelect:SelByValue(self.build.calcsTab.powerStat.stat, "stat")
+			end
+		else
+			self:SetPowerCalc(value)
+		end
 	end)
 	self.controls.treeHeatMap.tooltipText = function()
 		local offCol, defCol = main.nodePowerTheme:match("(%a+)/(%a+)")
@@ -263,6 +271,12 @@ local TreeTabClass = newClass("TreeTab", "ControlHost", function(self, build)
 			t_insert(self.powerStatList, stat)
 		end
 	end
+	WeightedScore.appendEditWeightsAction(self.powerStatList, function()
+		local tq = self.build.itemsTab.tradeQuery
+		if tq then
+			tq:SetStatWeights(nil, function() self:SetPowerCalc(self.build.calcsTab.powerStat) end)
+		end
+	end)
 
 	-- Show/Hide Power Report Button
 	self.controls.powerReport = new("ButtonControl", { "LEFT", self.controls.treeHeatMapStatSelect, "RIGHT" }, { 8, 0, 150, 20 },
@@ -1835,29 +1849,37 @@ function TreeTabClass:FindTimelessJewel()
 	local function generateFallbackWeights(nodes, selection)
 		local calcFunc, calcBase = self.build.calcsTab:GetMiscCalculator(self.build)
 		local newList = { }
-		local baseOutput = calcFunc()
+		local baseRawOutput = calcFunc()
+		local baseOutput = baseRawOutput
 		if baseOutput.Minion then
 			baseOutput = baseOutput.Minion
 		end
-		local baseValue = baseOutput[selection.stat] or 1
-		if selection.transform then
-			baseValue = selection.transform(baseValue)
+		local function getStatValue(scopedOutput, rawOutput)
+			if selection.getValue then
+				return selection.getValue(rawOutput, self.build)
+			end
+			local value = scopedOutput[selection.stat] or 0
+			if selection.transform then
+				value = selection.transform(value)
+			end
+			return value
+		end
+		local baseValue = getStatValue(baseOutput, baseRawOutput)
+		if baseValue == 0 then
+			baseValue = 1
 		end
 		for _, newNode in ipairs(nodes) do
-			local output = nil
+			local rawOutput = nil
 			if newNode.calcMultiple then
-				output = calcFunc({ addNodes = { [newNode.node[1]] = true } })
+				rawOutput = calcFunc({ addNodes = { [newNode.node[1]] = true } })
 			else
-				output = calcFunc({ addNodes = { [newNode] = true } })
+				rawOutput = calcFunc({ addNodes = { [newNode] = true } })
 			end
-			if output.Minion then
-				output = output.Minion
+			local scopedOutput = rawOutput
+			if scopedOutput.Minion then
+				scopedOutput = scopedOutput.Minion
 			end
-			local outputValue = output[selection.stat] or 0
-			if selection.transform then
-				outputValue = selection.transform(outputValue)
-			end
-			outputValue = outputValue / baseValue
+			local outputValue = getStatValue(scopedOutput, rawOutput) / baseValue
 			if outputValue ~= outputValue then
 				outputValue = 1
 			end
@@ -1866,15 +1888,12 @@ function TreeTabClass:FindTimelessJewel()
 				weight1 = (outputValue - 1) / (newNode.divisor or 1)
 			})
 			if newNode.calcMultiple then
-				output = calcFunc({ addNodes = { [newNode.node[2]] = true } })
-				if output.Minion then
-					output = output.Minion
-				end
-				outputValue = output[selection.stat] or 0
-				if selection.transform then
-					outputValue = selection.transform(outputValue)
+				rawOutput = calcFunc({ addNodes = { [newNode.node[2]] = true } })
+				scopedOutput = rawOutput
+				if scopedOutput.Minion then
+					scopedOutput = scopedOutput.Minion
 				end
-				outputValue = outputValue / baseValue
+				outputValue = getStatValue(scopedOutput, rawOutput) / baseValue
 				if outputValue ~= outputValue then
 					outputValue = 1
 				end
@@ -2004,6 +2023,7 @@ function TreeTabClass:FindTimelessJewel()
 				label = "Sort by " .. stat.label,
 				stat = stat.stat,
 				transform = stat.transform,
+				getValue = stat.getValue,
 			})
 		end
 	end
diff --git a/src/Modules/Data.lua b/src/Modules/Data.lua
index 4923986364..bf17d107c3 100644
--- a/src/Modules/Data.lua
+++ b/src/Modules/Data.lua
@@ -6,6 +6,7 @@
 
 LoadModule("Data/Global")
 
+local WeightedScore = LoadModule("Modules/WeightedScore")
 local m_min = math.min
 local m_max = math.max
 local m_floor = math.floor
@@ -158,6 +159,15 @@ data.powerStatList = {
 	{ stat="BlockChance", label="Block Chance" },
 	{ stat="SpellBlockChance", label="Spell Block Chance" },
 	{ stat="SpellSuppressionChance", label="Spell Suppression Chance" },
+	{ stat="WeightedScore", label="Weighted Score", isWeightedScore=true, getValue=function(output, build, calcBase)
+		local weights = WeightedScore.getWeights(build)
+		local buildBase = calcBase
+		if not buildBase then
+			local _, cachedBuildBase = build.calcsTab:GetMiscCalculator()
+			buildBase = cachedBuildBase
+		end
+		return WeightedScore.computeRatioScore(buildBase, output, weights) * 1000
+	end },
 }
 
 data.misc = { -- magic numbers
diff --git a/src/Modules/WeightedScore.lua b/src/Modules/WeightedScore.lua
new file mode 100644
index 0000000000..0eb0cdc403
--- /dev/null
+++ b/src/Modules/WeightedScore.lua
@@ -0,0 +1,93 @@
+-- Path of Building
+--
+-- Module: Weighted Score
+-- Shared weighted stat score computation and weight management.
+-- Used by Trade Query, Unique Item DB, Gem Upgrade Report, and Tree heatmap.
+--
+
+local WeightedScore = {}
+
+-- Default stat weight configuration used when no custom weights are saved.
+function WeightedScore.defaultWeights()
+	return {
+		{ stat = "FullDPS", label = "Full DPS", weightMult = 1.0 },
+		{ stat = "TotalEHP", label = "Effective Hit Pool", weightMult = 0.5 },
+	}
+end
+
+-- Returns the current stat weight list from the build's trade query settings,
+-- falling back to defaults if none are configured or the build is not available.
+function WeightedScore.getWeights(build)
+	local tq = build and build.itemsTab and build.itemsTab.tradeQuery
+	if tq and tq.statSortSelectionList and #tq.statSortSelectionList > 0 then
+		return tq.statSortSelectionList
+	end
+	return WeightedScore.defaultWeights()
+end
+
+-- Returns true when any active weight targets FullDPS, so callers can route
+-- through the FullDPS-aware calculation path.
+function WeightedScore.weightsNeedFullDPS(weights)
+	if not weights then
+		return false
+	end
+	for _, statTable in ipairs(weights) do
+		if statTable and statTable.stat == "FullDPS" and (statTable.weightMult == nil or statTable.weightMult ~= 0) then
+			return true
+		end
+	end
+	return false
+end
+
+-- Compute a weighted ratio score comparing newOutput to baseOutput.
+-- Each stat contributes: weight * (newOutput[stat] / baseOutput[stat]).
+-- A neutral candidate (same as base) scores approximately sum(weights).
+-- Higher score means the candidate is better.
+-- Missing or zero stats are handled safely (no crash, no infinite values).
+function WeightedScore.computeRatioScore(baseOutput, newOutput, weights)
+	local meanStatDiff = 0.0
+	local function ratioModSums(...)
+		local baseModSum = 0
+		local newModSum = 0
+		for _, mod in ipairs({ ... }) do
+			baseModSum = baseModSum + (baseOutput[mod] or 0)
+			newModSum = newModSum + (newOutput[mod] or 0)
+		end
+		if baseModSum == math.huge then
+			return 0
+		elseif newModSum == math.huge then
+			return data.misc.maxStatIncrease
+		else
+			return math.min(newModSum / ((baseModSum ~= 0) and baseModSum or 1), data.misc.maxStatIncrease)
+		end
+	end
+	for _, statTable in ipairs(weights) do
+		if statTable.stat == "FullDPS" and not (baseOutput["FullDPS"] and newOutput["FullDPS"]) then
+			-- FullDPS fallback: use combined DPS components when FullDPS is not directly available
+			meanStatDiff = meanStatDiff + (ratioModSums("TotalDPS", "TotalDotDPS", "CombinedDPS") or 0) * statTable.weightMult
+		end
+		meanStatDiff = meanStatDiff + (ratioModSums(statTable.stat) or 0) * statTable.weightMult
+	end
+	return meanStatDiff
+end
+
+-- Append a contextual "Edit Weights..." action to a sort dropdown list when the
+-- list contains the WeightedScore entry. Lets every WS-aware sort surface share
+-- the same affordance without each one adding its own button.
+function WeightedScore.appendEditWeightsAction(sortDropList, openEditor)
+	local hasWeightedScore = false
+	for _, entry in ipairs(sortDropList) do
+		if entry.isWeightedScore then
+			hasWeightedScore = true
+			break
+		end
+	end
+	if not hasWeightedScore then return end
+	table.insert(sortDropList, {
+		label = colorCodes.TIP .. "Edit Weights...",
+		isAction = true,
+		action = openEditor,
+	})
+end
+
+return WeightedScore