farming-weight 0.14.2 → 0.15.0

package/dist/player/player.js

@@ -1,22 +1,31 @@
 import { normalizeAttributes } from '../constants/attributes.js';
 import { getChipInputLevel, getChipLevel, getChipTempMultiplierPerLevel, normalizeChipId, normalizeChipLevels, } from '../constants/chips.js';
 import { CROP_INFO } from '../constants/crops.js';
+import { compareRarity } from '../constants/reforge-types.js';
 import { getContributoryStats, Stat } from '../constants/stats.js';
 import { TEMPORARY_FORTUNE } from '../constants/tempfortune.js';
-import { UpgradeAction, UpgradeCategory } from '../constants/upgrades.js';
+import { getQueryStats, UpgradeAction, UpgradeCategory, } from '../constants/upgrades.js';
+import { buildEffectEnvironment } from '../effects/environment.js';
+import { resolveOverbloomBreakdown, resolveStatBreakdown } from '../effects/resolver.js';
+import { effectsToSummaries } from '../effects/summary.js';
 import { FarmingAccessory } from '../fortune/farmingaccessory.js';
 import { ArmorSet, FarmingArmor } from '../fortune/farmingarmor.js';
 import { FarmingEquipment } from '../fortune/farmingequipment.js';
 import { FarmingPet } from '../fortune/farmingpet.js';
 import { FarmingTool } from '../fortune/farmingtool.js';
 import { FarmingPets } from '../items/pets.js';
+import { FARMING_ATTRIBUTE_SHARD_CLASSES } from '../items/sources/attributes.js';
+import { GARDEN_CHIP_CLASSES } from '../items/sources/chips.js';
 import { FARMING_TOOLS } from '../items/tools.js';
 import { getSourceProgress } from '../upgrades/getsourceprogress.js';
+import { withGroupedUpgrades } from '../upgrades/groups.js';
 import { getFakeItem } from '../upgrades/itemregistry.js';
 import { CROP_FORTUNE_SOURCES } from '../upgrades/sources/cropsources.js';
+import { collectCropFortuneSourceEffects, collectGeneralFortuneSourceEffects, } from '../upgrades/sources/effectsources.js';
 import { GENERAL_FORTUNE_SOURCES } from '../upgrades/sources/generalsources.js';
 import { filterAndSortUpgrades } from '../upgrades/upgradeutils.js';
