@shipload/sdk 1.0.0-next.1 → 1.0.0-next.11

package/src/derivation/capability-mappings.ts

@@ -0,0 +1,122 @@
+import {SLOT_FORMULAS, type SlotConsumerKind} from '../data/capability-formulas'
+import {getStatDefinitions, type StatDefinition} from './stats'
+import {
+    getRecipe,
+    type Recipe,
+    type RecipeInput,
+    type RecipeInputCategory,
+} from '../data/recipes-runtime'
+import {
+    ITEM_ENGINE_T1,
+    ITEM_EXTRACTOR_T1_PACKED,
+    ITEM_GENERATOR_T1,
+    ITEM_GATHERER_T1,
+    ITEM_LOADER_T1,
+    ITEM_CRAFTER_T1,
+    ITEM_STORAGE_T1,
+    ITEM_HAULER_T1,
+    ITEM_WARP_T1,
+    ITEM_SHIP_T1_PACKED,
+    ITEM_CONTAINER_T1_PACKED,
+    ITEM_WAREHOUSE_T1_PACKED,
+    ITEM_CONTAINER_T2_PACKED,
+} from '../data/item-ids'
+import type {StatMapping} from '../data/capabilities'
+
+export const KIND_TO_ITEM_ID: Record<SlotConsumerKind, number> = {
+    engine: ITEM_ENGINE_T1,
+    generator: ITEM_GENERATOR_T1,
+    gatherer: ITEM_GATHERER_T1,
+    loader: ITEM_LOADER_T1,
+    crafter: ITEM_CRAFTER_T1,
+    storage: ITEM_STORAGE_T1,
+    hauler: ITEM_HAULER_T1,
+    warp: ITEM_WARP_T1,
+    'ship-t1': ITEM_SHIP_T1_PACKED,
+    'container-t1': ITEM_CONTAINER_T1_PACKED,
+    'warehouse-t1': ITEM_WAREHOUSE_T1_PACKED,
+    'extractor-t1': ITEM_EXTRACTOR_T1_PACKED,
+    'container-t2': ITEM_CONTAINER_T2_PACKED,
+}
+
+function isCategoryInput(input: RecipeInput): input is RecipeInputCategory {
+    return 'category' in input
+}
+
+/**
+ * Walk a recipe's slot source down to the raw category stat that ultimately
+ * lands in that slot. Returns the StatDefinition or undefined if the trace
+ * dead-ends (unknown sub-component, missing slot, etc.).
+ *
+ * Multi-source sub-slots collapse to `sources[0]`; top-level multi-source slots
+ * are expanded by the caller (`deriveStatMappings`).
+ */
+function traceToRawCategoryStat(
+    recipe: Recipe,
+    source: {inputIndex: number; statIndex: number},
+    visited: Set<number> = new Set()
+): StatDefinition | undefined {
+    const input = recipe.inputs[source.inputIndex]
+    if (!input) return undefined
+    if (isCategoryInput(input)) {
+        const defs = getStatDefinitions(input.category)
+        return defs[source.statIndex]
+    }
+    if (visited.has(input.itemId)) return undefined
+    const subRecipe = getRecipe(input.itemId)
+    if (!subRecipe) return undefined
+    const subSlot = subRecipe.statSlots[source.statIndex]
+    if (!subSlot) return undefined
+    const subSource = subSlot.sources[0]
+    if (!subSource) return undefined
+    const nextVisited = new Set(visited)
+    nextVisited.add(input.itemId)
+    return traceToRawCategoryStat(subRecipe, subSource, nextVisited)
+}
+
+let cached: StatMapping[] | undefined
+
+export function deriveStatMappings(): StatMapping[] {
+    if (cached) return cached
+    const out: StatMapping[] = []
+    const seen = new Set<string>()
+    for (const [kind, slots] of Object.entries(SLOT_FORMULAS) as [
+        SlotConsumerKind,
+        Record<number, {capability: string; attribute: string}>,
+    ][]) {
+        const itemId = KIND_TO_ITEM_ID[kind]
+        const recipe = getRecipe(itemId)
+        if (!recipe) continue
+        for (const [slotIdxStr, consumer] of Object.entries(slots)) {
+            const slotIdx = Number(slotIdxStr)
+            const slot = recipe.statSlots[slotIdx]
+            if (!slot) continue
+            for (const source of slot.sources) {
+                const stat = traceToRawCategoryStat(recipe, source)
+                if (!stat) continue
+                const key = `${stat.label}|${consumer.capability}|${consumer.attribute}`
+                if (seen.has(key)) continue
+                seen.add(key)
+                out.push({
+                    stat: stat.label,
+                    capability: consumer.capability,
+                    attribute: consumer.attribute,
+                })
+            }
+        }
+    }
+    cached = out
+    return out
+}
+
+export function getStatMappings(): StatMapping[] {
+    return deriveStatMappings()
+}
+
+export function getStatMappingsForStat(stat: string): StatMapping[] {
+    return deriveStatMappings().filter((m) => m.stat === stat)
+}
+
+export function getStatMappingsForCapability(capability: string): StatMapping[] {
+    return deriveStatMappings().filter((m) => m.capability === capability)
+}

