#2008 Use the version selected for the content

A sequence with Default = 2 and Delves/Scenarios = 2 ran version 1 in a
delve. Two faults combine.

The editor stored a pick equal to the Default as nil, on the assumption
that an absent key resolves to the Default anyway. It does not: in
GetActiveSequenceVersion an absent key means "this rule does not match",
so the loop continues and a LOWER-priority rule claims the content.
Store what the author picked. Editor_Tree re-applied the same rule after
a version reorder, so it did that too.

The rule that then caught everything was Party. GSE.inParty is
IsInGroup(), true inside every delve, dungeon, raid and arena, and Party
is the last entry in the priority list -- so it picked up any instance
whose own rule stored no version. Party means in a party in the WORLD:
skip it when any instance context is active. It still applies grouped in
the world.

The same loop also let junk values win, since 9a17df9 replaced
`not GSE.isEmpty(meta[ctx.metaKey])` with bare truthiness and both "" and
0 are truthy in Lua: 0 resolved to version 1 via the trailing zero check,
"" resolved to "", and the PVP row (which tests PVP but reads Arena)
resolved to nil for PVP set in an arena with no Arena version. A context
now claims the sequence only when its key AND the value it actually reads
name a real version.

Lastly, inParty was only refreshed on a zone change, so joining or
leaving a group left the sequence on the version for the group state it
no longer had.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: LarryThiessen

GSE/API/Events.lua

@@ -1588,6 +1588,15 @@ function GSE:PLAYER_TALENT_UPDATE()
 end
 
 function GSE:GROUP_ROSTER_UPDATE(...)
+    -- inParty is read by the version resolver but was only refreshed on a zone
+    -- change, so joining or leaving a group in the same zone left the sequence
+    -- on the version for the group state it no longer had. Re-resolve when the
+    -- state actually flips -- not on every roster tick.
+    local grouped = IsInGroup() and true or false
+    if grouped ~= GSE.inParty then
+        GSE.inParty = grouped
+        GSE.ReloadSequences()
+    end
     -- Serialisation stuff
     GSE.sendVersionCheck()
     for k, _ in pairs(GSE.UnsavedOptions["PartyUsers"]) do

GSE/API/Storage.lua

@@ -1145,11 +1145,32 @@ function GSE.GetActiveSequenceVersion(sequenceName)
     if not GSE.isEmpty(meta.PVESolo) and isPVESoloContext() then
         vers = meta.PVESolo
     end
+    -- "Party" means in a party IN THE WORLD, but GSE.inParty is IsInGroup(),
+    -- which is equally true inside every delve, dungeon and raid. It is also the
+    -- LAST rule, so it used to pick up any instance whose own rule named no
+    -- version -- claiming content the author had configured elsewhere. Instance
+    -- content is never "the world": rule it out there.
+    local inInstanceContent = GSE.inScenario or GSE.inRaid or GSE.inDungeon
+        or GSE.inHeroic or GSE.inMythic or GSE.inMythicPlus or GSE.inTimeWalking
+        or GSE.inArena
     for _, ctx in ipairs(contextVersionPriority) do
-        if meta[ctx.metaKey] and GSE[ctx.flag] then
-            vers = meta[ctx.valueKey]
+        if ctx.flag == "inParty" and inInstanceContent then
             break
         end
+        -- A context only claims the sequence if it names a REAL version. Bare
+        -- truthiness is not enough: "" and 0 are both truthy in Lua, so a key
+        -- left empty by an import or an older save would win here and resolve
+        -- to nothing (or to 1, via the zero check below) instead of falling
+        -- through to the Default. The VALUE is checked too, not just the key,
+        -- because a row can read a different field than it tests -- PVP tested
+        -- in an arena reads Arena, which may never have been set.
+        if GSE[ctx.flag] and not GSE.isEmpty(meta[ctx.metaKey]) and meta[ctx.metaKey] ~= 0 then
+            local contextVersion = meta[ctx.valueKey]
+            if not GSE.isEmpty(contextVersion) and contextVersion ~= 0 then
+                vers = contextVersion
+                break
+            end
+        end
     end
     return (vers == 0) and 1 or vers
 end

GSE_GUI/Editor_Metadata.lua

@@ -940,14 +940,16 @@ local function drawMetadataTab(editframe, container)
         dd:SetCallback(
             "OnValueChanged",
             function(obj, event, key)
-                if editframe.Sequence.MetaData.Default == tonumber(key) then
-                    editframe.Sequence.MetaData[metaKey] = nil
-                else
-                    editframe.Sequence.MetaData[metaKey] = tonumber(key)
-                    -- PVP also mirrors editframe.PVP (original behaviour)
-                    if metaKey == "PVP" then
-                        editframe.PVP = tonumber(key)
-                    end
+                -- Store what the author picked, even when it equals the Default.
+                -- Dropping it looked harmless (both resolve to the same version
+                -- today) but it is not: an unset context falls THROUGH to the
+                -- next matching rule, so a lower-priority key -- Party, say --
+                -- silently wins the content the author just configured. It also
+                -- means the setting quietly follows any later Default change.
+                editframe.Sequence.MetaData[metaKey] = tonumber(key)
+                -- PVP also mirrors editframe.PVP (original behaviour)
+                if metaKey == "PVP" then
+                    editframe.PVP = tonumber(key)
                 end
             end
         )

GSE_GUI/Editor_Tree.lua

@@ -1645,20 +1645,16 @@ local function ManageTree(editframe)
             end
 
             -- Update all MetaData fields that hold a version index.
-            -- Context keys that equal Default are stored as nil; re-apply that rule
-            -- after remapping (mirrors the editor's OnValueChanged logic).
             seq.MetaData.Default = remapVersionIndex(seq.MetaData.Default)
             local contextKeys = {
                 "Raid", "Arena", "Mythic", "MythicPlus", "PVP",
                 "Heroic", "Dungeon", "Timewalking", "Party", "Scenario",
             }
             for _, k in ipairs(contextKeys) do
-                local remapped = remapVersionIndex(seq.MetaData[k])
-                if remapped == seq.MetaData.Default then
-                    seq.MetaData[k] = nil
-                else
-                    seq.MetaData[k] = remapped
-                end
+                -- Keep a context key that equals the Default (see the editor's
+                -- OnValueChanged): dropping it lets a lower-priority key win
+                -- that content instead.
+                seq.MetaData[k] = remapVersionIndex(seq.MetaData[k])
             end
 
             -- Mirror the reorder into the Library copy so ManageTree() draws the