@shipload/sdk 1.0.0-next.51 → 1.0.0-next.52

package/src/derivation/capabilities.test.ts

@@ -1,7 +1,9 @@
 import {expect, test} from 'bun:test'
 import {
     computeEntityCapabilities,
+    computeEngineCapabilities,
     computeGathererCapabilities,
+    computeGeneratorCapabilities,
     computeCrafterCapabilities,
     computeLoaderCapabilities,
     computeBaseCapacity,
@@ -17,12 +19,25 @@ import {
     ITEM_GATHERER_T1,
     ITEM_CRAFTER_T1,
     ITEM_LOADER_T1,
+    ITEM_SHIP_T1_PACKED,
+    ITEM_ROUSTABOUT_T1_PACKED,
+    ITEM_PROSPECTOR_T1_PACKED,
+    ITEM_TENDER_T1_PACKED,
+    ITEM_TUG_T1_PACKED,
+    ITEM_PORTER_T1_PACKED,
+    ITEM_WRANGLER_T1_PACKED,
+    ITEM_DREDGER_T1_PACKED,
+    ITEM_WRIGHT_T1_PACKED,
+    ITEM_ENGINE_T1,
+    ITEM_GENERATOR_T1,
 } from '../data/item-ids'
 import type {InstalledModule} from '../entities/slot-multiplier'
 import type {EntitySlot} from '../data/recipes-runtime'
+import {computeTravelDrain} from '../nft/description'
+import {computeEffectiveModuleStat} from './stat-scaling'
 
-function makeGathererStats(strength: number, hardness: number, saturation: number): bigint {
-    return encodeStats([strength, hardness, saturation, 0])
+function makeGathererStats(strength: number, tolerance: number, saturation: number): bigint {
+    return encodeStats([strength, tolerance, saturation, 0])
 }
 
 function makeCrafterStats(fineness: number, conductivity: number): bigint {
@@ -46,6 +61,24 @@ test('computeBaseCapacity uses container formula for all container-class entitie
     }
 })
 
+test('computeBaseCapacity uses ship-hull formula for every ship-class entity', () => {
+    const stats = {strength: 300, hardness: 400, density: 100}
+    const expected = computeBaseCapacity(ITEM_SHIP_T1_PACKED, stats)
+    expect(expected).toBeGreaterThan(0)
+    for (const itemId of [
+        ITEM_ROUSTABOUT_T1_PACKED,
+        ITEM_PROSPECTOR_T1_PACKED,
+        ITEM_TENDER_T1_PACKED,
+        ITEM_TUG_T1_PACKED,
+        ITEM_PORTER_T1_PACKED,
+        ITEM_WRANGLER_T1_PACKED,
+        ITEM_DREDGER_T1_PACKED,
+        ITEM_WRIGHT_T1_PACKED,
+    ]) {
+        expect(computeBaseCapacity(itemId, stats)).toBe(expected)
+    }
+})
+
 test('computeEntityCapabilities emits gathererLanes alongside legacy gatherer sum', () => {
     // Two gatherers with distinct stats in separate slots, amp=100 for both
     const gathStats1 = makeGathererStats(300, 200, 400)
@@ -72,8 +105,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, hardness: 200, saturation: 400}, 1)
-    const caps2 = computeGathererCapabilities({strength: 500, hardness: 100, saturation: 300}, 1)
+    const caps1 = computeGathererCapabilities({strength: 300, tolerance: 200, saturation: 400}, 1)
+    const caps2 = computeGathererCapabilities({strength: 500, tolerance: 100, saturation: 300}, 1)
     const expectedYield1 = applySlotMultiplier(caps1.yield, 100)
     const expectedYield2 = applySlotMultiplier(caps2.yield, 100)
     expect(result.gathererLanes![0].yield).toBe(expectedYield1)
@@ -149,3 +182,47 @@ test('per-lane amp-scaled stats clamp to UInt16, matching the contract clamp_to_
     expect(applySlotMultiplier(60000, 200)).toBe(U16_MAX)
     expect(applySlotMultiplier(1000, 150)).toBe(1500)
 })
