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

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@shipload/sdk",
     "description": "SDKs for Shipload",
-    "version": "1.0.0-next.52",
+    "version": "1.0.0-next.53",
     "homepage": "https://github.com/shipload/toolkit/tree/master/packages/sdk",
     "repository": {
         "type": "git",

package/src/data/capabilities.ts

@@ -27,6 +27,7 @@ export const capabilityNames: string[] = [
     'Gathering',
     'Warp',
     'Crafting',
+    'Build',
     'Launch',
     'Hauling',
 ]
@@ -73,6 +74,12 @@ export const capabilityAttributes: CapabilityAttribute[] = [
         description: 'Energy consumed per second while crafting',
     },
     {capability: 'Crafting', attribute: 'quality', description: 'Modifier on output quality'},
+    {capability: 'Build', attribute: 'speed', description: 'Build progress per second'},
+    {
+        capability: 'Build',
+        attribute: 'drain',
+        description: 'Energy consumed per second while building',
+    },
     {capability: 'Launch', attribute: 'range', description: 'Maximum launch distance'},
     {capability: 'Launch', attribute: 'capacity', description: 'Maximum mass per launch'},
     {capability: 'Launch', attribute: 'drain', description: 'Energy consumed per launch'},

package/src/data/capability-formulas.ts

@@ -9,6 +9,7 @@ export type SlotConsumerKind =
     | 'gatherer'
     | 'loader'
     | 'crafter'
+    | 'builder'
     | 'storage'
     | 'hauler'
     | 'warp'
@@ -47,6 +48,10 @@ export const SLOT_FORMULAS: Record<SlotConsumerKind, Record<number, SlotConsumer
         0: {capability: 'Crafting', attribute: 'speed'},
         1: {capability: 'Crafting', attribute: 'drain'},
     },
