Add support for Idolatry and change how Bonded lines are parsed

Export Bonded modifiers into separate rune data sub-tables instead of
adding "Bonded:" as a line prefix.
Fix export of some Bonded mods that had separate stat entries that were not being combined. e.g. Perfect Resolve Rune did not add the bonded mods for armour, weapons, wands and staves

Rebuild rune mods from rune data, keeping Bonded
lines unparsed until they are enabled.
Add support for the global `CanUseBonded` flag and the item-local Idol-only unlock, including socketed augment effect scaling.

Add tests for many of the new changes.
This now fixes all the mods that didn't parse correctly before because they were not a piece-meal mod and required explicit "Bonded:" ModParser lines

Author: LocalIdentity

spec/System/TestIdolatry_spec.lua

@@ -59,7 +59,7 @@ describe("TestIdolatry", function()
 	end)
 
 	-- Parsing: the three stat lines must resolve to mods that scale against those multipliers.
-	it("parses the three Idolatry stat lines", function()
+	it("parses Idolatry and bonded-idol stat lines", function()
 		local parseMod = LoadModule("Modules/ModParser")
 
 		-- Helper to find the Multiplier tag on a mod (tags are stored as array entries)
@@ -98,5 +98,85 @@ describe("TestIdolatry", function()
 		assert.are.equals("BASE", resist[1].type)
 		assert.are.equals(-4, resist[1].value)
 		assert.are.equals("NonIdolAugmentsInEquipment", multiplierTag(resist[1]).var)
+
+		-- 4) Fox Idol's unlock is an item-local flag, not a global condition.
+		local localUnlock = parseMod("Idols socketed in this item gain the benefits of their Bonded modifiers")
+		assert.are.equals(1, #localUnlock)
+		assert.are.equals("SocketedIdolsUseBondedModifiers", localUnlock[1].name)
+		assert.are.equals("FLAG", localUnlock[1].type)
+
+		-- 5) The ascendancy unlock is a flag consumed by calc setup, not a condition on each bonded mod.
+		local globalUnlock = parseMod("Gain the benefits of Bonded modifiers on Runes and Idols")
+		assert.are.equals(1, #globalUnlock)
+		assert.are.equals("CanUseBonded", globalUnlock[1].name)
+		assert.are.equals("FLAG", globalUnlock[1].type)
+	end)
+
+	it("enables only Idol Bonded modifiers from Fox Idol locally", function()
+		local item = new("Item", [[
+			Test Body
+			Rusted Cuirass
+		]])
+		item.itemSocketCount = 2
+		item.runes = { "Fox Idol", "Lesser Body Rune" }
+		item:UpdateRunes()
+		item:BuildAndParseRaw()
+		assert.is_true(item.socketedIdolsUseBondedModifiers)
+
+		local foxBondedLine
+		local bodyRuneBondedLife
+		for _, modLine in ipairs(item.runeModLines) do
+			if modLine.line == "Bonded: +5% to Quality of all Skills" then
+				foxBondedLine = modLine
+			end
+			if modLine.line == "Bonded: +20 to maximum Life" then
+				bodyRuneBondedLife = modLine
+			end
+		end
+		assert.is_not_nil(foxBondedLine)
+		assert.are.equals(0, #foxBondedLine.modList)
+		assert.is_not_nil(bodyRuneBondedLife)
+		assert.are.equals(0, #bodyRuneBondedLife.modList)
+
+		build.itemsTab:AddItem(item)
+		build.buildFlag = true
+		runCallback("OnFrame")
+
+		local modDB = build.calcsTab.mainEnv.itemModDB
+		local foxBondedQuality
+		for _, mod in ipairs(modDB.mods.GemProperty or { }) do
+			if mod.value.value == 5 and mod.source == item.modSource then
+				foxBondedQuality = mod
+				break
+			end
+		end
+		assert.is_not_nil(foxBondedQuality)
+		assert.is_not_nil(foxBondedLine.bondedModList)
+		assert.is_nil(bodyRuneBondedLife.bondedModList)
+
+		for _, mod in ipairs(modDB.mods.Life or { }) do
+			assert.is_false(mod.type == "BASE" and mod.value == 20 and mod.source == item.modSource)
+		end
+	end)
+
+	it("enables and scales Bonded modifiers from the ascendancy flag", function()
+		build.spec.allocNodes[42253] = build.spec.nodes[42253] -- Wisdom of the Maji
+
+		local item = new("Item", [[
+			Test Body
+			Rusted Cuirass
+			200% increased effect of Socketed Runes
+		]])
+		item.itemSocketCount = 1
+		item.runes = { "Lesser Body Rune" }
+		item:UpdateRunes()
+		item:BuildAndParseRaw()
+		build.itemsTab:AddItem(item)
+		build.buildFlag = true
+		runCallback("OnFrame")
+
+		local modDB = build.calcsTab.mainEnv.itemModDB
+		assert.are.equals(150, modDB:Sum("BASE", nil, "Life"))
+		assert.are.equals(60, modDB:Sum("BASE", nil, "Mana"))
 	end)
 end)

spec/System/TestItemParse_spec.lua

@@ -659,10 +659,15 @@ describe("TestItemParse", function()
 
 		assert.are.equals(3, item.itemSocketCount)
 		assert.are.same({ "Greater Glacial Rune", "Lesser Body Rune" }, item.runes)
-		assert.are.equals(1, item.runeModLines[1].runeCount)
-		assert.are.equals(1, item.runeModLines[2].runeCount)
-		assert.is_nil(item.runeModLines[3].runeCount)
-		assert.is_nil(item.runeModLines[4].runeCount)
+		local runeLines = { }
+		for _, modLine in ipairs(item.runeModLines) do
+			runeLines[modLine.line] = true
+		end
+		assert.are.equals(4, #item.runeModLines)
+		assert.is_true(runeLines["Adds 9 to 15 Cold Damage"])
+		assert.is_true(runeLines["Leeches 3% of Physical Damage as Life"])
+		assert.is_true(runeLines["Bonded: 5% increased maximum Life"])
+		assert.is_true(runeLines["Bonded: 30% increased Freeze Buildup"])
 		for _, rune in ipairs(item.runes) do
 			assert.are_not.equals("Lesser Glacial Rune", rune)
 		end
@@ -682,6 +687,8 @@ describe("TestItemParse", function()
 		assert.are.equals("+30 to maximum Life", item.runeModLines[1].line)
 		assert.are.equals("Bonded: +20 to maximum Life", item.runeModLines[2].line)
 		assert.are.equals("Bonded: +20 to maximum Mana", item.runeModLines[3].line)
+		assert.are.equals(0, #item.runeModLines[2].modList)
+		assert.are.equals(0, #item.runeModLines[3].modList)
 	end)
 
 	it("applies increased effect of socketed runes", function()

spec/System/TestItemsTab_spec.lua

@@ -722,6 +722,25 @@ describe("TestItemsTab", function()
 				assert.are.equals("Hits against you have 20% reduced Critical Damage Bonus", ticabaRune.lines[1])
 				assert.are.equals("Hits against you have 20% reduced Critical Damage Bonus", ticabaRune.lines[2])
 			end)
+
+			it("uses the regular rune mod as the dropdown label", function ()
+				local weaponMods = data.itemMods.Runes["Perfect Robust Rune"].weapon
+				assert.are.equals("+15 to Strength", weaponMods[1])
+				assert.are.same({ "Adds 6 to 10 Physical Damage to Attacks", "Adds 6 to 10 Fire damage to Attacks" }, { unpack(weaponMods.bonded) })
+
+				local item = new("Item", [[
+					Test Wand
+					Runic Fork
+				]])
+
+				for _, rune in ipairs(build.itemsTab:GetValidRunesForItem(item)) do
+					if rune.name == "Perfect Robust Rune" then
+						assert.are.equals("+15 to Strength", rune.label)
+						return
+					end
+				end
+				assert.fail("Perfect Robust Rune was not valid for a wand")
+			end)
 		end)
 
 		it("does nothing when no matching item is equipped", function ()

spec/System/TestSocketables_spec.lua

@@ -6,13 +6,19 @@ describe("TestSocketables", function()
     -- Item Tab display Tests
     -- Also checks slot type runes
 
-    local extractNamesFromModRunes = function(slotType) 
+    local extractNamesFromModRunes = function(item)
         local modRunes = LoadModule("../src/Data/ModRunes")
         local names = { }
+        local baseType, specificType = item:GetSocketedAugmentTypes()
         for name, rune in pairs(modRunes) do
-            for runeSlotType, mods in pairs(rune) do
-                if runeSlotType == slotType then
-                    table.insert(names, name)
+            if rune[baseType] or rune[specificType] then
+                names[name] = true
+            else
+                for soulCoreType in pairs(item.socketedSoulCoreTypes) do
+                    if rune[soulCoreType] and rune[soulCoreType].type == "SoulCore" then
+                        names[name] = true
+                        break
+                    end
                 end
             end
         end
@@ -23,36 +29,23 @@ describe("TestSocketables", function()
         -- ConPrintf("Testing: %s", slotType)
         local itemRaw = "Test\n" .. itemBase .. "\nSockets: S"
 
-        local modRunes = extractNamesFromModRunes(slotType)
-
         -- Create an ItemTab and add a socketable item to it
         local item = new("Item", itemRaw)
+        local modRunes = extractNamesFromModRunes(item)
 
         build.itemsTab:AddItem(item)
         build.itemsTab:SetDisplayItem(item)
         runCallback("OnFrame")
 
-        -- Extract the proper slot type runes from the list
+        -- The dropdown combines broad and specific slot types, then deduplicates by name.
+        -- Compare that exact union so both missing and incorrectly included runes fail.
         local itemTabRunes = { }
         for _, rune in ipairs(build.itemsTab.controls["displayItemRune1"].list) do
-            if rune.slot == slotType then
-                table.insert(itemTabRunes, rune.name)
-            end
-        end
-        -- To keep the test fast, only check that the lengths match
-        -- This should also catch issues with multi-mod line runes since the rune name will appear
-        -- for the number of mod lines that the rune has.
-        if #itemTabRunes ~= #modRunes then
-            ConPrintf("Item Tab Runes for slot type '%s':", slotType)
-            for _, name in ipairs(itemTabRunes) do
-                ConPrintf("  %s", name)
-            end
-            ConPrintf("Mod Runes for slot type '%s':", slotType)
-            for _, name in ipairs(modRunes) do
-                ConPrintf("  %s", name)
+            if rune.name ~= "None" then
+                itemTabRunes[rune.name] = true
             end
         end
-        assert.are.equals(#itemTabRunes, #modRunes, "Mismatch in number of runes for slot type: " .. slotType)
+        assert.are.same(modRunes, itemTabRunes, "Rune list mismatch for slot type: " .. slotType)
     end
 
     -- Note: Except for weapon/armour/caster,
@@ -113,4 +106,4 @@ describe("TestSocketables", function()
 
     -- it("'Dagger' runes appear in Items tab", slotTypeTest("dagger", ""))
 
-end)
+end)