+
+test('generator capacity and recharge are denominated to milli-energy', () => {
+    const caps = computeGeneratorCapabilities({resonance: 213, reflectivity: 213})
+    expect(caps.capacity).toBe(1_406_500)
+    expect(caps.recharge).toBe(3_278)
+})
+
+test('engine and generator capabilities use tapered quality consistently', () => {
+    const modules: InstalledModule[] = [
+        {slotIndex: 0, itemId: ITEM_ENGINE_T1, stats: encodeStats([500, 500])},
+        {slotIndex: 1, itemId: ITEM_GENERATOR_T1, stats: encodeStats([500, 500])},
+    ]
+    const layout: EntitySlot[] = [
+        {type: 'engine', outputPct: 100, maxTier: 1},
+        {type: 'generator', outputPct: 100, maxTier: 1},
+    ]
+
+    const result = computeEntityCapabilities({}, ITEM_ROUSTABOUT_T1_PACKED, modules, layout)
+    const engines = computeEngineCapabilities({volatility: 500, thermal: 500})
+
+    expect(result.engines).toEqual({
+        thrust: engines.thrust,
+        drain: computeTravelDrain(engines.thrust, computeEffectiveModuleStat(500)),
+    })
+    expect(result.generator).toEqual(
+        computeGeneratorCapabilities({resonance: 500, reflectivity: 500})
+    )
+})
+
+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)
+})
+
+test('gatherer depth accepts canonical tolerance and legacy recipe-labelled hardness', () => {
+    expect(computeGathererCapabilities({strength: 0, tolerance: 213, saturation: 0}, 2).depth).toBe(
+        4_343
+    )
+    expect(computeGathererCapabilities({strength: 0, hardness: 213, saturation: 0}, 1).depth).toBe(
+        1_565
+    )
+})

package/src/derivation/capabilities.ts

