@shipload/sdk 1.0.0-next.59 → 1.0.0-next.60

package/src/data/recipes.json

@@ -2086,6 +2086,88 @@
     ],
     "blendWeights": []
   },
+  {
+    "outputItemId": 20100,
+    "outputMass": 1536000,
+    "inputs": [
+      {
+        "itemId": 20003,
+        "quantity": 600
+      },
+      {
+        "itemId": 10100,
+        "quantity": 1
+      }
+    ],
+    "statSlots": [
+      {
+        "sources": [
+          {
+            "inputIndex": 0,
+            "statIndex": 0
+          },
+          {
+            "inputIndex": 1,
+            "statIndex": 0
+          }
+        ]
+      },
+      {
+        "sources": [
+          {
+            "inputIndex": 0,
+            "statIndex": 1
+          },
+          {
+            "inputIndex": 1,
+            "statIndex": 1
+          }
+        ]
+      }
+    ],
+    "blendWeights": []
+  },
+  {
+    "outputItemId": 20101,
+    "outputMass": 1536000,
+    "inputs": [
+      {
+        "itemId": 20004,
+        "quantity": 600
+      },
+      {
+        "itemId": 10101,
+        "quantity": 1
+      }
+    ],
+    "statSlots": [
+      {
+        "sources": [
+          {
+            "inputIndex": 0,
+            "statIndex": 0
+          },
+          {
+            "inputIndex": 1,
+            "statIndex": 0
+          }
+        ]
+      },
+      {
+        "sources": [
+          {
+            "inputIndex": 0,
+            "statIndex": 1
+          },
+          {
+            "inputIndex": 1,
+            "statIndex": 1
+          }
+        ]
+      }
+    ],
+    "blendWeights": []
+  },
   {
     "outputItemId": 20102,
     "outputMass": 1536000,
@@ -2143,6 +2225,92 @@
     ],
     "blendWeights": []
   },
+  {
+    "outputItemId": 20103,
+    "outputMass": 1536000,
+    "inputs": [
+      {
+        "itemId": 20007,
+        "quantity": 600
+      },
+      {
+        "itemId": 10103,
+        "quantity": 1
+      }
+    ],
+    "statSlots": [
+      {
+        "sources": [
+          {
+            "inputIndex": 0,
+            "statIndex": 1
+          },
+          {
+            "inputIndex": 1,
+            "statIndex": 0
+          }
+        ]
+      },
+      {
+        "sources": [
+          {
+            "inputIndex": 0,
+            "statIndex": 0
+          },
+          {
+            "inputIndex": 1,
+            "statIndex": 1
+          }
+        ]
+      }
+    ],
+    "blendWeights": []
+  },
+  {
+    "outputItemId": 20104,
+    "outputMass": 1536000,
+    "inputs": [
+      {
+        "itemId": 20009,
+        "quantity": 300
+      },
+      {
+        "itemId": 20006,
+        "quantity": 300
+      },
+      {
+        "itemId": 10104,
+        "quantity": 1
+      }
+    ],
+    "statSlots": [
+      {
+        "sources": [
+          {
+            "inputIndex": 0,
+            "statIndex": 2
+          },
+          {
+            "inputIndex": 2,
+            "statIndex": 0
+          }
+        ]
+      },
+      {
+        "sources": [
+          {
+            "inputIndex": 1,
+            "statIndex": 0
+          },
+          {
+            "inputIndex": 2,
+            "statIndex": 1
+          }
+        ]
+      }
+    ],
+    "blendWeights": []
+  },
   {
     "outputItemId": 20106,
     "outputMass": 1536000,
@@ -2200,6 +2368,84 @@
     ],
     "blendWeights": []
   },