-import { calculateDetailedDrops } from '../util/ratecalc.js';
+import { nextRarity, previousRarity } from '../util/itemstats.js';
+import { calculateDetailedDropsFromEffects } from '../util/ratecalc-effects.js';
 import { createFarmingWeightCalculator } from '../weight/weightcalc.js';
 export function createFarmingPlayer(options) {
     return new FarmingPlayer(options);
@@ -125,9 +134,11 @@ export class FarmingPlayer {
         let pool = [];
         if (this.options.accessories[0] instanceof FarmingAccessory) {
             pool = this.options.accessories.sort((a, b) => b.fortune - a.fortune);
+            for (const acc of pool)
+                acc.setOptions(this.options);
         }
         else {
-            pool = FarmingAccessory.fromArray(this.options.accessories);
+            pool = FarmingAccessory.fromArray(this.options.accessories, this.options);
         }
         // Filter by unique family (keep highest rarity/fortune)
         const familyMap = new Map();
@@ -147,15 +158,21 @@ export class FarmingPlayer {
         this.activeAccessories = [...familyMap.values(), ...others].sort((a, b) => b.fortune - a.fortune);
         this.accessories = pool;
     }
+    syncActiveAccessories() {
+        this.options.accessories = this.accessories;
+        this.populateActiveAccessories();
+    }
     changeArmor(armor) {
         this.armorSet = new ArmorSet(armor.sort((a, b) => b.fortune - a.fortune));
     }
     selectTool(tool) {
         this.selectedTool = tool;
+        this.options.selectedTool = tool;
         this.permFortune = this.getGeneralFortune();
     }
     selectPet(pet) {
         this.selectedPet = pet;
+        this.options.selectedPet = pet;
         this.permFortune = this.getGeneralFortune();
     }
     setStrength(strength) {
@@ -168,14 +185,47 @@ export class FarmingPlayer {
     getProgress(stats) {
         return getSourceProgress(this, GENERAL_FORTUNE_SOURCES, false, stats);
     }
+    getPetProgress(stats) {
+        return this.pets.flatMap((pet) => pet.getProgress(stats, this));
+    }
     getUpgrades(options) {
-        const stats = options?.stat ? [options.stat] : undefined;
+        const hasExplicitStats = (options?.stats?.length ?? 0) > 0 || options?.stat !== undefined;
+        const stats = hasExplicitStats ? getQueryStats(options) : undefined;
         const upgrades = getSourceProgress(this, GENERAL_FORTUNE_SOURCES, false, stats).flatMap((source) => source.upgrades ?? []);
         const armorSetUpgrades = this.armorSet.getUpgrades(options);
         if (armorSetUpgrades.length > 0) {
             upgrades.push(...armorSetUpgrades);
         }
-        return filterAndSortUpgrades(upgrades, options);
+        // For non-FarmingFortune stats (e.g. Overbloom), tool upgrades aren't tied to a single
+        // crop and won't be surfaced by getCropUpgrades, so include them here.
+        if (stats?.some((stat) => stat !== Stat.FarmingFortune)) {
+            const tools = this.options.selectedCrop !== undefined
+                ? [this.getSelectedCropTool(this.options.selectedCrop)].filter((tool) => tool !== undefined)
+                : this.tools;
+            for (const tool of tools) {
+                upgrades.push(...tool.getUpgrades(options));
+            }
+        }
+        const filtered = filterAndSortUpgrades(upgrades, options);
+        return options?.includeUpgradeGroups ? withGroupedUpgrades(filtered) : filtered;
+    }
+    getStatView(query) {
+        const stats = query.stats.length > 0 ? query.stats : [Stat.FarmingFortune];
+        const totals = {};
+        const breakdowns = {};
+        for (const stat of stats) {
+            totals[stat] = this.getStat(stat, query.crop);
+            breakdowns[stat] = this.getStatBreakdown(stat, query.crop);
+        }
+        const env = this.buildEnvironment(query.crop);
+        const effects = effectsToSummaries(this.collectEffects(env), stats);
+        const upgrades = this.getUpgrades({ stats });
+        return {
+            totals,
+            breakdowns,
+            effects,
+            upgrades,
+        };
     }
     getCropUpgrades(crop, tool) {
         const upgrades = [];
@@ -196,16 +246,25 @@ export class FarmingPlayer {
             const startingInfo = FARMING_TOOLS[CROP_INFO[crop].startingTool];
             if (startingInfo) {
                 const fakeItem = getFakeItem(startingInfo.skyblockId, this.options);
+                const startingToolFortune = fakeItem?.getStat(CROP_INFO[crop].fortuneType, crop) ?? 0;
                 upgrades.push({
                     title: startingInfo.name,
                     action: UpgradeAction.Purchase,
-                    increase: fakeItem?.getFortune() ?? 0,
+                    increase: startingToolFortune,
+                    stats: {
+                        [CROP_INFO[crop].fortuneType]: startingToolFortune,
+                    },
                     wiki: startingInfo.wiki,
+                    purchase: startingInfo.skyblockId,
                     max: fakeItem?.getProgress()?.reduce((acc, p) => acc + p.max, 0) ?? 0,
                     category: UpgradeCategory.Item,
                     cost: {
                         copper: 250,
                     },
+                    meta: {
+                        type: 'buy_item',
+                        id: startingInfo.skyblockId,
+                    },
                 });
             }
         }
@@ -227,8 +286,68 @@ export class FarmingPlayer {
         }
         return val;
     }
-    getStat(stat) {
-        const breakdown = this.getStatBreakdown(stat);
+    /**
+     * Build the canonical {@link EffectEnvironment} for this player + crop.
+     * Thin wrapper over {@link buildEffectEnvironment}; provided so callers
+     * never have to import the helper directly.
+     */
+    buildEnvironment(crop) {
+        return buildEffectEnvironment(this, crop);
+    }
+    /**
+     * Aggregate the declarative {@link Effect}[] from every active source on
+     * the player: armor set (armor + equipment + set bonuses, including each
+     * piece's reforge & enchants), the selected tool, active accessories, the
+     * selected pet, every attribute shard, and every garden chip.
+     *
+     * Sources with a `getActive` guard that returns `active: false` are
+     * skipped. Sources whose `getEffects` returns `[]` contribute nothing.
+     *
+     * This method is the single seam consumed by the new effect-resolver
+     * pipeline (`getStat`, `getRates`). It does **not** apply scopes - that's
+     * the resolver's job - so the returned list includes every effect the
+     * player could plausibly emit, with their declarative scopes intact.
+     */
+    collectEffects(env) {
+        const effects = [];
+        effects.push(...collectGeneralFortuneSourceEffects(this));
+        // Armor set: armor pieces, equipment pieces, and set bonuses.
+        // (Per-piece reforge/enchant effects are emitted by each piece.)
+        effects.push(...this.armorSet.getEffects(env));
+        // Tool: for crop-scoped calculations, use the selected/best tool for
+        // that crop. For crop-agnostic stat queries, use the selected tool.
+        const tool = env.crop ? this.getSelectedCropTool(env.crop) : this.selectedTool;
+        if (tool) {
+            effects.push(...tool.getEffects(env));
+        }
+        // Active accessories only - the same filtering `getStatBreakdown`
+        // applies, so we don't double-count Helianthus etc.
+        for (const accessory of this.activeAccessories) {
+            effects.push(...accessory.getEffects(env));
+        }
+        // Selected pet.
+        if (this.selectedPet) {
+            effects.push(...this.selectedPet.getEffects(env, this));
+        }
+        // Attribute shards.
+        for (const shard of Object.values(FARMING_ATTRIBUTE_SHARD_CLASSES)) {
+            const active = shard.getActive?.(this, env);
+            if (active && active.active === false)
+                continue;
+            effects.push(...shard.getEffects(this, env));
+        }
+        // Garden chips.
+        for (const chip of Object.values(GARDEN_CHIP_CLASSES)) {
+            const active = chip.getActive?.(this, env);
+            if (active && active.active === false)
+                continue;
+            effects.push(...chip.getEffects(this, env));
+        }
+        effects.push(...collectCropFortuneSourceEffects(this, env));
+        return effects;
+    }
+    getStat(stat, targetCrop) {
+        const breakdown = this.getStatBreakdown(stat, targetCrop);
         return Object.values(breakdown).reduce((acc, val) => acc + val.value, 0);
     }
     getStatBreakdown(stat, targetCrop) {
@@ -241,110 +360,16 @@ export class FarmingPlayer {
                 breakdown[name].value += value;
             }
         };
-        // Identify all stats that contribute to the requested stat
         const contributingStats = getContributoryStats(stat);
-        // General Sources
-        // Always run general sources (they apply to everything)
-        for (const source of GENERAL_FORTUNE_SOURCES) {
-            // If this source is handled by an active accessory, skip it here to avoid double counting
-            if (this.activeAccessories.some((a) => a.info.name === source.name))
-                continue;
-            if (source.exists && !source.exists(this))
-                continue;
-            for (const targetStat of contributingStats) {
-                let val = 0;
-                if (source.currentStat) {
-                    val = source.currentStat(this, targetStat) ?? 0;
-                }
-                else if (source.current && targetStat === Stat.FarmingFortune) {
-                    val = source.current(this) ?? 0;
-                }
-                add(source.name, val, targetStat);
-            }
-        }
-        // Crop Sources
-        // Only run if we have a target crop
-        if (targetCrop) {
-            for (const source of CROP_FORTUNE_SOURCES) {
-                // Helianthus Relic Family is handled by activeAccessories
-                if (source.name === 'Helianthus Relic Family')
-                    continue;
-                const ctx = { player: this, crop: targetCrop };
-                if (source.exists && !source.exists(ctx))
-                    continue;
-                for (const targetStat of contributingStats) {
-                    let val = 0;
-                    // For Crop Sources, strictly match the crop's fortune type.
-                    if (source.currentStat) {
-                        val = source.currentStat(ctx, targetStat) ?? 0;
-                    }
-                    else if (source.current && targetStat === CROP_INFO[targetCrop].fortuneType) {
-                        val = source.current(ctx) ?? 0;
-                    }
-                    add(source.name, val, targetStat);
-                }
-            }
-        }
-        // Pets
-        const pet = this.selectedPet;
-        if (pet) {
-            for (const targetStat of contributingStats) {
-                // Pass the player for abilities that depend on player context (e.g., Mosquito sugar cane fortune)
-                const val = pet.getFortune(targetStat, this);
-                add(pet.info.name ?? 'Selected Pet', val, targetStat);
-            }
-        }
-        // Tools
-        if (!targetCrop && this.selectedTool) {
-            for (const targetStat of contributingStats) {
-                const val = this.selectedTool.getStat(targetStat);
-                add(this.selectedTool.info.name, val, targetStat);
-            }
-        }
-        // Equipment
-        for (const piece of this.armorSet.equipment) {
-            if (!piece)
-                continue;
-            for (const targetStat of contributingStats) {
-                const val = piece.getStat(targetStat);
-                add(piece.info.name, val, targetStat);
-            }
-        }
-        // Armor
-        for (const piece of this.armorSet.armor) {
-            if (!piece)
-                continue;
-            for (const targetStat of contributingStats) {
-                const val = piece.getStat(targetStat);
-                add(piece.info.name, val, targetStat);
-            }
-        }
-        // Armor Set Bonuses
-        for (const { bonus, count } of this.armorSet.setBonuses) {
-            if (count < 2 || count > 4)
-                continue;
-            for (const targetStat of contributingStats) {
-                const val = bonus.stats?.[count]?.[targetStat] ?? 0;
-                add(bonus.name, val, targetStat);
-            }
-        }
-        // Equipment Set Bonuses
-        for (const { bonus, count } of this.armorSet.equipmentSetBonuses) {
-            if (count < 2 || count > 4)
-                continue;
-            for (const targetStat of contributingStats) {
-                const val = bonus.stats?.[count]?.[targetStat] ?? 0;
-                add(bonus.name, val, targetStat);
-            }
-        }
-        // Accessories
-        for (const acc of this.activeAccessories) {
-            // If the accessory is restricted to specific crops, check validity
-            if (acc.info.crops && (!targetCrop || !acc.info.crops.includes(targetCrop)))
-                continue;
-            for (const targetStat of contributingStats) {
-                const val = acc.getStat(targetStat);
-                add(acc.info.name, val, targetStat);
+        const env = this.buildEnvironment(targetCrop);
+        const effects = this.collectEffects(env);
+        const statContext = { env, crop: targetCrop };
+        for (const targetStat of contributingStats) {
+            const resolved = targetStat === Stat.Overbloom
+                ? resolveOverbloomBreakdown(effects, statContext, Stat.Overbloom)
+                : resolveStatBreakdown(effects, targetStat, statContext);
+            for (const [name, value] of Object.entries(resolved)) {
+                add(name, value, targetStat);
             }
         }
         // Temporary Fortune
@@ -373,9 +398,11 @@ export class FarmingPlayer {
             const petName = this.selectedPet.info.name ?? 'Selected Pet';
             // Get the stat type from the late breakdown entries (they specify their stat)
             const lateBreakdownEntries = lateResult.breakdown ? Object.values(lateResult.breakdown) : [];
-            const lateStat = lateBreakdownEntries[0]?.stat ?? Stat.FarmingFortune;
+            const contributingLateEntry = lateBreakdownEntries.find((entry) => contributingStats.includes(entry.stat));
+            const lateStat = contributingLateEntry?.stat ?? lateBreakdownEntries[0]?.stat ?? Stat.FarmingFortune;
+            const lateResultContributes = contributingStats.includes(lateStat);
             // Add late additive effects to the pet's entry
-            if (lateResult.additive) {
+            if (lateResultContributes && lateResult.additive) {
                 if (breakdown[petName]) {
                     breakdown[petName].value += lateResult.additive;
                 }
@@ -384,7 +411,7 @@ export class FarmingPlayer {
                 }
             }
             // Apply multiplier to total fortune (add as reduction to pet's entry)
-            if (lateResult.multiplier !== undefined && lateResult.multiplier !== 1) {
+            if (lateResultContributes && lateResult.multiplier !== undefined && lateResult.multiplier !== 1) {
                 const reduction = baseFortune * (lateResult.multiplier - 1);
                 if (breakdown[petName]) {
                     breakdown[petName].value += reduction;
@@ -416,9 +443,12 @@ export class FarmingPlayer {
                 continue;
             const fortune = source.fortune(this.options.temporaryFortune);
             if (fortune) {
-                const boosted = fortune * hyperchargeMultiplier;
-                breakdown[source.name] = { value: boosted, stat: Stat.FarmingFortune };
-                sum += boosted;
+                const stat = source.stat ?? Stat.FarmingFortune;
+                // Hypercharge chip only boosts farming fortune sources, not Overbloom or other stats.
+                const boosted = stat === Stat.FarmingFortune ? fortune * hyperchargeMultiplier : fortune;
+                breakdown[source.name] = { value: boosted, stat };
+                if (stat === Stat.FarmingFortune)
+                    sum += boosted;
             }
         }
         this.tempFortuneBreakdown = breakdown;
@@ -447,15 +477,34 @@ export class FarmingPlayer {
     getRates(crop, blocksBroken) {
         const tool = this.getBestTool(crop);
         const cropFortune = this.getCropFortune(crop, tool);
-        const fortune = this.permFortune + this.tempFortune + cropFortune.fortune;
-        return calculateDetailedDrops({
-            crop: crop,
-            blocksBroken: blocksBroken,
+        const fortune = cropFortune.fortune;
+        const env = this.buildEnvironment(crop);
+        const effects = this.collectEffects(env);
+        return calculateDetailedDropsFromEffects({
+            crop,
+            blocksBroken,
             farmingFortune: fortune,
+            armorPieces: this.armorSet.specialDropsCount(crop),
             bountiful: tool?.bountiful ?? false,
             mooshroom: this.selectedPet?.type === FarmingPets.MooshroomCow,
+            maxTool: tool?.getCurrentLevelProgress().maxed ?? false,
+            chips: this.options.chips,
+            pet: this.selectedPet,
+            effects,
+            env,
         });
     }
+    getUpgradeRateImpact(upgrade, options) {
+        const before = this.getRates(options.crop, options.blocksBroken);
+        const clonedPlayer = this.clone();
+        clonedPlayer.applyUpgrade(upgrade);
+        const after = clonedPlayer.getRates(options.crop, options.blocksBroken);
+        return {
+            before,
+            after,
+            delta: diffDetailedDrops(before, after),
+        };
+    }
     getWeightCalc(info) {
         return createFarmingWeightCalculator({
             collection: this.options.collection,
@@ -480,6 +529,35 @@ export class FarmingPlayer {
         if (!upgrade.meta)
             return;
         const { type, itemUuid, key, value, id } = upgrade.meta;
+        if (type === 'upgrade_group') {
+            for (const groupedUpgrade of upgrade.groupedUpgrades ?? []) {
+                this.applyUpgrade(groupedUpgrade);
+            }
+            this.permFortune = this.getGeneralFortune();
+            return;
+        }
+        if ((type === 'pet_level' || type === 'pet_item') && itemUuid) {
+            const index = this.pets.findIndex((pet) => pet.pet.uuid === itemUuid);
+            const target = this.pets[index];
+            if (target) {
+                const nextPetData = { ...target.pet };
+                if (type === 'pet_level' && value) {
+                    nextPetData.exp = target.getXpForLevel(Number(value));
+                }
+                else if (type === 'pet_item' && id) {
+                    nextPetData.heldItem = id;
+                }
+                const updatedPet = new FarmingPet(nextPetData, this.options);
+                this.pets[index] = updatedPet;
+                this.options.pets = this.pets;
+                if (this.selectedPet?.pet.uuid === itemUuid) {
+                    this.selectedPet = updatedPet;
+                    this.options.selectedPet = updatedPet;
+                }
+                this.permFortune = this.getGeneralFortune();
+            }
+            return;
+        }
         if (itemUuid) {
             const candidates = [...this.tools, ...this.armor, ...this.equipment, ...this.accessories];
             const target = candidates.find((i) => i.item.uuid === itemUuid);
@@ -491,7 +569,11 @@ export class FarmingPlayer {
                     if (target instanceof FarmingTool) {
                         const idx = this.tools.indexOf(target);
                         if (idx >= 0) {
-                            this.tools[idx] = new FarmingTool(target.item, this.options);
+                            const updatedTool = new FarmingTool(target.item, this.options);
+                            this.tools[idx] = updatedTool;
+                            if (this.selectedTool === target) {
+                                this.selectedTool = updatedTool;
+                            }
                         }
                     }
                     else if (target instanceof FarmingArmor) {
@@ -524,7 +606,11 @@ export class FarmingPlayer {
                     if (target instanceof FarmingTool) {
                         const idx = this.tools.indexOf(target);
                         if (idx >= 0) {
-                            this.tools[idx] = new FarmingTool(target.item, this.options);
+                            const updatedTool = new FarmingTool(target.item, this.options);
+                            this.tools[idx] = updatedTool;
+                            if (this.selectedTool === target) {
+                                this.selectedTool = updatedTool;
+                            }
                         }
                     }
                     else if (target instanceof FarmingArmor) {
@@ -602,6 +688,7 @@ export class FarmingPlayer {
                 else if (type === 'item' && id === 'rarity_upgrades' && value) {
                     target.item.attributes ??= {};
                     target.item.attributes.rarity_upgrades = String(value);
+                    setItemRarityAttribute(target.item, nextRarity(target.rarity));
                     // Recomb affects rarity, which affects stats. Need to reload tool.
                     if (target instanceof FarmingTool) {
                         const idx = this.tools.indexOf(target);
@@ -649,6 +736,7 @@ export class FarmingPlayer {
                             ...newItem.item.gems,
                             ...target.item.gems,
                         };
+                        setItemRarityAttribute(newItem.item, getUpgradedItemRarity(target.rarity, target.info.maxRarity, newItem.info.maxRarity));
                         // Preserve the old item's UUID so the item remains trackable
                         newItem.item.uuid = target.item.uuid;
                         if (target instanceof FarmingTool && newItem instanceof FarmingTool) {
@@ -674,6 +762,7 @@ export class FarmingPlayer {
                         else if (target instanceof FarmingEquipment && newItem instanceof FarmingEquipment) {
                             const idx = this.equipment.indexOf(target);
                             if (idx >= 0) {
+                                target.applyTierUpgradeStateTo(newItem);
                                 const updatedPiece = new FarmingEquipment(newItem.item, this.options);
                                 this.equipment[idx] = updatedPiece;
                                 this.armorSet.updateEquipmentSlot(updatedPiece);
@@ -688,6 +777,10 @@ export class FarmingPlayer {
                         this.permFortune = this.getGeneralFortune();
                     }
                 }
+                if (target instanceof FarmingAccessory) {
+                    this.syncActiveAccessories();
+                }
+                this.permFortune = this.getGeneralFortune();
             }
         }
         else if (type === 'skill') {
@@ -737,12 +830,22 @@ export class FarmingPlayer {
             if (key === 'cocoaFortuneUpgrade') {
                 this.options.cocoaFortuneUpgrade = Number(value);
             }
+            else if (key === 'dnaMilestone') {
+                this.options.dnaMilestone = Number(value);
+            }
+            else if (key === 'refinedTruffles') {
+                this.options.refinedTruffles = Number(value);
+            }
             this.permFortune = this.getGeneralFortune();
         }
         else if (type === 'unlock' && id) {
             if (id === 'personal_best') {
                 this.options.personalBestsUnlocked = true;
             }
+            else if (id === 'exportable_crop' && key) {
+                this.options.exportableCrops ??= {};
+                this.options.exportableCrops[key] = true;
+            }
             this.permFortune = this.getGeneralFortune();
         }
         else if (type === 'buy_item' && id) {
@@ -785,7 +888,9 @@ export class FarmingPlayer {
                         this.armor[oldIdx] = new FarmingArmor(newItem.item, this.options);
                     }
                     else {
-                        this.armor.push(newItem);
+                        const addedPiece = new FarmingArmor(newItem.item, this.options);
+                        this.armor.push(addedPiece);
+                        this.armorSet.updateArmorSlot(addedPiece);
                     }
                 }
                 else if (newItem instanceof FarmingEquipment) {
@@ -801,10 +906,13 @@ export class FarmingPlayer {
                             ...oldItem.item.attributes,
                         };
                         newItem.item.gems = { ...newItem.item.gems, ...oldItem.item.gems };
+                        oldItem.applyTierUpgradeStateTo(newItem);
                         this.equipment[oldIdx] = new FarmingEquipment(newItem.item, this.options);
                     }
                     else {
-                        this.equipment.push(newItem);
+                        const addedPiece = new FarmingEquipment(newItem.item, this.options);
+                        this.equipment.push(addedPiece);
+                        this.armorSet.updateEquipmentSlot(addedPiece);
                     }
                 }
                 else if (newItem instanceof FarmingAccessory) {
@@ -826,6 +934,9 @@ export class FarmingPlayer {
                         this.accessories.push(newItem);
                     }
                 }
+                if (newItem instanceof FarmingAccessory) {
+                    this.syncActiveAccessories();
+                }
                 this.permFortune = this.getGeneralFortune();
             }
         }
@@ -843,6 +954,8 @@ export class FarmingPlayer {
                 lore: [...(item.item.lore ?? [])],
             }));
         };
+        const selectedToolUuid = this.selectedTool?.item.uuid;
+        const selectedPetUuid = this.selectedPet?.pet.uuid;
         const clonedOptions = {
             ...this.options,
             tools: cloneItems(this.tools),
@@ -858,8 +971,21 @@ export class FarmingPlayer {
             bestiaryKills: { ...this.options.bestiaryKills },
             attributes: { ...this.options.attributes },
             plots: [...(this.options.plots ?? [])],
+            selectedTool: undefined,
+            selectedPet: undefined,
         };
-        return new FarmingPlayer(clonedOptions);
+        const clonedPlayer = new FarmingPlayer(clonedOptions);
+        if (selectedToolUuid) {
+            const selectedTool = clonedPlayer.tools.find((tool) => tool.item.uuid === selectedToolUuid);
+            if (selectedTool)
+                clonedPlayer.selectTool(selectedTool);
+        }
+        if (selectedPetUuid) {
+            const selectedPet = clonedPlayer.pets.find((pet) => pet.pet.uuid === selectedPetUuid);
+            if (selectedPet)
+                clonedPlayer.selectPet(selectedPet);
+        }
+        return clonedPlayer;
     }
     /**
      * Expands an upgrade into a tree of follow-up upgrades.
@@ -908,6 +1034,25 @@ export class FarmingPlayer {
             totalCost: upgrade.cost,
             children: [],
         };
+        if (upgrade.meta?.type === 'upgrade_group') {
+            const sequentialPlayer = this.clone();
+            for (const groupedUpgrade of upgrade.groupedUpgrades ?? []) {
+                const childStatsBefore = sequentialPlayer.getAllStats(stats, crop);
+                const childPlayer = sequentialPlayer.clone();
+                childPlayer.applyUpgrade(groupedUpgrade);
+                const childStatsAfter = childPlayer.getAllStats(stats, crop);
+                node.children.push({
+                    upgrade: groupedUpgrade,
+                    statsBefore: childStatsBefore,
+                    statsAfter: childStatsAfter,
+                    statsGained: this.computeStatsDiff(childStatsBefore, childStatsAfter),
+                    totalCost: groupedUpgrade.cost,
+                    children: [],
+                });
+                sequentialPlayer.applyUpgrade(groupedUpgrade);
+            }
+            return node;
+        }
         // Stop recursion at max depth
         if (depth >= maxDepth) {
             return node;
@@ -1004,9 +1149,12 @@ export class FarmingPlayer {
             const target = player.tools.find((t) => t.item.uuid === itemUuid) ??
                 player.armor.find((a) => a.item.uuid === itemUuid) ??
                 player.equipment.find((e) => e.item.uuid === itemUuid) ??
-                player.accessories.find((a) => a.item.uuid === itemUuid);
+                player.accessories.find((a) => a.item.uuid === itemUuid) ??
+                player.pets.find((p) => p.pet.uuid === itemUuid);
             if (target && 'getUpgrades' in target && typeof target.getUpgrades === 'function') {
-                const itemUpgrades = target.getUpgrades({ stat: primaryStat });
+                const itemUpgrades = target instanceof FarmingPet
+                    ? target.getUpgrades({ stat: primaryStat }, player)
+                    : target.getUpgrades({ stat: primaryStat });
                 // Filter to only include upgrades of the same type (enchant chains, tier upgrades, etc.)
                 // For gem upgrades, also match on slot to only show follow-ups for that specific slot
                 for (const u of itemUpgrades) {
@@ -1041,4 +1189,46 @@ export class FarmingPlayer {
         return upgrades;
     }
 }
+function diffDetailedDrops(before, after) {
+    const items = diffRecord(before.items, after.items);
+    const rngItems = diffRecord(before.rngItems ?? {}, after.rngItems ?? {});
+    const currencies = diffRecord(before.currencies, after.currencies);
+    return {
+        collection: after.collection - before.collection,
+        npcCoins: after.npcCoins - before.npcCoins,
+        coinSources: diffRecord(before.coinSources, after.coinSources),
+        otherCollection: diffRecord(before.otherCollection, after.otherCollection),
+        items,
+        currencies,
+        rngItems,
+        totalItems: sumRecord(items) + sumRecord(rngItems),
+    };
+}
+function diffRecord(before, after) {
+    const result = {};
+    const keys = new Set([...Object.keys(before), ...Object.keys(after)]);
+    for (const key of keys) {
+        const delta = (after[key] ?? 0) - (before[key] ?? 0);
+        if (delta !== 0) {
+            result[key] = delta;
+        }
+    }
+    return result;
+}
+function sumRecord(record) {
+    return Object.values(record).reduce((sum, value) => sum + value, 0);
+}
+function getUpgradedItemRarity(currentRarity, currentMaxRarity, nextMaxRarity) {
+    const currentBaseRarity = previousRarity(currentMaxRarity);
+    const nextBaseRarity = previousRarity(nextMaxRarity);
+    const rarityIncrease = compareRarity(currentRarity, currentBaseRarity);
+    if (rarityIncrease > 0) {
+        return nextRarity(nextBaseRarity);
+    }
+    return nextBaseRarity;
+}
+function setItemRarityAttribute(item, rarity) {
+    item.attributes ??= {};
+    item.attributes.rarity = rarity;
+}
 //# sourceMappingURL=player.js.map