+    builder: {
+        0: {capability: 'Build', attribute: 'speed'},
+        1: {capability: 'Build', attribute: 'drain'},
+    },
     storage: {
         0: {capability: 'Storage', attribute: 'capacity'},
         1: {capability: 'Storage', attribute: 'capacity'},

package/src/data/recipes.json

@@ -777,33 +777,40 @@
     "outputMass": 960000,
     "inputs": [
       {
-        "itemId": 10005,
+        "itemId": 10006,
         "quantity": 300
       },
       {
-        "itemId": 10002,
+        "itemId": 10008,
         "quantity": 300
       }
     ],
     "statSlots": [
       {
         "sources": [
+          {
+            "inputIndex": 0,
+            "statIndex": 2
+          },
           {
             "inputIndex": 1,
-            "statIndex": 1
+            "statIndex": 0
           }
         ]
       },
       {
         "sources": [
           {
-            "inputIndex": 0,
+            "inputIndex": 1,
             "statIndex": 1
           }
         ]
       }
     ],
-    "blendWeights": []
+    "blendWeights": [
+      1,
+      1
+    ]
   },
   {
     "outputItemId": 10200,

package/src/derivation/capabilities.test.ts

@@ -5,6 +5,7 @@ import {
     computeGathererCapabilities,
     computeGeneratorCapabilities,
     computeCrafterCapabilities,
+    computeBuilderCapabilities,
     computeLoaderCapabilities,
     computeBaseCapacity,
     computeContainerCapabilities,
@@ -30,6 +31,7 @@ import {
     ITEM_WRIGHT_T1_PACKED,
     ITEM_ENGINE_T1,
     ITEM_GENERATOR_T1,
+    ITEM_BUILDER_T1,
 } from '../data/item-ids'
 import type {InstalledModule} from '../entities/slot-multiplier'
 import type {EntitySlot} from '../data/recipes-runtime'
@@ -48,6 +50,10 @@ function makeLoaderStats(insulation: number, plasticity: number): bigint {
     return encodeStats([insulation, plasticity])
 }
 
+function makeBuilderStats(resonance: number, fineness: number): bigint {
+    return encodeStats([resonance, fineness])
+}
+
 test('computeBaseCapacity uses container formula for all container-class entities', () => {
     const stats = {strength: 300, hardness: 400, density: 100}
     const expected = computeContainerCapabilities(stats).capacity
@@ -154,6 +160,24 @@ test('computeEntityCapabilities emits crafterLanes alongside legacy crafter sum'
     expect(result.crafter!.speed).toBe(expectedSpeed)
 })
 
+test('builder capabilities read canonical resonance and fineness slots', () => {
+    expect(computeBuilderCapabilities({resonance: 500, fineness: 330})).toEqual({
+        speed: 500,
+        drain: 20_000,
+    })
+})
+
+test('computeEntityCapabilities emits a Builder lane from resonance and fineness', () => {
+    const modules: InstalledModule[] = [
+        {slotIndex: 0, itemId: ITEM_BUILDER_T1, stats: makeBuilderStats(500, 330)},
+    ]
+    const layout: EntitySlot[] = [{type: 'builder', outputPct: 80, maxTier: 1}]
+    const result = computeEntityCapabilities({}, ITEM_EXTRACTOR_T1_PACKED, modules, layout)
+
+    expect(result.builderLanes).toEqual([{slotIndex: 0, speed: 400, drain: 20_000, outputPct: 80}])
+    expect(result.builder).toEqual({speed: 400, drain: 20_000})
+})
+
 test('computeEntityCapabilities emits loaderLanes alongside legacy loaders sum', () => {
     const loaderStats = makeLoaderStats(600, 500)
 

package/src/derivation/capabilities.ts

@@ -147,12 +147,12 @@ export function computeBuilderCapabilities(stats: Record<string, number>): {
     speed: number
     drain: number
 } {
-    const coh = stats.cohesion
-    const tol = stats.tolerance
+    const resonance = stats.resonance
+    const fineness = stats.fineness
 
     return {
-        speed: 100 + Math.floor((coh * 4) / 5),
-        drain: Math.max(5000, 30000 - Math.floor((tol * 1000) / 33)),
+        speed: 100 + Math.floor((resonance * 4) / 5),
+        drain: Math.max(5000, 30000 - Math.floor((fineness * 1000) / 33)),
     }
 }
 

package/src/derivation/capability-mappings.ts

@@ -9,6 +9,7 @@ import {
     ITEM_GATHERER_T1,
     ITEM_LOADER_T1,
     ITEM_CRAFTER_T1,
+    ITEM_BUILDER_T1,
     ITEM_STORAGE_T1,
     ITEM_HAULER_T1,
     ITEM_WARP_T1,
@@ -27,6 +28,7 @@ export const KIND_TO_ITEM_ID: Record<SlotConsumerKind, number> = {
     gatherer: ITEM_GATHERER_T1,
     loader: ITEM_LOADER_T1,
     crafter: ITEM_CRAFTER_T1,
+    builder: ITEM_BUILDER_T1,
     storage: ITEM_STORAGE_T1,
     hauler: ITEM_HAULER_T1,
     warp: ITEM_WARP_T1,

package/src/nft/buildImmutableData.ts

@@ -263,12 +263,12 @@ export function buildModuleImmutable(
             break
         }
         case MODULE_BUILDER: {
-            const coh = decodeStat(stats, 0)
-            const tol = decodeStat(stats, 1)
-            base.push({first: 'cohesion', second: ['uint16', coh]})
-            base.push({first: 'tolerance', second: ['uint16', tol]})
-            base.push({first: 'speed', second: ['uint16', computeBuilderSpeed(coh)]})
-            base.push({first: 'drain', second: ['uint16', toWholeEnergy(computeBuilderDrain(tol))]})
+            const res = decodeStat(stats, 0)
+            const fin = decodeStat(stats, 1)
+            base.push({first: 'resonance', second: ['uint16', res]})
+            base.push({first: 'fineness', second: ['uint16', fin]})
+            base.push({first: 'speed', second: ['uint16', computeBuilderSpeed(res)]})
+            base.push({first: 'drain', second: ['uint16', toWholeEnergy(computeBuilderDrain(fin))]})
             break
         }
         case MODULE_STORAGE: {

package/src/nft/description.ts

@@ -114,9 +114,9 @@ export const computeLoaderThrust = (pla: number): number => 1 + idiv(pla * pla,
 export const computeCrafterSpeed = (rea: number): number => 100 + idiv(rea * 4, 5)
 export const computeCrafterDrain = (fin: number): number =>
     Math.max(5000, 30000 - idiv(fin * 1000, 33))
-export const computeBuilderSpeed = (coh: number): number => 100 + idiv(coh * 4, 5)
-export const computeBuilderDrain = (tol: number): number =>
-    Math.max(5000, 30000 - idiv(tol * 1000, 33))
+export const computeBuilderSpeed = (resonance: number): number => 100 + idiv(resonance * 4, 5)
+export const computeBuilderDrain = (fineness: number): number =>
+    Math.max(5000, 30000 - idiv(fineness * 1000, 33))
 export const computeHaulerCapacity = (fin: number, tier: number): number =>
     Math.max(tier, tier + idiv(fin, 400))
 export const computeHaulerEfficiency = (con: number): number => 2000 + con * 6
@@ -260,9 +260,9 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             break
         }
         case MODULE_BUILDER: {
-            const coh = decodeStat(stats, 0)
-            const tol = decodeStat(stats, 1)
-            out += `  Speed ${computeBuilderSpeed(coh)}  Drain ${toWholeEnergy(computeBuilderDrain(tol))}`
+            const res = decodeStat(stats, 0)
+            const fin = decodeStat(stats, 1)
+            out += `  Speed ${computeBuilderSpeed(res)}  Drain ${toWholeEnergy(computeBuilderDrain(fin))}`
             break
         }
         case MODULE_STORAGE: {

package/src/scheduling/lanes.ts

@@ -130,12 +130,12 @@ export function resolveLaneBuilder(
     const item = getItem(Number(installed.item_id.value ?? installed.item_id))
     if (item.moduleType !== 'builder') throw new Error('lane module is not a builder')
     const stats = BigInt(installed.stats.toString())
-    const coh = decodeStat(stats, 0)
-    const tol = decodeStat(stats, 1)
+    const res = decodeStat(stats, 0)
+    const fin = decodeStat(stats, 1)
     const layout = getEntityLayout(entityItemId)?.slots ?? []
     const amp = getSlotAmp(layout, idx)
-    const speed = applySlotMultiplier(computeBuilderSpeed(coh), amp)
-    const drain = computeBuilderDrain(tol)
+    const speed = applySlotMultiplier(computeBuilderSpeed(res), amp)
+    const drain = computeBuilderDrain(fin)
     return {slotIndex: idx, speed, drain, outputPct: amp}
 }