+  {
+    "outputItemId": 20107,
+    "outputMass": 1536000,
+    "inputs": [
+      {
+        "itemId": 20004,
+        "quantity": 300
+      },
+      {
+        "itemId": 20009,
+        "quantity": 300
+      },
+      {
+        "itemId": 10107,
+        "quantity": 1
+      }
+    ],
+    "statSlots": [
+      {
+        "sources": [
+          {
+            "inputIndex": 0,
+            "statIndex": 1
+          },
+          {
+            "inputIndex": 2,
+            "statIndex": 0
+          }
+        ]
+      }
+    ],
+    "blendWeights": []
+  },
+  {
+    "outputItemId": 20110,
+    "outputMass": 1536000,
+    "inputs": [
+      {
+        "itemId": 20006,
+        "quantity": 300
+      },
+      {
+        "itemId": 20008,
+        "quantity": 300
+      },
+      {
+        "itemId": 10110,
+        "quantity": 1
+      }
+    ],
+    "statSlots": [
+      {
+        "sources": [
+          {
+            "inputIndex": 0,
+            "statIndex": 2
+          },
+          {
+            "inputIndex": 2,
+            "statIndex": 0
+          }
+        ]
+      },
+      {
+        "sources": [
+          {
+            "inputIndex": 1,
+            "statIndex": 1
+          },
+          {
+            "inputIndex": 2,
+            "statIndex": 1
+          }
+        ]
+      }
+    ],
+    "blendWeights": []
+  },
   {
     "outputItemId": 20200,
     "outputMass": 3100000,

package/src/derivation/capabilities.test.ts

@@ -1,15 +1,34 @@
-import {expect, test} from 'bun:test'
+import {describe, expect, test} from 'bun:test'
 import {
     computeEntityCapabilities,
     computeEngineCapabilities,
     computeGathererCapabilities,
+    computeGathererYield,
     computeGeneratorCapabilities,
     computeCrafterCapabilities,
     computeBuilderCapabilities,
     computeLoaderCapabilities,
     computeBaseCapacity,
     computeContainerCapabilities,
+    GATHERER_YIELD_TIER_TABLE,
+    ENGINE_THRUST_TIER_PCT,
+    GENERATOR_CAPACITY_TIER_PCT,
+    GENERATOR_RECHARGE_TIER_PCT,
+    CRAFTER_SPEED_TIER_PCT,
+    BUILDER_SPEED_TIER_PCT,
+    WARP_RANGE_TIER_PCT,
+    LOADER_THRUST_TIER_PCT,
+    moduleTierPct,
 } from './capabilities'
+import {
+    computeEngineThrust,
+    computeGeneratorCap,
+    computeGeneratorRech,
+    computeCrafterSpeed,
+    computeBuilderSpeed,
+    computeWarpRange,
+    computeLoaderThrust,
+} from '../nft/description'
 import {applySlotMultiplier, U16_MAX} from '../entities/slot-multiplier'
 import {encodeStats} from './crafting'
 import {
@@ -147,7 +166,7 @@ test('computeEntityCapabilities emits crafterLanes alongside legacy crafter sum'
     expect(result.crafterLanes!.length).toBe(1)
     expect(result.crafterLanes![0].slotIndex).toBe(0)
 
-    const caps = computeCrafterCapabilities({fineness: 400, conductivity: 300})
+    const caps = computeCrafterCapabilities({fineness: 400, conductivity: 300}, 1)
     const expectedSpeed = applySlotMultiplier(caps.speed, 120)
     expect(result.crafterLanes![0].speed).toBe(expectedSpeed)
     expect(result.crafterLanes![0].drain).toBe(caps.drain)
@@ -159,7 +178,7 @@ test('computeEntityCapabilities emits crafterLanes alongside legacy crafter sum'
 })
 
 test('builder capabilities read canonical resonance and fineness slots', () => {
-    expect(computeBuilderCapabilities({resonance: 500, fineness: 330})).toEqual({
+    expect(computeBuilderCapabilities({resonance: 500, fineness: 330}, 1)).toEqual({
         speed: 500,
         drain: 20_000,
     })
@@ -189,7 +208,7 @@ test('computeEntityCapabilities emits loaderLanes alongside legacy loaders sum',
     expect(result.loaderLanes!.length).toBe(1)
     expect(result.loaderLanes![0].slotIndex).toBe(0)
 
-    const caps = computeLoaderCapabilities({insulation: 600, plasticity: 500})
+    const caps = computeLoaderCapabilities({insulation: 600, plasticity: 500}, 1)
     // mass is unscaled (raw); thrust is amp-scaled
     expect(result.loaderLanes![0].mass).toBe(caps.mass)
     expect(result.loaderLanes![0].thrust).toBe(applySlotMultiplier(caps.thrust, 80))
@@ -206,7 +225,7 @@ test('per-lane amp-scaled stats clamp to UInt16, matching the contract clamp_to_
 })
 
 test('generator capacity and recharge are denominated to milli-energy', () => {
-    const caps = computeGeneratorCapabilities({resonance: 213, reflectivity: 213})
+    const caps = computeGeneratorCapabilities({resonance: 213, reflectivity: 213}, 1)
     expect(caps.capacity).toBe(1_406_500)
     expect(caps.recharge).toBe(3_278)
 })
@@ -222,14 +241,14 @@ test('engine and generator capabilities use tapered quality consistently', () =>
     ]
 
     const result = computeEntityCapabilities({}, ITEM_ROUSTABOUT_T1A_PACKED, modules, layout)
-    const engines = computeEngineCapabilities({volatility: 500, thermal: 500})
+    const engines = computeEngineCapabilities({volatility: 500, thermal: 500}, 1)
 
     expect(result.engines).toEqual({
         thrust: engines.thrust,
         drain: computeTravelDrain(engines.thrust, computeEffectiveModuleStat(500)),
     })
     expect(result.generator).toEqual(
-        computeGeneratorCapabilities({resonance: 500, reflectivity: 500})
+        computeGeneratorCapabilities({resonance: 500, reflectivity: 500}, 1)
     )
 })
 
@@ -237,7 +256,7 @@ test('gatherer/crafter/hauler drains are denominated', () => {
     expect(computeGathererCapabilities({strength: 0, hardness: 0, saturation: 213}, 1).drain).toBe(
         1_967_500
     )
-    expect(computeCrafterCapabilities({fineness: 0, conductivity: 213}).drain).toBe(23_546)
+    expect(computeCrafterCapabilities({fineness: 0, conductivity: 213}, 1).drain).toBe(23_546)
 })
 
 test('gatherer depth accepts canonical tolerance and legacy recipe-labelled hardness', () => {
@@ -248,3 +267,82 @@ test('gatherer depth accepts canonical tolerance and legacy recipe-labelled hard
         1_565
     )
 })
+
+describe('computeGathererYield', () => {
+    test('table is the k=0.2 integer-percent curve T1..T10', () => {
+        expect([...GATHERER_YIELD_TIER_TABLE]).toEqual([
+            100, 120, 140, 160, 180, 200, 220, 240, 260, 280,
+        ])
+    })
+
+    test('T1 equals the base yield 200 + str (no change)', () => {
+        expect(computeGathererYield(500, 1)).toBe(700)
+        expect(computeGathererYield(0, 1)).toBe(200)
+    })
+
+    test('T2 scales base yield by 1.2, floored', () => {
+        expect(computeGathererYield(500, 2)).toBe(840) // floor(700 * 120 / 100)
+        expect(computeGathererYield(213, 2)).toBe(495) // floor(413 * 120 / 100) = floor(495.6)
+    })
+
+    test('T10 scales base yield by 2.8, floored', () => {
+        expect(computeGathererYield(500, 10)).toBe(1960) // 700 * 280 / 100
+    })
+
+    test('tier is clamped to [1, 10]', () => {
+        expect(computeGathererYield(500, 0)).toBe(700)
+        expect(computeGathererYield(500, 99)).toBe(1960)
+    })
+})
+
+describe('module tier tables', () => {
+    const ALL_TABLES = [
+        ENGINE_THRUST_TIER_PCT,
+        GENERATOR_CAPACITY_TIER_PCT,
+        GENERATOR_RECHARGE_TIER_PCT,
+        CRAFTER_SPEED_TIER_PCT,
+        BUILDER_SPEED_TIER_PCT,
+        WARP_RANGE_TIER_PCT,
+        LOADER_THRUST_TIER_PCT,
+    ]
+    test('every table has 10 rows and T1 = 100', () => {
+        for (const table of ALL_TABLES) {
+            expect(table.length).toBe(10)
+            expect(table[0]).toBe(100)
+        }
+    })
+    test('moduleTierPct clamps out-of-range tiers', () => {
+        expect(moduleTierPct(ENGINE_THRUST_TIER_PCT, 0)).toBe(100)
+        expect(moduleTierPct(ENGINE_THRUST_TIER_PCT, 11)).toBe(280)
+    })
+    test('engine thrust tiers (stat 500 pre-effective)', () => {
+        expect(computeEngineThrust(500, 1)).toBe(775)
+        expect(computeEngineThrust(500, 2)).toBe(930)
+        expect(computeEngineThrust(500, 10)).toBe(2170)
+    })
+    test('generator capacity k=0.1, recharge k=0.2', () => {
+        expect(computeGeneratorCap(500, 1)).toBe(1_550_000)
+        expect(computeGeneratorCap(500, 2)).toBe(1_705_000)
+        expect(computeGeneratorCap(500, 10)).toBe(2_945_000)
+        expect(computeGeneratorRech(500, 1)).toBe(5000)
+        expect(computeGeneratorRech(500, 2)).toBe(6000)
+        expect(computeGeneratorRech(500, 10)).toBe(14000)
+    })
+    test('crafter/builder speed tiers', () => {
+        expect(computeCrafterSpeed(500, 1)).toBe(500)
+        expect(computeCrafterSpeed(500, 2)).toBe(600)
+        expect(computeBuilderSpeed(500, 2)).toBe(600)
+        expect(computeBuilderSpeed(500, 10)).toBe(1400)
+    })
+    test('warp range tiers', () => {
+        expect(computeWarpRange(500, 1)).toBe(1600)
+        expect(computeWarpRange(500, 2)).toBe(1920)
+        expect(computeWarpRange(500, 10)).toBe(4480)
+    })
+    test('loader thrust tiers floor correctly', () => {
+        expect(computeLoaderThrust(500, 1)).toBe(26)
+        expect(computeLoaderThrust(500, 2)).toBe(31)
+        expect(computeLoaderThrust(500, 10)).toBe(72)
+        expect(computeLoaderThrust(0, 2)).toBe(1)
+    })
+})

package/src/derivation/capabilities.ts

@@ -39,29 +39,33 @@ export function computeShipHullCapabilities(
     }
 }
 
-export function computeEngineCapabilities(stats: Record<string, number>): {
-    thrust: number
-    drain: number
-} {
+export function computeEngineCapabilities(
+    stats: Record<string, number>,
+    tier: number
+): {thrust: number; drain: number} {
     const vol = computeEffectiveModuleStat(stats.volatility)
     const thm = computeEffectiveModuleStat(stats.thermal)
-
     return {
-        thrust: 400 + Math.floor((vol * 3) / 4),
+        thrust: Math.floor(
+            ((400 + Math.floor((vol * 3) / 4)) * moduleTierPct(ENGINE_THRUST_TIER_PCT, tier)) / 100
+        ),
         drain: 2 * Math.max(30, 50 - Math.floor(thm / 70)),
     }
 }
 
-export function computeGeneratorCapabilities(stats: Record<string, number>): {
-    capacity: number
-    recharge: number
-} {
+export function computeGeneratorCapabilities(
+    stats: Record<string, number>,
+    tier: number
+): {capacity: number; recharge: number} {
     const res = computeEffectiveModuleStat(stats.resonance)
     const ref = computeEffectiveModuleStat(stats.reflectivity)
-
     return {
-        capacity: 1_300_000 + res * 500,
-        recharge: 2000 + ref * 6,
+        capacity: Math.floor(
+            ((1_300_000 + res * 500) * moduleTierPct(GENERATOR_CAPACITY_TIER_PCT, tier)) / 100
+        ),
+        recharge: Math.floor(
+            ((2000 + ref * 6) * moduleTierPct(GENERATOR_RECHARGE_TIER_PCT, tier)) / 100
+        ),
     }
 }
 
@@ -109,49 +113,55 @@ export function computeGathererCapabilities(
     const tol = stats.tolerance ?? stats.hardness
 
     return {
-        yield: 200 + str,
+        yield: computeGathererYield(str, tier),
         drain: 2 * Math.max(250_000, 1_250_000 - con * 1250),
         depth: gathererDepthForTier(tol, tier),
     }
 }
 
-export function computeLoaderCapabilities(stats: Record<string, number>): {
-    mass: number
-    thrust: number
-    quantity: number
-} {
+export function computeLoaderCapabilities(
+    stats: Record<string, number>,
+    tier: number
+): {mass: number; thrust: number; quantity: number} {
     const insulation = stats.insulation
     const plasticity = stats.plasticity
-
     return {
         mass: Math.max(200, 2000 - Math.floor(insulation * 2)),
-        thrust: 1 + Math.floor((plasticity * plasticity) / 10000),
+        thrust: Math.floor(
+            ((1 + Math.floor((plasticity * plasticity) / 10000)) *
+                moduleTierPct(LOADER_THRUST_TIER_PCT, tier)) /
+                100
+        ),
         quantity: 1,
     }
 }
 
-export function computeCrafterCapabilities(stats: Record<string, number>): {
-    speed: number
-    drain: number
-} {
+export function computeCrafterCapabilities(
+    stats: Record<string, number>,
+    tier: number
+): {speed: number; drain: number} {
     const fin = stats.fineness
     const con = stats.conductivity
-
     return {
-        speed: 100 + Math.floor((fin * 4) / 5),
+        speed: Math.floor(
+            ((100 + Math.floor((fin * 4) / 5)) * moduleTierPct(CRAFTER_SPEED_TIER_PCT, tier)) / 100
+        ),
         drain: Math.max(5000, 30000 - Math.floor((con * 1000) / 33)),
     }
 }
 
-export function computeBuilderCapabilities(stats: Record<string, number>): {
-    speed: number
-    drain: number
-} {
+export function computeBuilderCapabilities(
+    stats: Record<string, number>,
+    tier: number
+): {speed: number; drain: number} {
     const resonance = stats.resonance
     const fineness = stats.fineness
-
     return {
-        speed: 100 + Math.floor((resonance * 4) / 5),
+        speed: Math.floor(
+            ((100 + Math.floor((resonance * 4) / 5)) *
+                moduleTierPct(BUILDER_SPEED_TIER_PCT, tier)) /
+                100
+        ),
         drain: Math.max(5000, 30000 - Math.floor((fineness * 1000) / 33)),
     }
 }
@@ -225,6 +235,7 @@ import {
     ITEM_MASS_DRIVER_T1_PACKED,
     ITEM_SHIP_T1_PACKED,
     ITEM_WAREHOUSE_T1_PACKED,
+    ITEM_WORKSHOP_T1_PACKED,
 } from '../data/item-ids'
 import {
     getModuleCapabilityType,
@@ -270,6 +281,33 @@ export function applyCapacityTier(baseCapacity: number, tier: number): number {
     return clampUint32(Math.floor(baseCapacity * capacityTierMultiplier(tier)))
 }
 
+export const GATHERER_YIELD_TIER_TABLE = [100, 120, 140, 160, 180, 200, 220, 240, 260, 280] as const
+
+export const MODULE_MAX_TIER = 10
+
+export const ENGINE_THRUST_TIER_PCT = [100, 120, 140, 160, 180, 200, 220, 240, 260, 280] as const
+export const GENERATOR_CAPACITY_TIER_PCT = [
+    100, 110, 120, 130, 140, 150, 160, 170, 180, 190,
+] as const
+export const GENERATOR_RECHARGE_TIER_PCT = [
+    100, 120, 140, 160, 180, 200, 220, 240, 260, 280,
+] as const
+export const CRAFTER_SPEED_TIER_PCT = [100, 120, 140, 160, 180, 200, 220, 240, 260, 280] as const
+export const BUILDER_SPEED_TIER_PCT = [100, 120, 140, 160, 180, 200, 220, 240, 260, 280] as const
+export const WARP_RANGE_TIER_PCT = [100, 120, 140, 160, 180, 200, 220, 240, 260, 280] as const
+export const LOADER_THRUST_TIER_PCT = [100, 120, 140, 160, 180, 200, 220, 240, 260, 280] as const
+
+export function moduleTierPct(table: readonly number[], tier: number): number {
+    const clamped = Math.min(Math.max(tier, 1), MODULE_MAX_TIER)
+    return table[clamped - 1]
+}
+
+export function computeGathererYield(str: number, tier: number): number {
+    const clampedTier = Math.min(Math.max(tier, 1), GATHERER_YIELD_TIER_TABLE.length)
+    const pct = GATHERER_YIELD_TIER_TABLE[clampedTier - 1]
+    return Math.floor(((200 + str) * pct) / 100)
+}
+
 export function computeBaseCapacity(itemId: number, stats: Record<string, number>): number {
     let base: number
     if (isShipHull(itemId)) {
@@ -288,6 +326,9 @@ export function computeBaseCapacity(itemId: number, stats: Record<string, number
             case ITEM_WAREHOUSE_T1_PACKED:
                 base = computeWarehouseHullCapabilities(stats).capacity
                 break
+            case ITEM_WORKSHOP_T1_PACKED:
+                base = computeWorkshopHullCapabilities(stats).capacity
+                break
             default:
                 return 0
         }
@@ -295,11 +336,16 @@ export function computeBaseCapacity(itemId: number, stats: Record<string, number
     return applyCapacityTier(base, getItem(itemId).tier)
 }
 
-export function computeWarpCapabilities(stats: Record<string, number>): {
-    range: number
-} {
+export function computeWarpCapabilities(
+    stats: Record<string, number>,
+    tier: number
+): {range: number} {
     const reflectivity = stats.reflectivity
-    return {range: 100 + reflectivity * 3}
+    return {
+        range: Math.floor(
+            ((100 + reflectivity * 3) * moduleTierPct(WARP_RANGE_TIER_PCT, tier)) / 100
+        ),
+    }
 }
 
 export function computeWarehouseHullCapabilities(stats: Record<string, number>): {
@@ -314,6 +360,18 @@ export function computeWarehouseHullCapabilities(stats: Record<string, number>):
     }
 }
 
+export function computeWorkshopHullCapabilities(stats: Record<string, number>): {
+    hullmass: number
+    capacity: number
+} {
+    const statSum = (stats.strength ?? 0) + (stats.hardness ?? 0)
+    const exponent = statSum / 1998.0
+    return {
+        hullmass: computeBaseHullmass(ITEM_WORKSHOP_T1_PACKED, stats),
+        capacity: Math.floor(5000000 * 6 ** exponent),
+    }
+}
+
 export interface GathererLaneEntry {
     slotIndex: number
     yield: number
@@ -442,13 +500,13 @@ export function computeEntityCapabilities(
 
         if (modType === MODULE_ENGINE) {
             hasEngine = true
-            const caps = computeEngineCapabilities(decodedStats)
+            const caps = computeEngineCapabilities(decodedStats, item.tier)
             totalThrust += applySlotMultiplier(caps.thrust, amp)
             totalEngineThm += computeEffectiveModuleStat(decodedStats.thermal ?? 0)
             engineCount += 1
         } else if (modType === MODULE_GENERATOR) {
             hasGenerator = true
-            const caps = computeGeneratorCapabilities(decodedStats)
+            const caps = computeGeneratorCapabilities(decodedStats, item.tier)
             totalGenCapacity += applySlotMultiplierUint32(caps.capacity, amp)
             totalGenRecharge += applySlotMultiplierUint32(caps.recharge, amp)
         } else if (modType === MODULE_GATHERER) {
@@ -475,7 +533,7 @@ export function computeEntityCapabilities(
             })
         } else if (modType === MODULE_LOADER) {
             hasLoader = true
-            const caps = computeLoaderCapabilities(decodedStats)
+            const caps = computeLoaderCapabilities(decodedStats, item.tier)
             totalLoaderMass += caps.mass
             totalLoaderThrust += applySlotMultiplier(caps.thrust, amp)
             totalLoaderQuantity += caps.quantity
@@ -491,7 +549,7 @@ export function computeEntityCapabilities(
             totalCargoHoldDrain += caps.drain
         } else if (modType === MODULE_CRAFTER) {
             hasCrafter = true
-            const caps = computeCrafterCapabilities(decodedStats)
+            const caps = computeCrafterCapabilities(decodedStats, item.tier)
             const scaledSpeed = applySlotMultiplier(caps.speed, amp)
             totalCrafterSpeed += scaledSpeed
             totalCrafterDrain += caps.drain
@@ -503,7 +561,7 @@ export function computeEntityCapabilities(
             })
         } else if (modType === MODULE_BUILDER) {
             hasBuilder = true
-            const caps = computeBuilderCapabilities(decodedStats)
+            const caps = computeBuilderCapabilities(decodedStats, item.tier)
             const scaledSpeed = applySlotMultiplier(caps.speed, amp)
             totalBuilderSpeed += scaledSpeed
             totalBuilderDrain += caps.drain
@@ -523,7 +581,7 @@ export function computeEntityCapabilities(
             totalHaulerDrain += caps.drain
         } else if (modType === MODULE_WARP) {
             hasWarp = true
-            const caps = computeWarpCapabilities(decodedStats)
+            const caps = computeWarpCapabilities(decodedStats, item.tier)
             totalWarpRange += applySlotMultiplier(caps.range, amp)
         } else if (modType === MODULE_LAUNCHER) {
             hasLauncher = true