@shipload/sdk 2.0.0-rc13 → 2.0.0-rc15

package/src/derivation/stats.ts

@@ -8,7 +8,7 @@ export interface StatDefinition {
     inverted?: boolean
 }
 
-const METAL_STATS: StatDefinition[] = [
+const ORE_STATS: StatDefinition[] = [
     {
         key: 'strength',
         label: 'Strength',
@@ -30,24 +30,24 @@ const METAL_STATS: StatDefinition[] = [
     },
 ]
 
-const PRECIOUS_STATS: StatDefinition[] = [
+const CRYSTAL_STATS: StatDefinition[] = [
     {
         key: 'conductivity',
         label: 'Conductivity',
         abbreviation: 'CON',
-        purpose: 'Efficiency of energy/signal transfer',
+        purpose: 'Efficiency of energy/signal transfer through crystalline lattice',
     },
     {
-        key: 'ductility',
-        label: 'Ductility',
-        abbreviation: 'DUC',
-        purpose: 'Ability to be worked into fine, precise shapes',
+        key: 'resonance',
+        label: 'Resonance',
+        abbreviation: 'RES',
+        purpose: 'Frequency tuning and piezoelectric response — storage and amplification',
     },
     {
         key: 'reflectivity',
         label: 'Reflectivity',
         abbreviation: 'REF',
-        purpose: 'Surface quality for heat management and precision optics',
+        purpose: 'Optical refraction and reflection — lenses, mirrors, focus',
     },
 ]
 
@@ -72,54 +72,54 @@ const GAS_STATS: StatDefinition[] = [
     },
 ]
 
-const MINERAL_STATS: StatDefinition[] = [
+const REGOLITH_STATS: StatDefinition[] = [
     {
-        key: 'resonance',
-        label: 'Resonance',
-        abbreviation: 'RES',
-        purpose: 'Energy field interaction — storage, focusing, projection',
+        key: 'composition',
+        label: 'Composition',
+        abbreviation: 'COM',
+        purpose: 'Mineral/metal mix — drives sensor, chip, and optic crafting quality',
     },
     {
         key: 'hardness',
         label: 'Hardness',
         abbreviation: 'HRD',
-        purpose: 'Resistance to wear — cutting surfaces, penetration',
+        purpose: 'Particle hardness — cutting surfaces, abrasives, wear resistance',
     },
     {
-        key: 'clarity',
-        label: 'Clarity',
-        abbreviation: 'CLR',
-        purpose: 'Crystalline perfection — precision optics',
+        key: 'fineness',
+        label: 'Fineness',
+        abbreviation: 'FIN',
+        purpose: 'Grain size — fine powder for smooth composites and sintering',
     },
 ]
 
-const ORGANIC_STATS: StatDefinition[] = [
+const BIOMASS_STATS: StatDefinition[] = [
     {
         key: 'plasticity',
         label: 'Plasticity',
         abbreviation: 'PLA',
-        purpose: 'Ease of reshaping — speeds processing',
+        purpose: 'Flexibility and deformation under load',
     },
     {
         key: 'insulation',
         label: 'Insulation',
         abbreviation: 'INS',
-        purpose: 'Energy containment — reduces energy loss',
+        purpose: 'Thermal and electrical blocking capacity',
     },
     {
-        key: 'purity',
-        label: 'Purity',
-        abbreviation: 'PUR',
-        purpose: 'Biological cleanliness — better composites and lubricants',
+        key: 'saturation',
+        label: 'Saturation',
+        abbreviation: 'SAT',
+        purpose: 'Concentration of useful organic compounds per unit',
     },
 ]
 
 const STAT_MAP: Record<ResourceCategory, StatDefinition[]> = {
-    metal: METAL_STATS,
-    precious: PRECIOUS_STATS,
+    ore: ORE_STATS,
+    crystal: CRYSTAL_STATS,
     gas: GAS_STATS,
-    mineral: MINERAL_STATS,
-    organic: ORGANIC_STATS,
+    regolith: REGOLITH_STATS,
+    biomass: BIOMASS_STATS,
 }
 
 export function getStatDefinitions(category: ResourceCategory): StatDefinition[] {

package/src/derivation/stratum.ts

@@ -89,6 +89,18 @@ export function deriveStratum(
     return {itemId: selectedItemId, seed: seedBigInt, richness, reserve}
 }
 
+/**
+ * Derives the three stat values for a raw resource from a deposit's
+ * entropy seed (hash-based, weibull-transformed).
+ *
+ * **Use only on deposit seeds** — the bigint returned by `deriveStratum`
+ * or carried on a `MassDeposit`. Do NOT call this on a cargo item's
+ * `stats` field; cargo stats are bit-packed and must be read via
+ * `decodeStat` (or `decodeStackStats` for category-mapped output).
+ *
+ * Passing a cargo `stats` value here produces meaningless output
+ * (hash of the packed bits, unrelated to the actual stats).
+ */
 export function deriveResourceStats(seed: bigint): ResourceStats {
     const seedBytes = new Uint8Array(8)
     for (let i = 0; i < 8; i++) {

package/src/entities/container.ts

@@ -13,6 +13,7 @@ export interface ContainerStateInput {
     hullmass: number
     capacity: number
     cargomass?: number
+    cargo?: ServerContract.Types.cargo_item[]
     schedule?: ServerContract.Types.schedule
 }
 
@@ -75,12 +76,12 @@ export function computeContainerCapabilities(stats: Record<string, number>): {
 } {
     const density = stats['density'] ?? 500
     const strength = stats['strength'] ?? 500
-    const ductility = stats['ductility'] ?? 500
-    const purity = stats['purity'] ?? 500
+    const fineness = stats['fineness'] ?? 500
+    const saturation = stats['saturation'] ?? 500
 
     const hullmass = 25000 + 75 * density
 
-    const statSum = strength + ductility + purity
+    const statSum = strength + fineness + saturation
     const exponent = statSum / 2997
     const capacity = Math.floor(1000000 * Math.pow(10, exponent))
 
@@ -93,12 +94,12 @@ export function computeContainerT2Capabilities(stats: Record<string, number>): {
 } {
     const strength = stats['strength'] ?? 0
     const density = stats['density'] ?? 0
-    const ductility = stats['ductility'] ?? 0
-    const purity = stats['purity'] ?? 0
+    const fineness = stats['fineness'] ?? 0
+    const saturation = stats['saturation'] ?? 0
 
     const hullmass = 20000 + 50 * density
 
-    const statSum = strength + ductility + purity
+    const statSum = strength + fineness + saturation
     const exponent = statSum / 2500
     const capacity = Math.floor(1500000 * Math.pow(10, exponent))
 

package/src/entities/makers.ts

@@ -1,8 +1,86 @@
-import {Name, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
+import {Name, UInt16, UInt32, UInt64, UInt8} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
-import {Ship, ShipStateInput} from './ship'
-import {Warehouse, WarehouseStateInput} from './warehouse'
+import {PackedModuleInput, Ship, ShipStateInput} from './ship'
+import {computeWarehouseCapabilities, Warehouse, WarehouseStateInput} from './warehouse'
 import {Container, ContainerStateInput} from './container'
+import {
+    getEntitySlotLayout,
+    getModuleRecipeByItemId,
+    ITEM_SHIP_T1_PACKED,
+    ITEM_WAREHOUSE_T1_PACKED,
+} from '../data/recipes'
+import {getModuleCapabilityType, MODULE_STORAGE, moduleAccepts} from '../capabilities/modules'
+import {computeShipCapabilities, computeStorageCapabilities} from './ship-deploy'
+import {decodeCraftedItemStats} from '../derivation/crafting'
+
+function assignModulesToSlots(
+    packedEntityItemId: number,
+    modules: PackedModuleInput[],
+    entityLabel: string
+): ServerContract.Types.module_entry[] {
+    const slots = getEntitySlotLayout(packedEntityItemId)
+    const result: Array<{type: number; installed?: ServerContract.Types.packed_module}> = slots.map(
+        (s) => ({type: s.type, installed: undefined})
+    )
+
+    for (const mod of modules) {
+        const itemId = Number(UInt16.from(mod.itemId).value.toString())
+        const modType = getModuleCapabilityType(itemId)
+        const slotIdx = result.findIndex((r) => !r.installed && moduleAccepts(r.type, modType))
+        if (slotIdx === -1) {
+            const recipe = getModuleRecipeByItemId(itemId)
+            const modName = recipe?.name ?? `item ${itemId}`
+            throw new Error(
+                `No compatible slot for module ${modName} (type ${modType}) on ${entityLabel}`
+            )
+        }
+        result[slotIdx].installed = ServerContract.Types.packed_module.from({
+            item_id: UInt16.from(mod.itemId),
+            stats: UInt64.from(mod.stats),
+        })
+    }
+
+    return result.map((r) =>
+        ServerContract.Types.module_entry.from({
+            type: UInt8.from(r.type),
+            installed: r.installed,
+        })
+    )
+}
+
+function decodePackedInput(m: PackedModuleInput): {itemId: number; stats: bigint} {
+    return {
+        itemId: Number(UInt16.from(m.itemId).value.toString()),
+        stats: BigInt(UInt64.from(m.stats).toString()),
+    }
+}
+
+function computeStorageBonus(
+    decoded: {itemId: number; stats: bigint}[],
+    baseCapacity: number
+): number {
+    let totalBonus = 0
+    for (const m of decoded) {
+        if (getModuleCapabilityType(m.itemId) !== MODULE_STORAGE) continue
+        const stats = decodeCraftedItemStats(m.itemId, m.stats)
+        const {capacityBonus} = computeStorageCapabilities(stats, baseCapacity)
+        totalBonus += capacityBonus
+    }
+    return totalBonus
+}
+
+function deriveShipFromModules(
+    modules: PackedModuleInput[],
+    baseCapacity: number
+): {
+    capabilities: ReturnType<typeof computeShipCapabilities>
+    finalCapacity: number
+} {
+    const decoded = modules.map(decodePackedInput)
+    const capabilities = computeShipCapabilities(decoded)
+    const totalBonus = computeStorageBonus(decoded, baseCapacity)
+    return {capabilities, finalCapacity: baseCapacity + totalBonus}
+}
 
 export function makeShip(state: ShipStateInput): Ship {
     const info: Record<string, unknown> = {
@@ -19,14 +97,32 @@ export function makeShip(state: ShipStateInput): Ship {
         pending_tasks: [],
     }
     if (state.hullmass !== undefined) info.hullmass = UInt32.from(state.hullmass)
-    if (state.capacity !== undefined) info.capacity = UInt32.from(state.capacity)
     if (state.energy !== undefined) info.energy = UInt16.from(state.energy)
-    if (state.engines) info.engines = state.engines
-    if (state.generator) info.generator = state.generator
-    if (state.loaders) info.loaders = state.loaders
     if (state.schedule) info.schedule = state.schedule
+
+    let moduleEntries: ServerContract.Types.module_entry[] = []
+    if (state.modules && state.modules.length > 0) {
+        moduleEntries = assignModulesToSlots(ITEM_SHIP_T1_PACKED, state.modules, 'Ship T1')
+        const {capabilities, finalCapacity} = deriveShipFromModules(
+            state.modules,
+            state.capacity ?? 0
+        )
+        if (capabilities.engines) info.engines = capabilities.engines
+        if (capabilities.generator) info.generator = capabilities.generator
+        if (capabilities.gatherer) info.gatherer = capabilities.gatherer
+        if (capabilities.hauler) info.hauler = capabilities.hauler
+        if (capabilities.loaders) info.loaders = capabilities.loaders
+        if (capabilities.crafter) info.crafter = capabilities.crafter
+        if (state.capacity !== undefined) info.capacity = UInt32.from(finalCapacity)
+    } else {
+        moduleEntries = assignModulesToSlots(ITEM_SHIP_T1_PACKED, [], 'Ship T1')
+        if (state.capacity !== undefined) info.capacity = UInt32.from(state.capacity)
+    }
+
     const entityInfo = ServerContract.Types.entity_info.from(info)
-    return new Ship(entityInfo)
+    const ship = new Ship(entityInfo)
+    ship.setModules(moduleEntries)
+    return ship
 }
 
 export function makeWarehouse(state: WarehouseStateInput): Warehouse {
@@ -45,10 +141,29 @@ export function makeWarehouse(state: WarehouseStateInput): Warehouse {
         pending_tasks: [],
     }
     if (state.hullmass !== undefined) info.hullmass = UInt32.from(state.hullmass)
-    if (state.loaders) info.loaders = state.loaders
     if (state.schedule) info.schedule = state.schedule
+
+    let moduleEntries: ServerContract.Types.module_entry[] = []
+    if (state.modules && state.modules.length > 0) {
+        moduleEntries = assignModulesToSlots(
+            ITEM_WAREHOUSE_T1_PACKED,
+            state.modules,
+            'Warehouse T1'
+        )
+        const decoded = state.modules.map(decodePackedInput)
+        const capabilities = computeWarehouseCapabilities(decoded)
+        if (capabilities.loaders) info.loaders = capabilities.loaders
+
+        const totalBonus = computeStorageBonus(decoded, state.capacity)
+        info.capacity = UInt32.from(state.capacity + totalBonus)
+    } else {
+        moduleEntries = assignModulesToSlots(ITEM_WAREHOUSE_T1_PACKED, [], 'Warehouse T1')
+    }
+
     const entityInfo = ServerContract.Types.entity_info.from(info)
-    return new Warehouse(entityInfo)
+    const warehouse = new Warehouse(entityInfo)
+    warehouse.setModules(moduleEntries)
+    return warehouse
 }
 
 export function makeContainer(state: ContainerStateInput): Container {
@@ -61,7 +176,7 @@ export function makeContainer(state: ContainerStateInput): Container {
         hullmass: UInt32.from(state.hullmass),
         capacity: UInt32.from(state.capacity),
         cargomass: UInt32.from(state.cargomass || 0),
-        cargo: [],
+        cargo: state.cargo || [],
         is_idle: !state.schedule,
         current_task_elapsed: UInt32.from(0),
         current_task_remaining: UInt32.from(0),

package/src/entities/ship-deploy.ts

@@ -15,11 +15,11 @@ export function computeShipHullCapabilities(stats: Record<string, number>): {
 } {
     const density = stats.density ?? 500
     const strength = stats.strength ?? 500
-    const ductility = stats.ductility ?? 500
-    const purity = stats.purity ?? 500
+    const fineness = stats.fineness ?? 500
+    const saturation = stats.saturation ?? 500
 
     const hullmass = 25000 + 75 * density
-    const statSum = strength + ductility + purity
+    const statSum = strength + fineness + saturation
     const exponent = statSum / 2997.0
     const capacity = Math.floor(1000000 * Math.pow(10, exponent))
 
@@ -44,11 +44,11 @@ export function computeGeneratorCapabilities(stats: Record<string, number>): {
     recharge: number
 } {
     const res = stats.resonance ?? 500
-    const clr = stats.clarity ?? 500
+    const ref = stats.reflectivity ?? 500
 
     return {
         capacity: 300 + Math.floor(res / 6),
-        recharge: 5 + Math.floor((clr * 15) / 1000),
+        recharge: 1 + Math.floor((ref * 3) / 1000),
     }
 }
 
@@ -65,7 +65,7 @@ export function computeGathererCapabilities(stats: Record<string, number>): {
 
     return {
         yield: 200 + str,
-        drain: Math.max(10, 50 - Math.floor(con / 20)),
+        drain: Math.max(250, 1250 - Math.floor((con * 25) / 20)),
         depth: 200 + Math.floor((tol * 3) / 2),
         speed: 100 + Math.floor((ref * 4) / 5),
     }
@@ -76,11 +76,11 @@ export function computeLoaderCapabilities(stats: Record<string, number>): {
     thrust: number
     quantity: number
 } {
-    const duc = stats.ductility ?? 500
+    const fin = stats.fineness ?? 500
     const pla = stats.plasticity ?? 500
 
     return {
-        mass: Math.max(200, 2000 - Math.floor(duc * 2)),
+        mass: Math.max(200, 2000 - Math.floor(fin * 2)),
         thrust: 1 + Math.floor(pla / 500),
         quantity: 1,
     }
@@ -91,11 +91,11 @@ export function computeManufacturingCapabilities(stats: Record<string, number>):
     drain: number
 } {
     const rea = stats.reactivity ?? 500
-    const clr = stats.clarity ?? 500
+    const com = stats.composition ?? 500
 
     return {
         speed: 100 + Math.floor((rea * 4) / 5),
-        drain: Math.max(5, 30 - Math.floor(clr / 33)),
+        drain: Math.max(5, 30 - Math.floor(com / 33)),
     }
 }
 
@@ -106,12 +106,12 @@ export function computeHaulerCapabilities(stats: Record<string, number>): {
 } {
     const res = stats.resonance ?? 500
     const con = stats.conductivity ?? 500
-    const clr = stats.clarity ?? 500
+    const ref = stats.reflectivity ?? 500
 
     return {
         capacity: Math.max(1, 1 + Math.floor(res / 400)),
         efficiency: 2000 + con * 6,
-        drain: Math.max(3, 15 - Math.floor(clr / 80)),
+        drain: Math.max(3, 15 - Math.floor(ref / 80)),
     }
 }
 
@@ -122,10 +122,10 @@ export function computeStorageCapabilities(
     capacityBonus: number
 } {
     const strength = stats.strength ?? 500
-    const ductility = stats.ductility ?? 500
-    const purity = stats.purity ?? 500
+    const fineness = stats.fineness ?? 500
+    const saturation = stats.saturation ?? 500
 
-    const statSum = strength + ductility + purity
+    const statSum = strength + fineness + saturation
     const capacityBonus = Math.floor(
         (baseCapacity * (10 + Math.floor((statSum * 10) / 2997))) / 100
     )
@@ -139,11 +139,11 @@ export function computeWarehouseHullCapabilities(stats: Record<string, number>):
 } {
     const density = stats.density ?? 500
     const strength = stats.strength ?? 500
-    const ductility = stats.ductility ?? 500
-    const purity = stats.purity ?? 500
+    const fineness = stats.fineness ?? 500
+    const saturation = stats.saturation ?? 500
 
     const hullmass = 25000 + 75 * density
-    const statSum = strength + ductility + purity
+    const statSum = strength + fineness + saturation
     const exponent = statSum / 2997.0
     const capacity = Math.floor(20000000 * Math.pow(10, exponent))
 
@@ -160,7 +160,7 @@ export interface ShipCapabilities {
 }
 
 export function computeShipCapabilities(
-    modules: {itemId: number; seed: bigint}[]
+    modules: {itemId: number; stats: bigint}[]
 ): ShipCapabilities {
     const ship: ShipCapabilities = {}
 
@@ -169,7 +169,7 @@ export function computeShipCapabilities(
         let totalThrust = 0
         let totalDrain = 0
         for (const m of engineModules) {
-            const caps = computeEngineCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
+            const caps = computeEngineCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
             totalThrust += caps.thrust
             totalDrain += caps.drain
         }
@@ -183,7 +183,7 @@ export function computeShipCapabilities(
         let totalCapacity = 0
         let totalRecharge = 0
         for (const m of generatorModules) {
-            const caps = computeGeneratorCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
+            const caps = computeGeneratorCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
             totalCapacity += caps.capacity
             totalRecharge += caps.recharge
         }
@@ -199,7 +199,7 @@ export function computeShipCapabilities(
         let totalDepth = 0
         let totalSpeed = 0
         for (const m of gathererModules) {
-            const caps = computeGathererCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
+            const caps = computeGathererCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
             totalYield += caps.yield
             totalDrain += caps.drain
             totalDepth += caps.depth
@@ -214,12 +214,7 @@ export function computeShipCapabilities(
         let weightedEffNum = 0
         let totalDrain = 0
         for (const m of haulerModules) {
-            const decoded = decodeCraftedItemStats(m.itemId, m.seed)
-            const caps = computeHaulerCapabilities({
-                resonance: decoded.capacity,
-                conductivity: decoded.efficiency,
-                clarity: decoded.drain,
-            })
+            const caps = computeHaulerCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
             totalCapacity += caps.capacity
             weightedEffNum += caps.efficiency * caps.capacity
             totalDrain += caps.drain
@@ -237,7 +232,7 @@ export function computeShipCapabilities(
         let totalThrust = 0
         let totalQuantity = 0
         for (const m of loaderModules) {
-            const caps = computeLoaderCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
+            const caps = computeLoaderCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
             totalMass += caps.mass
             totalThrust += caps.thrust
             totalQuantity += caps.quantity
@@ -252,7 +247,7 @@ export function computeShipCapabilities(
         let totalSpeed = 0
         let totalDrain = 0
         for (const m of crafterModules) {
-            const caps = computeManufacturingCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
+            const caps = computeManufacturingCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
             totalSpeed += caps.speed
             totalDrain += caps.drain
         }

package/src/entities/ship.ts

@@ -1,4 +1,4 @@
-import {UInt16, UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {UInt16, UInt16Type, UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
 import {Coordinates, CoordinatesType} from '../types'
 import {
@@ -23,6 +23,11 @@ import {
 } from '../capabilities/movement'
 import * as schedule from '../scheduling/schedule'
 
+export interface PackedModuleInput {
+    itemId: UInt16Type
+    stats: UInt64Type
+}
+
 export interface ShipStateInput {
     id: UInt64Type
     owner: string
@@ -31,9 +36,7 @@ export interface ShipStateInput {
     hullmass?: number
     capacity?: number
     energy?: number
-    engines?: ServerContract.Types.movement_stats
-    generator?: ServerContract.Types.energy_stats
-    loaders?: ServerContract.Types.loader_stats
+    modules?: PackedModuleInput[]
     schedule?: ServerContract.Types.schedule
     cargo?: ServerContract.Types.cargo_item[]
 }
@@ -47,11 +50,20 @@ type MovementEntity = {
 export class Ship extends ServerContract.Types.entity_info {
     private _sched?: ScheduleAccessor
     private _inv?: InventoryAccessor
+    private _modules: ServerContract.Types.module_entry[] = []
 
     get name(): string {
         return this.entity_name
     }
 
+    get modules(): ServerContract.Types.module_entry[] {
+        return this._modules
+    }
+
+    setModules(modules: ServerContract.Types.module_entry[]): void {
+        this._modules = modules
+    }
+
     get inv(): InventoryAccessor {
         return (this._inv ??= new InventoryAccessor(this))
     }

package/src/entities/warehouse.ts

@@ -6,6 +6,10 @@ import {ScheduleAccessor} from '../scheduling/accessor'
 import {InventoryAccessor} from './inventory-accessor'
 import {EntityInventory} from './entity-inventory'
 import * as schedule from '../scheduling/schedule'
+import type {PackedModuleInput} from './ship'
+import {decodeCraftedItemStats} from '../derivation/crafting'
+import {getModuleCapabilityType, MODULE_LOADER} from '../capabilities/modules'
+import {computeLoaderCapabilities} from './ship-deploy'
 
 export interface WarehouseStateInput {
     id: UInt64Type
@@ -14,7 +18,7 @@ export interface WarehouseStateInput {
     coordinates: CoordinatesType | {x: number; y: number; z?: number}
     hullmass?: number
     capacity: number
-    loaders?: ServerContract.Types.loader_stats
+    modules?: PackedModuleInput[]
     schedule?: ServerContract.Types.schedule
     cargo?: ServerContract.Types.cargo_item[]
 }
@@ -22,11 +26,20 @@ export interface WarehouseStateInput {
 export class Warehouse extends ServerContract.Types.entity_info {
     private _sched?: ScheduleAccessor
     private _inv?: InventoryAccessor
+    private _modules: ServerContract.Types.module_entry[] = []
 
     get name(): string {
         return this.entity_name
     }
 
+    get modules(): ServerContract.Types.module_entry[] {
+        return this._modules
+    }
+
+    setModules(modules: ServerContract.Types.module_entry[]): void {
+        this._modules = modules
+    }
+
     get inv(): InventoryAccessor {
         return (this._inv ??= new InventoryAccessor(this))
     }
@@ -89,3 +102,25 @@ export class Warehouse extends ServerContract.Types.entity_info {
         return hull.adding(this.totalCargoMass)
     }
 }
+
+export function computeWarehouseCapabilities(modules: {itemId: number; stats: bigint}[]): {
+    loaders?: {mass: number; thrust: number; quantity: number}
+} {
+    const warehouse: {loaders?: {mass: number; thrust: number; quantity: number}} = {}
+
+    const loaderModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_LOADER)
+    if (loaderModules.length > 0) {
+        let totalMass = 0
+        let totalThrust = 0
+        let totalQuantity = 0
+        for (const m of loaderModules) {
+            const caps = computeLoaderCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
+            totalMass += caps.mass
+            totalThrust += caps.thrust
+            totalQuantity += caps.quantity
+        }
+        warehouse.loaders = {mass: totalMass, thrust: totalThrust, quantity: totalQuantity}
+    }
+
+    return warehouse
+}

package/src/format.ts

@@ -0,0 +1,12 @@
+export function formatMass(kg: number): string {
+    const t = kg / 1000
+    const fixed = t.toFixed(2)
+    const trimmed = fixed.replace(/\.?0+$/, '')
+    return `${trimmed} t`
+}
+
+export function formatMassDelta(kg: number): string {
+    if (kg === 0) return '0 t'
+    const sign = kg > 0 ? '+' : '-'
+    return `${sign}${formatMass(Math.abs(kg))}`
+}