@shipload/sdk 1.0.0-next.44 → 1.0.0-next.46

package/src/derivation/capabilities.test.ts

@@ -21,12 +21,12 @@ import {
 import type {InstalledModule} from '../entities/slot-multiplier'
 import type {EntitySlot} from '../data/recipes-runtime'
 
-function makeGathererStats(strength: number, tolerance: number, saturation: number): bigint {
-    return encodeStats([strength, tolerance, saturation, 0])
+function makeGathererStats(strength: number, hardness: number, saturation: number): bigint {
+    return encodeStats([strength, hardness, saturation, 0])
 }
 
-function makeCrafterStats(reactivity: number, conductivity: number): bigint {
-    return encodeStats([reactivity, conductivity])
+function makeCrafterStats(fineness: number, conductivity: number): bigint {
+    return encodeStats([fineness, conductivity])
 }
 
 function makeLoaderStats(insulation: number, plasticity: number): bigint {
@@ -57,8 +57,8 @@ test('computeEntityCapabilities emits gathererLanes alongside legacy gatherer su
     ]
 
     const layout: EntitySlot[] = [
-        {type: 'gatherer', outputPct: 100},
-        {type: 'gatherer', outputPct: 100},
+        {type: 'gatherer', outputPct: 100, maxTier: 1},
+        {type: 'gatherer', outputPct: 100, maxTier: 1},
     ]
 
     const result = computeEntityCapabilities({}, ITEM_EXTRACTOR_T1_PACKED, modules, layout)
@@ -72,8 +72,8 @@ test('computeEntityCapabilities emits gathererLanes alongside legacy gatherer su
     expect(result.gathererLanes![1].slotIndex).toBe(1)
 
     // Yields are amp-scaled and distinct
-    const caps1 = computeGathererCapabilities({strength: 300, tolerance: 200, saturation: 400}, 1)
-    const caps2 = computeGathererCapabilities({strength: 500, tolerance: 100, saturation: 300}, 1)
+    const caps1 = computeGathererCapabilities({strength: 300, hardness: 200, saturation: 400}, 1)
+    const caps2 = computeGathererCapabilities({strength: 500, hardness: 100, saturation: 300}, 1)
     const expectedYield1 = applySlotMultiplier(caps1.yield, 100)
     const expectedYield2 = applySlotMultiplier(caps2.yield, 100)
     expect(result.gathererLanes![0].yield).toBe(expectedYield1)
@@ -102,7 +102,7 @@ test('computeEntityCapabilities emits crafterLanes alongside legacy crafter sum'
         {slotIndex: 0, itemId: ITEM_CRAFTER_T1, stats: crafterStats},
     ]
 
-    const layout: EntitySlot[] = [{type: 'crafter', outputPct: 120}]
+    const layout: EntitySlot[] = [{type: 'crafter', outputPct: 120, maxTier: 1}]
 
     const result = computeEntityCapabilities({}, ITEM_EXTRACTOR_T1_PACKED, modules, layout)
 
@@ -110,7 +110,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({reactivity: 400, conductivity: 300})
+    const caps = computeCrafterCapabilities({fineness: 400, conductivity: 300})
     const expectedSpeed = applySlotMultiplier(caps.speed, 120)
     expect(result.crafterLanes![0].speed).toBe(expectedSpeed)
     expect(result.crafterLanes![0].drain).toBe(caps.drain)
@@ -126,7 +126,7 @@ test('computeEntityCapabilities emits loaderLanes alongside legacy loaders sum',
 
     const modules: InstalledModule[] = [{slotIndex: 0, itemId: ITEM_LOADER_T1, stats: loaderStats}]
 
-    const layout: EntitySlot[] = [{type: 'loader', outputPct: 80}]
+    const layout: EntitySlot[] = [{type: 'loader', outputPct: 80, maxTier: 1}]
 
     const result = computeEntityCapabilities({}, ITEM_EXTRACTOR_T1_PACKED, modules, layout)
 

package/src/derivation/capabilities.ts

@@ -115,7 +115,10 @@ export function computeCrafterCapabilities(stats: Record<string, number>): {
     }
 }
 
-export function computeHaulerCapabilities(stats: Record<string, number>): {
+export function computeHaulerCapabilities(
+    stats: Record<string, number>,
+    tier: number
+): {
     capacity: number
     efficiency: number
     drain: number
@@ -125,7 +128,7 @@ export function computeHaulerCapabilities(stats: Record<string, number>): {
     const conductivity = stats.conductivity
 
     return {
-        capacity: Math.max(1, 1 + Math.floor(resonance / 400)),
+        capacity: computeHaulerCapacity(resonance, tier),
         efficiency: 2000 + plasticity * 6,
         drain: Math.max(3, 15 - Math.floor(conductivity / 80)),
     }
@@ -171,8 +174,10 @@ import {
     ITEM_CONTAINER_T2_PACKED,
     ITEM_EXTRACTOR_T1_PACKED,
     ITEM_FACTORY_T1_PACKED,
+    ITEM_HAULER_SHIP_T2_PACKED,
     ITEM_MASS_CATCHER_T1_PACKED,
     ITEM_MASS_DRIVER_T1_PACKED,
+    ITEM_PROSPECTOR_T2_PACKED,
     ITEM_SHIP_T1_PACKED,
     ITEM_WAREHOUSE_T1_PACKED,
 } from '../data/item-ids'
@@ -200,25 +205,42 @@ import {
     type InstalledModule,
 } from '../entities/slot-multiplier'
 import type {EntitySlot} from '../data/recipes-runtime'
-import {computeTravelDrain} from '../nft/description'
+import {computeHaulerCapacity, computeTravelDrain} from '../nft/description'
+
+export const CAPACITY_TIER_TABLE = [1.0, 1.4, 1.8, 2.2, 2.6, 3.0, 3.4, 3.8, 4.2, 4.6]
+
+export function capacityTierMultiplier(tier: number): number {
+    const clampedTier = tier >= 1 && tier <= 10 ? tier : 1
+    return CAPACITY_TIER_TABLE[clampedTier - 1]
+}
+
+export function applyCapacityTier(baseCapacity: number, tier: number): number {
+    return clampUint32(Math.floor(baseCapacity * capacityTierMultiplier(tier)))
+}
 
 export function computeBaseCapacity(itemId: number, stats: Record<string, number>): number {
+    let base: number
     switch (itemId) {
         case ITEM_SHIP_T1_PACKED:
-            return computeShipHullCapabilities(stats).capacity
+        case ITEM_PROSPECTOR_T2_PACKED:
+        case ITEM_HAULER_SHIP_T2_PACKED:
+            base = computeShipHullCapabilities(stats).capacity
+            break
         case ITEM_EXTRACTOR_T1_PACKED:
         case ITEM_FACTORY_T1_PACKED:
         case ITEM_MASS_DRIVER_T1_PACKED:
         case ITEM_MASS_CATCHER_T1_PACKED:
         case ITEM_CONTAINER_T1_PACKED:
-            return computeContainerCapabilities(stats).capacity
-        case ITEM_WAREHOUSE_T1_PACKED:
-            return computeWarehouseHullCapabilities(stats).capacity
         case ITEM_CONTAINER_T2_PACKED:
-            return computeContainerT2Capabilities(stats).capacity
+            base = computeContainerCapabilities(stats).capacity
+            break
+        case ITEM_WAREHOUSE_T1_PACKED:
+            base = computeWarehouseHullCapabilities(stats).capacity
+            break
         default:
             return 0
     }
+    return applyCapacityTier(base, getItem(itemId).tier)
 }
 
 export function computeWarpCapabilities(stats: Record<string, number>): {
@@ -273,7 +295,12 @@ export interface ComputedCapabilities {
     loaderLanes?: LoaderLaneEntry[]
     crafter?: {speed: number; drain: number}
     crafterLanes?: CrafterLaneEntry[]
-    hauler?: {capacity: number; efficiency: number; drain: number}
+    hauler?: {
+        capacity: number
+        efficiency: number
+        drain: number
+        capacityByTier: {tier: number; capacity: number}[]
+    }
     warp?: {range: number}
     launcher?: {chargeRate: number; velocity: number; drain: number}
 }
@@ -315,6 +342,7 @@ export function computeEntityCapabilities(
     let weightedHaulerEffNum = 0n
     let totalHaulerDrain = 0
     let hasHauler = false
+    const haulerCapByTier = new Map<number, number>()
 
     let totalWarpRange = 0
     let hasWarp = false
@@ -392,9 +420,10 @@ export function computeEntityCapabilities(
             })
         } else if (modType === MODULE_HAULER) {
             hasHauler = true
-            const caps = computeHaulerCapabilities(decodedStats)
+            const caps = computeHaulerCapabilities(decodedStats, item.tier)
             const eff = applySlotMultiplier(caps.efficiency, amp)
             totalHaulerCapacity += caps.capacity
+            haulerCapByTier.set(item.tier, (haulerCapByTier.get(item.tier) ?? 0) + caps.capacity)
             weightedHaulerEffNum += BigInt(eff) * BigInt(caps.capacity)
             totalHaulerDrain += caps.drain
         } else if (modType === MODULE_WARP) {
@@ -466,6 +495,9 @@ export function computeEntityCapabilities(
             capacity: totalHaulerCapacity,
             efficiency: clampUint16(efficiency),
             drain: totalHaulerDrain,
+            capacityByTier: [...haulerCapByTier.entries()]
+                .sort((a, b) => a[0] - b[0])
+                .map(([tier, capacity]) => ({tier, capacity})),
         }
     }
     if (hasWarp) {
@@ -493,20 +525,3 @@ export function computeContainerCapabilities(stats: Record<string, number>): {
         capacity: Math.floor(22000000 * 6 ** exponent),
     }
 }
-
-export function computeContainerT2Capabilities(stats: Record<string, number>): {
-    hullmass: number
-    capacity: number
-} {
-    const strength = stats.strength ?? 0
-    const density = stats.density ?? 0
-    const hardness = stats.hardness ?? 0
-
-    const hullmass = 70000 - 50 * density
-
-    const statSum = strength + hardness
-    const exponent = statSum / 2947
-    const capacity = Math.floor(24000000 * 6 ** exponent)
-
-    return {hullmass, capacity}
-}

package/src/derivation/index.ts

@@ -52,4 +52,6 @@ export {
     starsForStat,
     starRating,
     statMagnitude,
+    compareByStars,
 } from './stars'
+export type {StarSortable} from './stars'

package/src/derivation/recipe-usage.test.ts

@@ -7,7 +7,9 @@ import {
 } from './recipe-usage'
 import {
     ITEM_SENSOR,
+    ITEM_SENSOR_T2,
     ITEM_RESIN,
+    ITEM_FRAME,
     ITEM_PLATE,
     ITEM_BEAM,
     ITEM_GATHERER_T1,
@@ -26,12 +28,14 @@ test('getRecipeConsumers lists every recipe that consumes Sensor', () => {
     const consumers = getRecipeConsumers(ITEM_SENSOR)
     const ids = consumers.map((c) => c.outputItemId).sort((a, b) => a - b)
     expect(ids).toEqual(
-        [ITEM_CRAFTER_T1, ITEM_SHIP_T1_PACKED, ITEM_EXTRACTOR_T1_PACKED].sort((a, b) => a - b)
+        [ITEM_CRAFTER_T1, ITEM_SHIP_T1_PACKED, ITEM_EXTRACTOR_T1_PACKED, ITEM_SENSOR_T2].sort(
+            (a, b) => a - b
+        )
     )
 })
 
-test('Resin feeds the gatherer drain stat', () => {
-    const consumers = getRecipeConsumers(ITEM_RESIN)
+test('Frame feeds the gatherer drain stat', () => {
+    const consumers = getRecipeConsumers(ITEM_FRAME)
     const gatherer = consumers.find((c) => c.outputItemId === ITEM_GATHERER_T1)
     expect(gatherer).toBeDefined()
     const drain = gatherer?.statFlows.find(
@@ -56,12 +60,12 @@ test('getResourceDemand traces a dual-resource component to both resources', ()
 })
 
 test('getResourceDemand recurses through a module to raw resources', () => {
-    // Gatherer = 300 Beam (5 ore + 5 gas each) + 300 Resin (5 biomass + 5 crystal each)
+    // Gatherer = 300 Beam (5 ore + 5 gas each) + 300 Frame (5 regolith + 5 biomass each)
     expect(getResourceDemand(ITEM_GATHERER_T1)).toEqual({
         ore: 1500,
         gas: 1500,
+        regolith: 1500,
         biomass: 1500,
-        crystal: 1500,
     })
 })
 
@@ -69,9 +73,9 @@ test('getResourceDemand scales by quantity', () => {
     expect(getResourceDemand(ITEM_PLATE, 3)).toEqual({ore: 30})
 })
 
-test('getComponentDemand reports Resin as consumed by two recipes', () => {
+test('getComponentDemand reports Resin as consumed by three recipes', () => {
     const demand = getComponentDemand()
     const resin = demand.find((d) => d.itemId === ITEM_RESIN)
     expect(resin).toBeDefined()
-    expect(resin?.consumerCount).toBe(2)
+    expect(resin?.consumerCount).toBe(3)
 })

package/src/derivation/stars.test.ts

@@ -1,5 +1,6 @@
 import {expect, test} from 'bun:test'
 import {
+    compareByStars,
     MAX_STARS_PER_STAT,
     MAX_STAR_RATING,
     starRating,
@@ -44,6 +45,21 @@ test('statMagnitude sums raw values for tiebreaking', () => {
     expect(statMagnitude(599, 599, 599)).toBeGreaterThan(statMagnitude(251, 251, 251))
 })
 
+test('compareByStars orders by rating desc, then magnitude desc', () => {
+    const rows = [
+        {key: 'low-rating', rating: 3, magnitude: 9000},
+        {key: 'high-rating', rating: 6, magnitude: 300},
+        {key: 'tie-small', rating: 6, magnitude: 600},
+        {key: 'tie-big', rating: 6, magnitude: 900},
+    ]
+    const ordered = [...rows].sort(compareByStars).map((r) => r.key)
+    expect(ordered).toEqual(['tie-big', 'tie-small', 'high-rating', 'low-rating'])
+})
+
+test('compareByStars returns 0 when rating and magnitude are equal', () => {
+    expect(compareByStars({rating: 4, magnitude: 500}, {rating: 4, magnitude: 500})).toBe(0)
+})
+
 test('constants hold their documented values', () => {
     expect(STAR_STEP).toBe(250)
     expect(MAX_STARS_PER_STAT).toBe(3)

package/src/derivation/stars.ts

@@ -13,3 +13,13 @@ export function starRating(stat1: number, stat2: number, stat3: number): number
 export function statMagnitude(stat1: number, stat2: number, stat3: number): number {
     return stat1 + stat2 + stat3
 }
+
+export interface StarSortable {
+    rating: number
+    magnitude: number
+}
+
+// Star-quality ordering shared by every "sort by stars" surface: rating desc, then total sum of stats desc.
+export function compareByStars(a: StarSortable, b: StarSortable): number {
+    return b.rating - a.rating || b.magnitude - a.magnitude
+}

package/src/derivation/stratum.ts

@@ -3,13 +3,20 @@ import {hash512} from '../utils/hash'
 import {Coordinates, type CoordinatesType} from '../types'
 import {getItem} from '../data/catalog'
 import {getEligibleResources, getResourceWeight, yieldThresholdAt} from './resources'
-import {RESERVE_TIERS, rollTier, rollWithinTier, applyResourceTierMultiplier} from './tiers'
+import {
+    RESERVE_TIERS,
+    rollTier,
+    rollWithinTier,
+    applyResourceTierMultiplier,
+    type ReserveTier,
+} from './tiers'
 
 export interface StratumInfo {
     itemId: number
     seed: bigint
     richness: number
     reserve: number
+    tier: ReserveTier
 }
 
 export interface ResourceStats {
@@ -35,10 +42,10 @@ export function deriveStratum(
     const rawReserve = ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0
 
     if (rawReserve > yieldThresholdAt(stratum))
-        return {itemId: 0, seed: 0n, richness: 0, reserve: 0}
+        return {itemId: 0, seed: 0n, richness: 0, reserve: 0, tier: 'small'}
 
     const eligible = getEligibleResources(locationType, subtype, stratum)
-    if (eligible.length === 0) return {itemId: 0, seed: 0n, richness: 0, reserve: 0}
+    if (eligible.length === 0) return {itemId: 0, seed: 0n, richness: 0, reserve: 0, tier: 'small'}
 
     const resourceRoll = ((bytes[4] << 24) | (bytes[5] << 16) | (bytes[6] << 8) | bytes[7]) >>> 0
 
@@ -83,7 +90,7 @@ export function deriveStratum(
     const roll = 500 + 100 * z
     const richness = Math.max(1, Math.min(999, Math.round(roll)))
 
-    return {itemId: selectedItemId, seed: seedBigInt, richness, reserve}
+    return {itemId: selectedItemId, seed: seedBigInt, richness, reserve, tier}
 }
 
 /**

package/src/entities/makers.ts

@@ -140,7 +140,14 @@ export function makeEntity(packedItemId: number, state: EntityStateInput): Entit
 
         if (caps.engines) info.engines = caps.engines
         if (caps.generator) info.generator = caps.generator
-        if (caps.hauler) info.hauler = caps.hauler
+        if (caps.hauler) {
+            info.hauler = ServerContract.Types.hauler_stats.from({
+                capacity: caps.hauler.capacity,
+                efficiency: caps.hauler.efficiency,
+                drain: caps.hauler.drain,
+                capacity_by_tier: caps.hauler.capacityByTier,
+            })
+        }
         if (caps.warp) info.warp = caps.warp
         if (caps.launcher) {
             info.launcher = ServerContract.Types.launcher_stats.from({

package/src/index-module.ts

@@ -160,7 +160,9 @@ export {
     starsForStat,
     starRating,
     statMagnitude,
+    compareByStars,
 } from './derivation'
+export type {StarSortable} from './derivation'
 
 export {hash, hash512} from './utils/hash'
 export {validateDisplayName, normalizeDisplayName} from './utils/display-name'
@@ -424,11 +426,13 @@ export {
     computeStorageCapabilities,
     computeBatteryCapabilities,
     computeContainerCapabilities,
-    computeContainerT2Capabilities,
     computeWarpCapabilities,
     computeLauncherCapabilities,
     computeBaseCapacity,
     computeEntityCapabilities,
+    CAPACITY_TIER_TABLE,
+    capacityTierMultiplier,
+    applyCapacityTier,
     GATHERER_DEPTH_TABLE,
     GATHERER_DEPTH_MAX_TIER,
     gathererDepthForTier,

package/src/managers/actions.ts

@@ -471,6 +471,16 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    swaptile(hubId: UInt64Type, aGx: number, aGy: number, bGx: number, bGy: number): Action {
+        return this.server.action('swaptile', {
+            hub_id: UInt64.from(hubId),
+            a_gx: aGx,
+            a_gy: aGy,
+            b_gx: bGx,
+            b_gy: bGy,
+        })
+    }
+
     buildplot(entityId: UInt64Type, plotId: UInt64Type): Action {
         return this.server.action('buildplot', {
             builder_id: UInt64.from(entityId),

package/src/nft/buildImmutableData.ts

@@ -269,7 +269,7 @@ export function buildModuleImmutable(
             base.push({first: 'resonance', second: ['uint16', res]})
             base.push({first: 'plasticity', second: ['uint16', pla]})
             base.push({first: 'conductivity', second: ['uint16', con]})
-            base.push({first: 'capacity', second: ['uint8', computeHaulerCapacity(res)]})
+            base.push({first: 'capacity', second: ['uint8', computeHaulerCapacity(res, item.tier)]})
             base.push({first: 'efficiency', second: ['uint16', computeHaulerEfficiency(pla)]})
             base.push({first: 'drain', second: ['uint16', computeHaulerDrain(con)]})
             break

package/src/nft/description.ts

@@ -18,10 +18,13 @@ import {
     ITEM_EXTRACTOR_T1_PACKED,
     ITEM_FACTORY_T1_PACKED,
     ITEM_GATHERER_T1,
+    ITEM_GATHERER_T2,
     ITEM_GENERATOR_T1,
+    ITEM_HAULER_SHIP_T2_PACKED,
     ITEM_HAULER_T1,
     ITEM_BATTERY_T1,
     ITEM_LOADER_T1,
+    ITEM_PROSPECTOR_T2_PACKED,
     ITEM_SHIP_T1_PACKED,
     ITEM_STORAGE_T1,
     ITEM_WAREHOUSE_T1_PACKED,
@@ -50,11 +53,6 @@ export function computeBaseCapacityContainer(stats: bigint): number {
     return Math.floor(22_000_000 * 6 ** (s / 1998))
 }
 
-export function computeBaseCapacityContainerT2(stats: bigint): number {
-    const s = decodeStat(stats, 0) + decodeStat(stats, 2)
-    return Math.floor(24_000_000 * 6 ** (s / 2947))
-}
-
 export function computeBaseCapacityWarehouse(stats: bigint): number {
     const s = decodeStat(stats, 0) + decodeStat(stats, 2)
     return Math.floor(100_000_000 * 6 ** (s / 1998))
@@ -83,7 +81,8 @@ export const computeLoaderMass = (ins: number): number => Math.max(200, 2000 - i
 export const computeLoaderThrust = (pla: number): number => 1 + idiv(pla * pla, 10000)
 export const computeCrafterSpeed = (rea: number): number => 100 + idiv(rea * 4, 5)
 export const computeCrafterDrain = (fin: number): number => Math.max(5, 30 - idiv(fin, 33))
-export const computeHaulerCapacity = (fin: number): number => Math.max(1, 1 + idiv(fin, 400))
+export const computeHaulerCapacity = (fin: number, tier: number): number =>
+    Math.max(tier, tier + idiv(fin, 400))
 export const computeHaulerEfficiency = (con: number): number => 2000 + con * 6
 export const computeHaulerDrain = (com: number): number => Math.max(3, 15 - idiv(com, 80))
 export const computeWarpRange = (stat: number): number => 100 + stat * 3
@@ -114,6 +113,10 @@ export function entityDisplayName(itemId: number): string {
             return 'Container'
         case ITEM_CONTAINER_T2_PACKED:
             return 'Container'
+        case ITEM_PROSPECTOR_T2_PACKED:
+            return 'Prospector'
+        case ITEM_HAULER_SHIP_T2_PACKED:
+            return 'Hauler'
         default:
             return 'Entity'
     }
@@ -127,6 +130,8 @@ export function moduleDisplayName(itemId: number): string {
             return 'Reactor'
         case ITEM_GATHERER_T1:
             return 'Limpet Bay'
+        case ITEM_GATHERER_T2:
+            return 'Gatherer (T2)'
         case ITEM_LOADER_T1:
             return 'Shuttle Bay'
         case ITEM_CRAFTER_T1:
@@ -202,7 +207,8 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             const res = decodeStat(stats, 0)
             const pla = decodeStat(stats, 1)
             const ref = decodeStat(stats, 2)
-            out += `  Capacity ${computeHaulerCapacity(res)}  Efficiency ${computeHaulerEfficiency(pla)}  Drain ${computeHaulerDrain(ref)}`
+            const tier = getItem(itemId).tier
+            out += `  Capacity ${computeHaulerCapacity(res, tier)}  Efficiency ${computeHaulerEfficiency(pla)}  Drain ${computeHaulerDrain(ref)}`
             break
         }
         case MODULE_WARP: {
@@ -230,18 +236,21 @@ export function buildEntityDescription(
 ): string {
     const hullMass = computeBaseHullmass(hullStats)
     let baseCapacity = 0
-    if (itemId === ITEM_SHIP_T1_PACKED) {
+    if (
+        itemId === ITEM_SHIP_T1_PACKED ||
+        itemId === ITEM_PROSPECTOR_T2_PACKED ||
+        itemId === ITEM_HAULER_SHIP_T2_PACKED
+    ) {
         baseCapacity = computeBaseCapacityShip(hullStats)
     } else if (itemId === ITEM_WAREHOUSE_T1_PACKED) {
         baseCapacity = computeBaseCapacityWarehouse(hullStats)
     } else if (
         itemId === ITEM_EXTRACTOR_T1_PACKED ||
         itemId === ITEM_FACTORY_T1_PACKED ||
-        itemId === ITEM_CONTAINER_T1_PACKED
+        itemId === ITEM_CONTAINER_T1_PACKED ||
+        itemId === ITEM_CONTAINER_T2_PACKED
     ) {
         baseCapacity = computeBaseCapacityContainer(hullStats)
-    } else if (itemId === ITEM_CONTAINER_T2_PACKED) {
-        baseCapacity = computeBaseCapacityContainerT2(hullStats)
     }
 
     let out = entityDisplayName(itemId)

package/src/resolution/describe-module.ts

@@ -20,6 +20,7 @@ export interface ModuleDescription {
 export interface RenderDescriptionOptions {
     translate?: (id: string, fallback: string) => string
     formatNumber?: (n: number) => string
+    formatParam?: (paramName: string, value: number, descId: string) => string | undefined
 }
 
 interface TemplateSpec {
@@ -27,6 +28,7 @@ interface TemplateSpec {
     template: string
     params: readonly [string, string][]
     highlightKeys: readonly string[]
+    derive?: Record<string, (get: (label: string) => number) => number>
 }
 
 const TEMPLATES: Record<string, TemplateSpec> = {
@@ -53,13 +55,15 @@ const TEMPLATES: Record<string, TemplateSpec> = {
     gatherer: {
         id: 'module.gatherer.description',
         template:
-            'mines resources at {yield} yield to a max depth of {depth} while draining {drain} energy per second',
+            'mines resources at {yield} yield to a max depth of {depth} while draining {drain} energy per minute',
         params: [
             ['yield', 'Yield'],
             ['depth', 'Depth'],
-            ['drain', 'Drain'],
         ],
         highlightKeys: ['yield', 'depth', 'drain'],
+        derive: {
+            drain: (get) => Math.round((get('Drain') / 10000) * 60 * 10) / 10,
+        },
     },
     loading: {
         id: 'module.loading.description',
@@ -72,12 +76,12 @@ const TEMPLATES: Record<string, TemplateSpec> = {
     },
     crafting: {
         id: 'module.crafting.description',
-        template: 'manufactures items at {speed} speed while draining {drain} energy per second',
-        params: [
-            ['speed', 'Speed'],
-            ['drain', 'Drain'],
-        ],
+        template: 'manufactures items at {speed} speed while draining {drain} energy per minute',
+        params: [['speed', 'Speed']],
         highlightKeys: ['speed', 'drain'],
+        derive: {
+            drain: (get) => Math.round(((get('Drain') * get('Speed')) / 150000) * 60 * 10) / 10,
+        },
     },
     storage: {
         id: 'module.storage.description',
@@ -114,6 +118,12 @@ export function describeModule(input: CapabilityInput): ModuleDescription | null
         const attr = input.attributes.find((a) => a.label === attrLabel)
         if (attr) params[paramName] = attr.value
     }
+    if (spec.derive) {
+        const get = (label: string) => input.attributes.find((a) => a.label === label)?.value ?? 0
+        for (const [paramName, fn] of Object.entries(spec.derive)) {
+            params[paramName] = fn(get)
+        }
+    }
     return {
         id: spec.id,
         template: spec.template,
@@ -158,7 +168,10 @@ export function renderDescription(
         if (raw === undefined) {
             spans.push({text: `{${paramName}}`})
         } else {
-            const formatted = typeof raw === 'number' ? formatNumber(raw) : raw
+            const formatted =
+                typeof raw === 'number'
+                    ? (options?.formatParam?.(paramName, raw, desc.id) ?? formatNumber(raw))
+                    : raw
             const highlight = (desc.highlightKeys as readonly string[]).includes(paramName)
             spans.push(highlight ? {text: formatted, highlight: true} : {text: formatted})
         }

package/src/resolution/resolve-item.test.ts

@@ -2,10 +2,11 @@ import {expect, test} from 'bun:test'
 import {UInt16, UInt64} from '@wharfkit/antelope'
 import {resolveItem} from './resolve-item'
 import {encodeStats} from '../derivation/crafting'
-import {computeContainerCapabilities} from '../derivation/capabilities'
+import {computeBaseHullmass, computeContainerCapabilities} from '../derivation/capabilities'
 import {
     ITEM_EXTRACTOR_T1_PACKED,
     ITEM_FACTORY_T1_PACKED,
+    ITEM_HUB_T1_PACKED,
     ITEM_MASS_DRIVER_T1_PACKED,
     ITEM_MASS_CATCHER_T1_PACKED,
 } from '../data/item-ids'
@@ -35,3 +36,13 @@ for (const [label, itemId] of CONTAINER_ENTITIES) {
         expect(capacity).toBe(expected)
     })
 }
+
+test('resolveItem resolves the station hub with hullmass and zero cargo capacity', () => {
+    const stats = hullStats(300, 100, 400)
+    const resolved = resolveItem(UInt16.from(ITEM_HUB_T1_PACKED), stats)
+    const hull = resolved.attributes?.find((g) => g.capability === 'Hull')
+    expect(hull?.attributes.find((a) => a.label === 'Mass')?.value).toBe(
+        computeBaseHullmass({density: 100})
+    )
+    expect(hull?.attributes.find((a) => a.label === 'Capacity')?.value).toBe(0)
+})