@@ -1,15 +1,40 @@
-export function computeBaseHullmass(stats: Record<string, number>): number {
-    return 100000 - 75 * stats.density
+import {getEntityLayout} from '../data/recipes-runtime'
+import {ENTITY_SHIP, getPackedEntityType} from '../data/kind-registry'
+import {computeEffectiveModuleStat} from './stat-scaling'
+
+export const DEFAULT_BASE_HULLMASS = 100_000
+
+export function getBaseHullmassFor(itemId: number): number {
+    return getEntityLayout(itemId)?.baseHullmass ?? DEFAULT_BASE_HULLMASS
+}
+
+function isShipHull(itemId: number): boolean {
+    return getPackedEntityType(itemId)?.equals(ENTITY_SHIP) ?? false
 }
 
-export function computeShipHullCapabilities(stats: Record<string, number>): {
+function sumHullStats(stats: Record<string, number>): number {
+    return Object.values(stats).reduce((sum, value) => sum + value, 0)
+}
+
+export function computeBaseHullmass(itemId: number, stats: Record<string, number>): number {
+    if (isShipHull(itemId)) {
+        return Math.floor((getBaseHullmassFor(itemId) * (10_000 - sumHullStats(stats))) / 10_000)
+    }
+    const lightness = stats.density ?? stats.hardness ?? 0
+    return Math.floor((getBaseHullmassFor(itemId) * (2000 - lightness)) / 2000)
+}
+
+export function computeShipHullCapabilities(
+    stats: Record<string, number>,
+    itemId: number = ITEM_SHIP_T1_PACKED
+): {
     hullmass: number
     capacity: number
 } {
-    const statSum = (stats.strength ?? 0) + (stats.hardness ?? 0)
-    const exponent = statSum / 1998.0
+    const statSum = sumHullStats(stats)
+    const exponent = statSum / 4995.0
     return {
-        hullmass: computeBaseHullmass(stats),
+        hullmass: computeBaseHullmass(itemId, stats),
         capacity: Math.floor(5000000 * 6 ** exponent),
     }
 }
@@ -18,8 +43,8 @@ export function computeEngineCapabilities(stats: Record<string, number>): {
     thrust: number
     drain: number
 } {
-    const vol = stats.volatility
-    const thm = stats.thermal
+    const vol = computeEffectiveModuleStat(stats.volatility)
+    const thm = computeEffectiveModuleStat(stats.thermal)
 
     return {
         thrust: 400 + Math.floor((vol * 3) / 4),
@@ -31,12 +56,12 @@ export function computeGeneratorCapabilities(stats: Record<string, number>): {
     capacity: number
     recharge: number
 } {
-    const res = stats.resonance
-    const ref = stats.reflectivity
+    const res = computeEffectiveModuleStat(stats.resonance)
+    const ref = computeEffectiveModuleStat(stats.reflectivity)
 
     return {
-        capacity: 1300 + Math.floor(res / 2),
-        recharge: 2 * (1 + Math.floor((ref * 3) / 1000)),
+        capacity: 1_300_000 + res * 500,
+        recharge: 2000 + ref * 6,
     }
 }
 
@@ -78,12 +103,15 @@ export function computeGathererCapabilities(
 } {
     const str = stats.strength
     const con = stats.saturation
-    const hrd = stats.hardness
+    // Gatherer capabilities are positional in the contract: packed slot 1 is tolerance.
+    // T1 recipe presentation historically labels that blended slot as hardness, so retain
+    // that fallback for callers that only have recipe-decoded named stats.
+    const tol = stats.tolerance ?? stats.hardness
 
     return {
         yield: 200 + str,
-        drain: 2 * Math.max(250, 1250 - Math.floor((con * 25) / 20)),
-        depth: gathererDepthForTier(hrd, tier),
+        drain: 2 * Math.max(250_000, 1_250_000 - con * 1250),
+        depth: gathererDepthForTier(tol, tier),
     }
 }
 
@@ -111,7 +139,20 @@ export function computeCrafterCapabilities(stats: Record<string, number>): {
 
     return {
         speed: 100 + Math.floor((fin * 4) / 5),
-        drain: Math.max(5, 30 - Math.floor(con / 33)),
+        drain: Math.max(5000, 30000 - Math.floor((con * 1000) / 33)),
+    }
+}
+
+export function computeBuilderCapabilities(stats: Record<string, number>): {
+    speed: number
+    drain: number
+} {
+    const coh = stats.cohesion
+    const tol = stats.tolerance
+
+    return {
+        speed: 100 + Math.floor((coh * 4) / 5),
+        drain: Math.max(5000, 30000 - Math.floor((tol * 1000) / 33)),
     }
 }
 
@@ -130,7 +171,7 @@ export function computeHaulerCapabilities(
     return {
         capacity: computeHaulerCapacity(resonance, tier),
         efficiency: 2000 + plasticity * 6,
-        drain: Math.max(3, 15 - Math.floor(conductivity / 80)),
+        drain: computeHaulerDrain(conductivity, tier),
     }
 }
 
@@ -145,16 +186,21 @@ export function computeLauncherCapabilities(
     }
 }
 
-export function computeStorageCapabilities(stats: Record<string, number>): {
+export function computeStorageCapabilities(
+    stats: Record<string, number>,
+    tier: number
+): {
     capacity: number
+    drain: number
 } {
-    const strength = stats.strength ?? 0
-    const density = stats.density ?? 0
-    const hardness = stats.hardness ?? 0
-    const cohesion = stats.cohesion ?? 0
-
-    const statSum = strength + density + hardness + cohesion
-    return {capacity: 10_000_000 + Math.floor((statSum * 50_000_000) / 3996)}
+    return {
+        capacity: computeCargoBayCapacity(
+            stats.strength ?? 0,
+            stats.density ?? 0,
+            stats.hardness ?? 0
+        ),
+        drain: computeCargoBayDrain(stats.cohesion ?? 0, tier),
+    }
 }
 
 export function computeBatteryCapabilities(stats: Record<string, number>): {
@@ -166,7 +212,7 @@ export function computeBatteryCapabilities(stats: Record<string, number>): {
     const insulation = stats.insulation ?? 0
 
     const statSum = volatility + thermal + plasticity + insulation
-    return {capacity: 2_500 + Math.floor((statSum * 7_500) / 3996)}
+    return {capacity: 2_500_000 + Math.floor((statSum * 7_500_000) / 3996)}
 }
 
 import {
@@ -174,10 +220,8 @@ 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'
@@ -190,6 +234,7 @@ import {
     MODULE_LOADER,
     MODULE_STORAGE,
     MODULE_CRAFTER,
+    MODULE_BUILDER,
     MODULE_HAULER,
     MODULE_WARP,
     MODULE_LAUNCHER,
@@ -205,7 +250,13 @@ import {
     type InstalledModule,
 } from '../entities/slot-multiplier'
 import type {EntitySlot} from '../data/recipes-runtime'
-import {computeHaulerCapacity, computeTravelDrain} from '../nft/description'
+import {
+    computeCargoBayCapacity,
+    computeCargoBayDrain,
+    computeHaulerCapacity,
+    computeHaulerDrain,
+    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]
 
@@ -220,25 +271,24 @@ export function applyCapacityTier(baseCapacity: number, tier: number): number {
 
 export function computeBaseCapacity(itemId: number, stats: Record<string, number>): number {
     let base: number
-    switch (itemId) {
-        case ITEM_SHIP_T1_PACKED:
-        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:
-        case ITEM_CONTAINER_T2_PACKED:
-            base = computeContainerCapabilities(stats).capacity
-            break
-        case ITEM_WAREHOUSE_T1_PACKED:
-            base = computeWarehouseHullCapabilities(stats).capacity
-            break
-        default:
-            return 0
+    if (isShipHull(itemId)) {
+        base = computeShipHullCapabilities(stats, itemId).capacity
+    } else {
+        switch (itemId) {
+            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:
+            case ITEM_CONTAINER_T2_PACKED:
+                base = computeContainerCapabilities(stats).capacity
+                break
+            case ITEM_WAREHOUSE_T1_PACKED:
+                base = computeWarehouseHullCapabilities(stats).capacity
+                break
+            default:
+                return 0
+        }
     }
     return applyCapacityTier(base, getItem(itemId).tier)
 }
@@ -257,7 +307,7 @@ export function computeWarehouseHullCapabilities(stats: Record<string, number>):
     const statSum = (stats.strength ?? 0) + (stats.hardness ?? 0)
     const exponent = statSum / 1998.0
     return {
-        hullmass: computeBaseHullmass(stats),
+        hullmass: computeBaseHullmass(ITEM_WAREHOUSE_T1_PACKED, stats),
         capacity: Math.floor(100000000 * 6 ** exponent),
     }
 }
@@ -277,6 +327,13 @@ export interface CrafterLaneEntry {
     outputPct: number
 }
 
+export interface BuilderLaneEntry {
+    slotIndex: number
+    speed: number
+    drain: number
+    outputPct: number
+}
+
 export interface LoaderLaneEntry {
     slotIndex: number
     mass: number
@@ -284,10 +341,18 @@ export interface LoaderLaneEntry {
     outputPct: number
 }
 
+export interface TravelDrainBreakdown {
+    engine: number
+    cargoHolds: number
+    tractorBeams: number
+    total: number
+}
+
 export interface ComputedCapabilities {
     hullmass: number
     capacity: number
     engines?: {thrust: number; drain: number}
+    travelDrain?: TravelDrainBreakdown
     generator?: {capacity: number; recharge: number}
     gatherer?: {yield: number; drain: number; depth: number}
     gathererLanes?: GathererLaneEntry[]
@@ -295,6 +360,8 @@ export interface ComputedCapabilities {
     loaderLanes?: LoaderLaneEntry[]
     crafter?: {speed: number; drain: number}
     crafterLanes?: CrafterLaneEntry[]
+    builder?: {speed: number; drain: number}
+    builderLanes?: BuilderLaneEntry[]
     hauler?: {
         capacity: number
         efficiency: number
@@ -331,6 +398,7 @@ export function computeEntityCapabilities(
     let hasGatherer = false
 
     let totalStorageCapacity = 0
+    let totalCargoHoldDrain = 0
     const baseCapacity = computeBaseCapacity(itemId, stats)
     let installedModuleMass = 0
 
@@ -338,6 +406,10 @@ export function computeEntityCapabilities(
     let totalCrafterDrain = 0
     let hasCrafter = false
 
+    let totalBuilderSpeed = 0
+    let totalBuilderDrain = 0
+    let hasBuilder = false
+
     let totalHaulerCapacity = 0
     let weightedHaulerEffNum = 0n
     let totalHaulerDrain = 0
@@ -356,6 +428,7 @@ export function computeEntityCapabilities(
 
     const gathererLanes: GathererLaneEntry[] = []
     const crafterLanes: CrafterLaneEntry[] = []
+    const builderLanes: BuilderLaneEntry[] = []
     const loaderLanes: LoaderLaneEntry[] = []
 
     for (const mod of modules) {
@@ -369,17 +442,24 @@ export function computeEntityCapabilities(
             hasEngine = true
             const caps = computeEngineCapabilities(decodedStats)
             totalThrust += applySlotMultiplier(caps.thrust, amp)
-            totalEngineThm += decodedStats.thermal ?? 0
+            totalEngineThm += computeEffectiveModuleStat(decodedStats.thermal ?? 0)
             engineCount += 1
         } else if (modType === MODULE_GENERATOR) {
             hasGenerator = true
             const caps = computeGeneratorCapabilities(decodedStats)
-            totalGenCapacity += applySlotMultiplier(caps.capacity, amp)
-            totalGenRecharge += applySlotMultiplier(caps.recharge, amp)
+            totalGenCapacity += applySlotMultiplierUint32(caps.capacity, amp)
+            totalGenRecharge += applySlotMultiplierUint32(caps.recharge, amp)
         } else if (modType === MODULE_GATHERER) {
             hasGatherer = true
             const tier = item.tier
-            const caps = computeGathererCapabilities(decodedStats, tier)
+            const caps = computeGathererCapabilities(
+                {
+                    strength: decodeStat(mod.stats, 0),
+                    tolerance: decodeStat(mod.stats, 1),
+                    saturation: decodeStat(mod.stats, 2),
+                },
+                tier
+            )
             const scaledYield = applySlotMultiplier(caps.yield, amp)
             totalGathYield += scaledYield
             totalGathDrain += caps.drain
@@ -404,8 +484,9 @@ export function computeEntityCapabilities(
                 outputPct: amp,
             })
         } else if (modType === MODULE_STORAGE) {
-            const caps = computeStorageCapabilities(decodedStats)
+            const caps = computeStorageCapabilities(decodedStats, item.tier)
             totalStorageCapacity += applySlotMultiplierUint32(caps.capacity, amp)
+            totalCargoHoldDrain += caps.drain
         } else if (modType === MODULE_CRAFTER) {
             hasCrafter = true
             const caps = computeCrafterCapabilities(decodedStats)
@@ -418,6 +499,18 @@ export function computeEntityCapabilities(
                 drain: caps.drain,
                 outputPct: amp,
             })
+        } else if (modType === MODULE_BUILDER) {
+            hasBuilder = true
+            const caps = computeBuilderCapabilities(decodedStats)
+            const scaledSpeed = applySlotMultiplier(caps.speed, amp)
+            totalBuilderSpeed += scaledSpeed
+            totalBuilderDrain += caps.drain
+            builderLanes.push({
+                slotIndex: mod.slotIndex,
+                speed: scaledSpeed,
+                drain: caps.drain,
+                outputPct: amp,
+            })
         } else if (modType === MODULE_HAULER) {
             hasHauler = true
             const caps = computeHaulerCapabilities(decodedStats, item.tier)
@@ -454,13 +547,21 @@ export function computeEntityCapabilities(
     }
 
     const result: ComputedCapabilities = {
-        hullmass: computeBaseHullmass(stats) + installedModuleMass,
+        hullmass: computeBaseHullmass(itemId, stats) + installedModuleMass,
         capacity: clampUint32(baseCapacity + totalStorageCapacity),
     }
 
     if (hasEngine) {
         const avgThm = engineCount > 0 ? Math.trunc(totalEngineThm / engineCount) : 0
-        result.engines = {thrust: totalThrust, drain: computeTravelDrain(totalThrust, avgThm)}
+        const engineDrain = computeTravelDrain(totalThrust, avgThm)
+        const totalDrain = clampUint32(engineDrain + totalCargoHoldDrain + totalHaulerDrain)
+        result.engines = {thrust: totalThrust, drain: totalDrain}
+        result.travelDrain = {
+            engine: engineDrain,
+            cargoHolds: totalCargoHoldDrain,
+            tractorBeams: totalHaulerDrain,
+            total: totalDrain,
+        }
     }
     if (hasGenerator) {
         result.generator = {
@@ -488,6 +589,10 @@ export function computeEntityCapabilities(
         result.crafter = {speed: clampUint16(totalCrafterSpeed), drain: totalCrafterDrain}
         result.crafterLanes = crafterLanes
     }
+    if (hasBuilder) {
+        result.builder = {speed: clampUint16(totalBuilderSpeed), drain: totalBuilderDrain}
+        result.builderLanes = builderLanes
+    }
     if (hasHauler) {
         const efficiency =
             totalHaulerCapacity > 0 ? Number(weightedHaulerEffNum / BigInt(totalHaulerCapacity)) : 0
@@ -521,7 +626,7 @@ export function computeContainerCapabilities(stats: Record<string, number>): {
     const statSum = (stats.strength ?? 0) + (stats.hardness ?? 0)
     const exponent = statSum / 1998.0
     return {
-        hullmass: computeBaseHullmass(stats),
+        hullmass: computeBaseHullmass(ITEM_CONTAINER_T1_PACKED, stats),
         capacity: Math.floor(22000000 * 6 ** exponent),
     }
 }

package/src/derivation/crafting.ts

@@ -4,6 +4,7 @@ import {getRecipe, type Recipe} from '../data/recipes-runtime'
 import {getItem} from '../data/catalog'
 import {getStatDefinitions} from './stats'
 import {deriveResourceStats} from './stratum'
+import {ITEM_SHIP_T1_PACKED} from '../data/item-ids'
 
 export interface StackInput {
     quantity: number
@@ -41,6 +42,7 @@ function getItemStatKeys(itemId: number): string[] {
         if (!item.category) return []
         return getStatDefinitions(item.category).map((d) => d.key)
     }
+    if (itemId === ITEM_SHIP_T1_PACKED) return ['strength', 'density', '', '']
     const recipe = getRecipe(itemId)
     if (!recipe) return []
     return recipe.statSlots.map((slot) => keyForStatSlot(recipe, slot))

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

@@ -7,7 +7,6 @@ import {
 } from './recipe-usage'
 import {
     ITEM_SENSOR,
-    ITEM_SENSOR_T2,
     ITEM_RESIN,
     ITEM_FRAME,
     ITEM_PLATE,
@@ -15,7 +14,13 @@ import {
     ITEM_GATHERER_T1,
     ITEM_CRAFTER_T1,
     ITEM_EXTRACTOR_T1_PACKED,
-    ITEM_SHIP_T1_PACKED,
+    ITEM_ROUSTABOUT_T1_PACKED,
+    ITEM_PROSPECTOR_T1_PACKED,
+    ITEM_TENDER_T1_PACKED,
+    ITEM_TUG_T1_PACKED,
+    ITEM_PORTER_T1_PACKED,
+    ITEM_WRANGLER_T1_PACKED,
+    ITEM_DREDGER_T1_PACKED,
 } from '../data/item-ids'
 
 test('getAllRecipes returns the full catalog including the gatherer', () => {
@@ -28,9 +33,7 @@ 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, ITEM_SENSOR_T2].sort(
-            (a, b) => a - b
-        )
+        [ITEM_CRAFTER_T1, ITEM_EXTRACTOR_T1_PACKED, ITEM_ROUSTABOUT_T1_PACKED].sort((a, b) => a - b)
     )
 })
 
@@ -73,9 +76,9 @@ test('getResourceDemand scales by quantity', () => {
     expect(getResourceDemand(ITEM_PLATE, 3)).toEqual({ore: 30})
 })
 
-test('getComponentDemand reports Resin as consumed by three recipes', () => {
+test('getComponentDemand reports Resin as consumed by nine recipes', () => {
     const demand = getComponentDemand()
     const resin = demand.find((d) => d.itemId === ITEM_RESIN)
     expect(resin).toBeDefined()
-    expect(resin?.consumerCount).toBe(3)
+    expect(resin?.consumerCount).toBe(9)
 })

package/src/derivation/rollups.ts

@@ -37,6 +37,22 @@ export function rollupCrafter(
     }
 }
 
+export function rollupBuilder(
+    lanes: ServerContract.Types.builder_lane[]
+): {speed: UInt16; drain: UInt32} | undefined {
+    if (lanes.length === 0) return undefined
+    let totalSpeed = 0
+    let totalDrain = 0
+    for (const l of lanes) {
+        totalSpeed += Number(l.speed)
+        totalDrain += Number(l.drain)
+    }
+    return {
+        speed: UInt16.from(Math.min(totalSpeed, 65535)),
+        drain: UInt32.from(totalDrain),
+    }
+}
+
 export function rollupLoaders(
     lanes: ServerContract.Types.loader_lane[]
 ): {mass: UInt32; thrust: UInt16; quantity: UInt8} | undefined {

package/src/derivation/stat-scaling.ts

@@ -0,0 +1,12 @@
+export const MODULE_STAT_SCALING_ANCHOR = 213
+export const MODULE_STAT_SCALING_POST_ANCHOR_PERCENT = 40
+
+export function computeEffectiveModuleStat(stat: number): number {
+    if (stat <= MODULE_STAT_SCALING_ANCHOR) return stat
+    return (
+        MODULE_STAT_SCALING_ANCHOR +
+        Math.floor(
+            ((stat - MODULE_STAT_SCALING_ANCHOR) * MODULE_STAT_SCALING_POST_ANCHOR_PERCENT) / 100
+        )
+    )
+}

package/src/entities/makers.ts

@@ -112,7 +112,7 @@ export function makeEntity(packedItemId: number, state: EntityStateInput): Entit
         holds: [],
     }
 
-    if (state.energy !== undefined) info.energy = UInt16.from(state.energy)
+    if (state.energy !== undefined) info.energy = UInt32.from(state.energy)
 
     if (kind === 'container') {
         info.modules = []
@@ -174,6 +174,14 @@ export function makeEntity(packedItemId: number, state: EntityStateInput): Entit
                 output_pct: l.outputPct,
             })
         )
+        info.builder_lanes = (caps.builderLanes ?? []).map((l) =>
+            ServerContract.Types.builder_lane.from({
+                slot_index: l.slotIndex,
+                speed: l.speed,
+                drain: l.drain,
+                output_pct: l.outputPct,
+            })
+        )
         info.loader_lanes = (caps.loaderLanes ?? []).map((l) =>
             ServerContract.Types.loader_lane.from({
                 slot_index: l.slotIndex,
@@ -186,6 +194,7 @@ export function makeEntity(packedItemId: number, state: EntityStateInput): Entit
 
     if (!info.gatherer_lanes) info.gatherer_lanes = []
     if (!info.crafter_lanes) info.crafter_lanes = []
+    if (!info.builder_lanes) info.builder_lanes = []
     if (!info.loader_lanes) info.loader_lanes = []
 
     const entityInfo = ServerContract.Types.entity_info.from(info)