package/src/derivation/index.ts

@@ -7,6 +7,7 @@ export {
     getEligibleResources,
     getResourceWeight,
     getLocationCandidates,
+    getLocationProfile,
     getDepthThreshold,
     getResourceTier,
     DEPTH_THRESHOLD_T1,

package/src/derivation/resources.ts

@@ -1,10 +1,16 @@
 import {getItem} from '../data/catalog'
+import {LocationType} from '../types'
 
 export const DEPTH_THRESHOLD_T1 = 0
-export const DEPTH_THRESHOLD_T2 = 2000
-export const DEPTH_THRESHOLD_T3 = 10000
-export const DEPTH_THRESHOLD_T4 = 30000
-export const DEPTH_THRESHOLD_T5 = 55000
+export const DEPTH_THRESHOLD_T2 = 1500
+export const DEPTH_THRESHOLD_T3 = 5000
+export const DEPTH_THRESHOLD_T4 = 12000
+export const DEPTH_THRESHOLD_T5 = 22000
+export const DEPTH_THRESHOLD_T6 = 32000
+export const DEPTH_THRESHOLD_T7 = 42000
+export const DEPTH_THRESHOLD_T8 = 50000
+export const DEPTH_THRESHOLD_T9 = 57000
+export const DEPTH_THRESHOLD_T10 = 63000
 
 export const LOCATION_MIN_DEPTH = 500
 export const LOCATION_MAX_DEPTH = 65535
@@ -18,19 +24,22 @@ export const PLANET_SUBTYPE_ICY = 3
 export const PLANET_SUBTYPE_OCEAN = 4
 export const PLANET_SUBTYPE_INDUSTRIAL = 5
 
+const DEPTH_THRESHOLD_TABLE = [
+    DEPTH_THRESHOLD_T1,
+    DEPTH_THRESHOLD_T2,
+    DEPTH_THRESHOLD_T3,
+    DEPTH_THRESHOLD_T4,
+    DEPTH_THRESHOLD_T5,
+    DEPTH_THRESHOLD_T6,
+    DEPTH_THRESHOLD_T7,
+    DEPTH_THRESHOLD_T8,
+    DEPTH_THRESHOLD_T9,
+    DEPTH_THRESHOLD_T10,
+]
+
 export function getDepthThreshold(tier: number): number {
-    switch (tier) {
-        case 1:
-            return DEPTH_THRESHOLD_T1
-        case 2:
-            return DEPTH_THRESHOLD_T2
-        case 3:
-            return DEPTH_THRESHOLD_T3
-        case 4:
-            return DEPTH_THRESHOLD_T4
-        default:
-            return DEPTH_THRESHOLD_T5
-    }
+    if (tier < 1 || tier > 10) return 65535
+    return DEPTH_THRESHOLD_TABLE[tier - 1]
 }
 
 export function getResourceTier(itemId: number): number {
@@ -46,9 +55,9 @@ export function getResourceWeight(itemId: number, stratum: number): number {
 
     switch (tier) {
         case 1:
-            if (stratum < 2000) return 100
-            if (stratum < 10000) return 80
-            if (stratum < 30000) return 50
+            if (stratum < DEPTH_THRESHOLD_T2) return 100
+            if (stratum < DEPTH_THRESHOLD_T3) return 80
+            if (stratum < DEPTH_THRESHOLD_T4) return 50
             return 30
         case 2:
             if (depthAbove < 3000) return 40
@@ -67,37 +76,107 @@ export function getResourceWeight(itemId: number, stratum: number): number {
     }
 }
 
-const ASTEROID_RESOURCES = [101, 102, 103, 201, 202]
-const NEBULA_RESOURCES = [202, 203, 301, 302, 303]
-const GAS_GIANT_RESOURCES = [301, 302, 303, 401, 501]
-const ROCKY_RESOURCES = [101, 102, 103, 401, 402, 403, 503]
-const TERRESTRIAL_RESOURCES = [201, 202, 401, 402, 501, 502, 503]
-const ICY_RESOURCES = [101, 301, 302, 401, 403, 501, 502]
-const OCEAN_RESOURCES = [201, 203, 301, 303, 501, 502, 503]
-const INDUSTRIAL_RESOURCES = [101, 102, 103, 201, 203, 402, 403]
+const RESOURCE_ORE = 0
+const RESOURCE_GAS = 1
+const RESOURCE_REGOLITH = 2
+const RESOURCE_BIOMASS = 3
+const RESOURCE_CRYSTAL = 4
 
-export function getLocationCandidates(locationType: number, subtype: number): number[] {
-    if (locationType === 2) return ASTEROID_RESOURCES
-    if (locationType === 3) return NEBULA_RESOURCES
-    if (locationType === 1) {
+interface LocationProfileEntry {
+    category: number
+    maxTier: number
+}
+
+function categoryBaseId(category: number): number {
+    switch (category) {
+        case RESOURCE_ORE:
+            return 100
+        case RESOURCE_CRYSTAL:
+            return 200
+        case RESOURCE_GAS:
+            return 300
+        case RESOURCE_REGOLITH:
+            return 400
+        case RESOURCE_BIOMASS:
+            return 500
+        default:
+            return 0
+    }
+}
+
+function resourceId(category: number, tier: number): number {
+    return categoryBaseId(category) + tier
+}
+
+export function getLocationProfile(locationType: number, subtype: number): LocationProfileEntry[] {
+    if (locationType === LocationType.ASTEROID) {
+        return [
+            {category: RESOURCE_ORE, maxTier: 5},
+            {category: RESOURCE_CRYSTAL, maxTier: 5},
+        ]
+    }
+    if (locationType === LocationType.NEBULA) {
+        return [
+            {category: RESOURCE_GAS, maxTier: 5},
+            {category: RESOURCE_REGOLITH, maxTier: 5},
+        ]
+    }
+    if (locationType === LocationType.ICE_FIELD) {
+        return [
+            {category: RESOURCE_GAS, maxTier: 5},
+            {category: RESOURCE_BIOMASS, maxTier: 5},
+        ]
+    }
+    if (locationType === LocationType.PLANET) {
         switch (subtype) {
             case PLANET_SUBTYPE_GAS_GIANT:
-                return GAS_GIANT_RESOURCES
+                return [
+                    {category: RESOURCE_GAS, maxTier: 10},
+                    {category: RESOURCE_CRYSTAL, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_ROCKY:
-                return ROCKY_RESOURCES
+                return [
+                    {category: RESOURCE_REGOLITH, maxTier: 10},
+                    {category: RESOURCE_ORE, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_TERRESTRIAL:
-                return TERRESTRIAL_RESOURCES
+                return [
+                    {category: RESOURCE_ORE, maxTier: 10},
+                    {category: RESOURCE_BIOMASS, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_ICY:
-                return ICY_RESOURCES
+                return [
+                    {category: RESOURCE_CRYSTAL, maxTier: 10},
+                    {category: RESOURCE_REGOLITH, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_OCEAN:
-                return OCEAN_RESOURCES
+                return [
+                    {category: RESOURCE_BIOMASS, maxTier: 10},
+                    {category: RESOURCE_GAS, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_INDUSTRIAL:
-                return INDUSTRIAL_RESOURCES
+                return [
+                    {category: RESOURCE_ORE, maxTier: 3},
+                    {category: RESOURCE_CRYSTAL, maxTier: 3},
+                    {category: RESOURCE_REGOLITH, maxTier: 3},
+                    {category: RESOURCE_BIOMASS, maxTier: 3},
+                ]
         }
     }
     return []
 }
 
+export function getLocationCandidates(locationType: number, subtype: number): number[] {
+    const profile = getLocationProfile(locationType, subtype)
+    const ids: number[] = []
+    for (const {category, maxTier} of profile) {
+        for (let tier = 1; tier <= maxTier; tier++) {
+            ids.push(resourceId(category, tier))
+        }
+    }
+    return ids
+}
+
 export function getEligibleResources(
     locationType: number,
     subtype: number,

package/src/derivation/stats.ts

@@ -25,8 +25,7 @@ const ORE_STATS: StatDefinition[] = [
         key: 'density',
         label: 'Density',
         abbreviation: 'DEN',
-        purpose: 'Mass per unit',
-        inverted: true,
+        purpose: 'Structural integrity — higher rolls produce lighter hulls',
     },
 ]
 

package/src/entities/container.ts

@@ -1,6 +1,7 @@
 import {UInt64, type UInt64Type} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
 import type {CoordinatesType} from '../types'
+import {type FloatPosition, getInterpolatedPosition} from '../travel/travel'
 import {Location} from './location'
 import {ScheduleAccessor} from '../scheduling/accessor'
 import * as schedule from '../scheduling/schedule'
@@ -24,6 +25,14 @@ export class Container extends ServerContract.Types.entity_info {
         return this.entity_name
     }
 
+    get entityClass(): 'orbital' {
+        return 'orbital'
+    }
+
+    get canUndeploy(): boolean {
+        return true
+    }
+
     get sched(): ScheduleAccessor {
         this._sched ??= new ScheduleAccessor(this)
         return this._sched
@@ -33,6 +42,12 @@ export class Container extends ServerContract.Types.entity_info {
         return this.is_idle
     }
 
+    interpolatedPositionAt(now: Date): FloatPosition {
+        const taskIndex = this.sched.currentTaskIndex(now)
+        const progress = this.sched.currentTaskProgressFloat(now)
+        return getInterpolatedPosition(this, taskIndex, progress)
+    }
+
     isLoading(now: Date): boolean {
         return schedule.isLoading(this, now)
     }
@@ -75,12 +90,12 @@ export function computeContainerCapabilities(stats: Record<string, number>): {
     hullmass: number
     capacity: number
 } {
-    const density = stats['density'] ?? 500
-    const strength = stats['strength'] ?? 500
-    const hardness = stats['hardness'] ?? 500
-    const saturation = stats['saturation'] ?? 500
+    const density = stats.density
+    const strength = stats.strength
+    const hardness = stats.hardness
+    const saturation = stats.saturation
 
-    const hullmass = 25000 + 75 * density
+    const hullmass = 100000 - 75 * density
 
     const statSum = strength + hardness + saturation
     const exponent = statSum / 2997
@@ -93,12 +108,12 @@ 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 saturation = stats['saturation'] ?? 0
+    const strength = stats.strength
+    const density = stats.density
+    const hardness = stats.hardness
+    const saturation = stats.saturation
 
-    const hullmass = 20000 + 50 * density
+    const hullmass = 70000 - 50 * density
 
     const statSum = strength + hardness + saturation
     const exponent = statSum / 2500

package/src/entities/extractor.ts

@@ -0,0 +1,144 @@
+import {UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import type {CoordinatesType} from '../types'
+import {Location} from './location'
+import {ScheduleAccessor} from '../scheduling/accessor'
+import {InventoryAccessor} from './inventory-accessor'
+import type {EntityInventory} from './entity-inventory'
+import type {PackedModuleInput} from './ship'
+import {decodeCraftedItemStats} from '../derivation/crafting'
+import {getModuleCapabilityType, MODULE_GATHERER, MODULE_GENERATOR} from '../capabilities/modules'
+import {computeGathererCapabilities, computeGeneratorCapabilities} from './ship-deploy'
+import {applySlotMultiplier, clampUint16, getSlotAmp, type InstalledModule} from './slot-multiplier'
+import type {EntitySlot} from '../data/recipes-runtime'
+import {getItem} from '../data/catalog'
+
+export interface ExtractorStateInput {
+    id: UInt64Type
+    owner: string
+    name: string
+    coordinates: CoordinatesType | {x: number; y: number; z?: number}
+    hullmass?: number
+    capacity?: number
+    energy?: number
+    modules?: PackedModuleInput[]
+    schedule?: ServerContract.Types.schedule
+    cargo?: ServerContract.Types.cargo_item[]
+}
+
+export class Extractor extends ServerContract.Types.entity_info {
+    private _sched?: ScheduleAccessor
+    private _inv?: InventoryAccessor
+
+    get name(): string {
+        return this.entity_name
+    }
+
+    get entityClass(): 'planetary' {
+        return 'planetary'
+    }
+
+    get canDemolish(): boolean {
+        return true
+    }
+
+    get inv(): InventoryAccessor {
+        this._inv ??= new InventoryAccessor(this)
+        return this._inv
+    }
+
+    get inventory(): EntityInventory[] {
+        return this.inv.items
+    }
+
+    get sched(): ScheduleAccessor {
+        this._sched ??= new ScheduleAccessor(this)
+        return this._sched
+    }
+
+    get isIdle(): boolean {
+        return this.is_idle
+    }
+
+    get location(): Location {
+        return Location.from(this.coordinates)
+    }
+
+    get totalCargoMass(): UInt64 {
+        return this.inv.totalMass
+    }
+
+    get maxCapacity(): UInt64 {
+        return UInt64.from(this.capacity)
+    }
+
+    get availableCapacity(): UInt64 {
+        const cargo = this.totalCargoMass
+        return cargo.gte(this.maxCapacity) ? UInt64.from(0) : this.maxCapacity.subtracting(cargo)
+    }
+
+    get isFull(): boolean {
+        return this.totalCargoMass.gte(this.maxCapacity)
+    }
+
+    get totalMass(): UInt64 {
+        const hull = this.hullmass ? UInt64.from(this.hullmass) : UInt64.from(0)
+        return hull.adding(this.totalCargoMass)
+    }
+}
+
+export interface ExtractorCapabilities {
+    generator?: {capacity: number; recharge: number}
+    gatherer?: {yield: number; drain: number; depth: number; speed: number}
+}
+
+export function computeExtractorCapabilities(
+    modules: InstalledModule[],
+    layout: EntitySlot[]
+): ExtractorCapabilities {
+    const out: ExtractorCapabilities = {}
+
+    const genModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_GENERATOR)
+    if (genModules.length > 0) {
+        let totalCapacity = 0
+        let totalRecharge = 0
+        for (const m of genModules) {
+            const caps = computeGeneratorCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
+            const amp = getSlotAmp(layout, m.slotIndex)
+            totalCapacity += applySlotMultiplier(caps.capacity, amp)
+            totalRecharge += applySlotMultiplier(caps.recharge, amp)
+        }
+        out.generator = {
+            capacity: clampUint16(totalCapacity),
+            recharge: clampUint16(totalRecharge),
+        }
+    }
+
+    const gathModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_GATHERER)
+    if (gathModules.length > 0) {
+        let totalYield = 0
+        let totalDrain = 0
+        let maxDepth = 0
+        let totalSpeed = 0
+        for (const m of gathModules) {
+            const tier = getItem(m.itemId).tier
+            const caps = computeGathererCapabilities(
+                decodeCraftedItemStats(m.itemId, m.stats),
+                tier
+            )
+            const amp = getSlotAmp(layout, m.slotIndex)
+            totalYield += applySlotMultiplier(caps.yield, amp)
+            totalDrain += caps.drain
+            if (caps.depth > maxDepth) maxDepth = caps.depth
+            totalSpeed += applySlotMultiplier(caps.speed, amp)
+        }
+        out.gatherer = {
+            yield: clampUint16(totalYield),
+            drain: totalDrain,
+            depth: maxDepth,
+            speed: clampUint16(totalSpeed),
+        }
+    }
+
+    return out
+}

package/src/entities/factory.ts

@@ -0,0 +1,135 @@
+import {UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import type {CoordinatesType} from '../types'
+import {Location} from './location'
+import {ScheduleAccessor} from '../scheduling/accessor'
+import {InventoryAccessor} from './inventory-accessor'
+import type {EntityInventory} from './entity-inventory'
+import type {PackedModuleInput} from './ship'
+import {decodeCraftedItemStats} from '../derivation/crafting'
+import {getModuleCapabilityType, MODULE_CRAFTER, MODULE_GENERATOR} from '../capabilities/modules'
+import {computeCrafterCapabilities, computeGeneratorCapabilities} from './ship-deploy'
+import {applySlotMultiplier, clampUint16, getSlotAmp, type InstalledModule} from './slot-multiplier'
+import type {EntitySlot} from '../data/recipes-runtime'
+
+export interface FactoryStateInput {
+    id: UInt64Type
+    owner: string
+    name: string
+    coordinates: CoordinatesType | {x: number; y: number; z?: number}
+    hullmass?: number
+    capacity?: number
+    energy?: number
+    modules?: PackedModuleInput[]
+    schedule?: ServerContract.Types.schedule
+    cargo?: ServerContract.Types.cargo_item[]
+}
+
+export class Factory extends ServerContract.Types.entity_info {
+    private _sched?: ScheduleAccessor
+    private _inv?: InventoryAccessor
+
+    get name(): string {
+        return this.entity_name
+    }
+
+    get entityClass(): 'planetary' {
+        return 'planetary'
+    }
+
+    get canDemolish(): boolean {
+        return true
+    }
+
+    get inv(): InventoryAccessor {
+        this._inv ??= new InventoryAccessor(this)
+        return this._inv
+    }
+
+    get inventory(): EntityInventory[] {
+        return this.inv.items
+    }
+
+    get sched(): ScheduleAccessor {
+        this._sched ??= new ScheduleAccessor(this)
+        return this._sched
+    }
+
+    get isIdle(): boolean {
+        return this.is_idle
+    }
+
+    get location(): Location {
+        return Location.from(this.coordinates)
+    }
+
+    get totalCargoMass(): UInt64 {
+        return this.inv.totalMass
+    }
+
+    get maxCapacity(): UInt64 {
+        return UInt64.from(this.capacity)
+    }
+
+    get availableCapacity(): UInt64 {
+        const cargo = this.totalCargoMass
+        return cargo.gte(this.maxCapacity) ? UInt64.from(0) : this.maxCapacity.subtracting(cargo)
+    }
+
+    get isFull(): boolean {
+        return this.totalCargoMass.gte(this.maxCapacity)
+    }
+
+    get totalMass(): UInt64 {
+        const hull = this.hullmass ? UInt64.from(this.hullmass) : UInt64.from(0)
+        return hull.adding(this.totalCargoMass)
+    }
+}
+
+export interface FactoryCapabilities {
+    generator?: {capacity: number; recharge: number}
+    crafter?: {speed: number; drain: number}
+}
+
+export function computeFactoryCapabilities(
+    modules: InstalledModule[],
+    layout: EntitySlot[]
+): FactoryCapabilities {
+    const out: FactoryCapabilities = {}
+
+    const genModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_GENERATOR)
+    if (genModules.length > 0) {
+        let totalCapacity = 0
+        let totalRecharge = 0
+        for (const m of genModules) {
+            const caps = computeGeneratorCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
+            const amp = getSlotAmp(layout, m.slotIndex)
+            totalCapacity += applySlotMultiplier(caps.capacity, amp)
+            totalRecharge += applySlotMultiplier(caps.recharge, amp)
+        }
+        out.generator = {
+            capacity: clampUint16(totalCapacity),
+            recharge: clampUint16(totalRecharge),
+        }
+    }
+
+    const crafterModules = modules.filter(
+        (m) => getModuleCapabilityType(m.itemId) === MODULE_CRAFTER
+    )
+    if (crafterModules.length > 0) {
+        let totalSpeed = 0
+        let totalDrain = 0
+        for (const m of crafterModules) {
+            const caps = computeCrafterCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
+            const amp = getSlotAmp(layout, m.slotIndex)
+            totalSpeed += applySlotMultiplier(caps.speed, amp)
+            totalDrain += caps.drain
+        }
+        out.crafter = {
+            speed: clampUint16(totalSpeed),
+            drain: totalDrain,
+        }
+    }
+
+    return out
+}