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

package/src/scheduling/cancel.test.ts

@@ -10,6 +10,7 @@ function task(over: Partial<{type: number; duration: number; cancelable: number;
         duration: over.duration ?? 100,
         cancelable: over.cancelable ?? TaskCancelable.BEFORE_START,
         cargo: [],
+        couplings: [],
         ...(over.group ? {entitygroup: over.group} : {}),
     })
 }
@@ -28,6 +29,7 @@ function entity(tasks: ReturnType<typeof task>[], startedISO = T0) {
         lanes: [{lane_key: 0, schedule: {started: startedISO, tasks}}],
         gatherer_lanes: [],
         crafter_lanes: [],
+        builder_lanes: [],
         loader_lanes: [],
         holds: [],
     })
@@ -101,14 +103,20 @@ describe('cancelEligibility — linked tasks', () => {
 })
 
 const HOLD_PULL = 1
+const HOLD_BUILD = 4
 function loadTask(giverType: string, giverId: number, holdId: number, qty: number) {
     return ServerContract.Types.task.from({
         type: TaskType.LOAD,
         duration: 100,
         cancelable: TaskCancelable.ALWAYS,
         cargo: [{item_id: 7, stats: 0, modules: [], quantity: qty}],
-        entitytarget: {entity_type: giverType, entity_id: giverId},
-        hold: holdId,
+        couplings: [
+            {
+                counterpart: {entity_type: giverType, entity_id: giverId},
+                hold: holdId,
+                kind: HOLD_PULL,
+            },
+        ],
     })
 }
 
@@ -129,7 +137,13 @@ describe('cancelEligibility — effects', () => {
                 duration: 100,
                 cancelable: TaskCancelable.ALWAYS,
                 cargo: [],
-                entitytarget: {entity_type: 'plot', entity_id: 55},
+                couplings: [
+                    {
+                        counterpart: {entity_type: 'plot', entity_id: 55},
+                        hold: 0,
+                        kind: HOLD_BUILD,
+                    },
+                ],
             }),
         ])
         const plan = cancelEligibility(e, 0, 0, {now})
@@ -152,6 +166,7 @@ describe('cancelEligibility — effects', () => {
             lanes: [{lane_key: 0, schedule: {started: T0, tasks: [lt]}}],
             gatherer_lanes: [],
             crafter_lanes: [],
+            builder_lanes: [],
             loader_lanes: [],
             holds: [
                 {
@@ -184,6 +199,7 @@ describe('cancelEligibility — effects', () => {
             lanes: [{lane_key: 0, schedule: {started: T0, tasks: [lt]}}],
             gatherer_lanes: [],
             crafter_lanes: [],
+            builder_lanes: [],
             loader_lanes: [],
             holds: [
                 {
@@ -200,8 +216,7 @@ describe('cancelEligibility — effects', () => {
         expect(plan.effects.releasedHolds[0]?.counterpart.entity_id.toNumber()).toBe(6)
     })
 
-    test('unresolvable hold emits no releasedHolds entry', () => {
-        const lt = loadTask('warehouse', 6, 99, 4)
+    test('uncoupled task emits no releasedHolds entry', () => {
         const upcoming = new Date('2026-06-18T23:59:50.000Z')
         const e = ServerContract.Types.entity_info.from({
             type: 'ship',
@@ -213,14 +228,24 @@ describe('cancelEligibility — effects', () => {
             cargomass: 0,
             cargo: [],
             modules: [],
-            lanes: [{lane_key: 0, schedule: {started: T0, tasks: [lt]}}],
+            lanes: [
+                {
+                    lane_key: 0,
+                    schedule: {
+                        started: T0,
+                        tasks: [task({cancelable: TaskCancelable.ALWAYS, type: TaskType.LOAD})],
+                    },
+                },
+            ],
             gatherer_lanes: [],
             crafter_lanes: [],
+            builder_lanes: [],
             loader_lanes: [],
             holds: [],
         })
         const plan = cancelEligibility(e, 0, 0, {now: upcoming})
         expect(plan.effects.releasedHolds).toHaveLength(0)
+        expect(plan.effects.refunds).toHaveLength(0)
     })
 })
 
@@ -233,6 +258,7 @@ describe('cancelEligibility — feasibility', () => {
             duration: 50,
             cancelable: TaskCancelable.ALWAYS,
             cargo: [{item_id: 7, stats: 0, modules: [], quantity: 2}],
+            couplings: [],
         })
         const consumer = ServerContract.Types.task.from({
             type: TaskType.CRAFT,
@@ -242,6 +268,7 @@ describe('cancelEligibility — feasibility', () => {
                 {item_id: 7, stats: 0, modules: [], quantity: 2},
                 {item_id: 9, stats: 0, modules: [], quantity: 1},
             ],
+            couplings: [],
         })
         const e = ServerContract.Types.entity_info.from({
             type: 'ship',
@@ -265,6 +292,7 @@ describe('cancelEligibility — feasibility', () => {
             ],
             gatherer_lanes: [],
             crafter_lanes: [],
+            builder_lanes: [],
             loader_lanes: [],
             holds: [],
         })
@@ -279,12 +307,14 @@ describe('cancelEligibility — feasibility', () => {
             duration: 50,
             cancelable: TaskCancelable.ALWAYS,
             cargo: [{item_id: 7, stats: 0, modules: [], quantity: 2}],
+            couplings: [],
         })
         const independent = ServerContract.Types.task.from({
             type: TaskType.TRAVEL,
             duration: 50,
             cancelable: TaskCancelable.ALWAYS,
             cargo: [],
+            couplings: [],
         })
         const e = ServerContract.Types.entity_info.from({
             type: 'ship',
@@ -302,6 +332,7 @@ describe('cancelEligibility — feasibility', () => {
             ],
             gatherer_lanes: [],
             crafter_lanes: [],
+            builder_lanes: [],
             loader_lanes: [],
             holds: [],
         })
@@ -315,12 +346,14 @@ describe('cancelEligibility — feasibility', () => {
             duration: 50,
             cancelable: TaskCancelable.ALWAYS,
             cargo: [moduledCargo],
+            couplings: [],
         })
         const consumer = ServerContract.Types.task.from({
             type: TaskType.CRAFT,
             duration: 50,
             cancelable: TaskCancelable.ALWAYS,
             cargo: [moduledCargo, {item_id: 9, stats: 0, modules: [], quantity: 1}],
+            couplings: [],
         })
         const e = ServerContract.Types.entity_info.from({
             type: 'ship',
@@ -338,6 +371,7 @@ describe('cancelEligibility — feasibility', () => {
             ],
             gatherer_lanes: [],
             crafter_lanes: [],
+            builder_lanes: [],
             loader_lanes: [],
             holds: [],
         })

package/src/scheduling/cancel.ts

@@ -1,5 +1,5 @@
 import type {ServerContract} from '../contracts'
-import {TaskCancelable, TaskType} from '../types'
+import {HoldKind, TaskCancelable, TaskType} from '../types'
 import {calcCargoItemMass} from '../capabilities/storage'
 import {taskCargoEffect, cargoKey} from './availability'
 import * as schedule from './schedule'
@@ -169,34 +169,26 @@ export function cancelEligibility(
         if (timing[i].running && t.cancelable.equals(TaskCancelable.ALWAYS))
             effects.abandonsRunning = true
         if (t.energy_cost) energyForfeited += t.energy_cost.toNumber()
-        if (t.type.equals(TaskType.BUILDPLOT) && t.entitytarget)
-            effects.keepsPlotDeposits = {plot: t.entitytarget}
-        if (t.hold && t.entitytarget) {
-            const counterpart = input.counterparts?.get(t.entitytarget.entity_id.toString())
-            const hold =
-                (counterpart?.holds ?? []).find((h) => h.id.equals(t.hold!)) ??
-                (entity.holds ?? []).find((h) => h.id.equals(t.hold!))
-            if (hold) {
-                const kind = hold.kind.toNumber()
-                effects.releasedHolds.push({counterpart: t.entitytarget, kind})
-                if (kind === 1 /* HOLD_PULL */) {
-                    effects.refunds.push({giver: t.entitytarget, cargo: t.cargo})
-                    const giver = counterpart
-                    if (giver) {
-                        const returned = t.cargo.reduce(
-                            (s, c) => s + calcCargoItemMass(c).toNumber(),
-                            0
-                        )
-                        const cap = giver.capacity
-                            ? giver.capacity.toNumber()
-                            : Number.MAX_SAFE_INTEGER
-                        if (giver.cargomass.toNumber() + returned > cap) {
-                            return {
-                                ok: false,
-                                blockedReason: CancelBlockReason.WOULD_OVERFILL,
-                                range,
-                                effects: {...EMPTY_EFFECTS},
-                            }
+        if (t.type.equals(TaskType.BUILDPLOT) && t.couplings.length > 0)
+            effects.keepsPlotDeposits = {plot: t.couplings[0].counterpart}
+        for (const c of t.couplings) {
+            const kind = c.kind.toNumber()
+            effects.releasedHolds.push({counterpart: c.counterpart, kind})
+            if (kind === HoldKind.PULL) {
+                effects.refunds.push({giver: c.counterpart, cargo: t.cargo})
+                const giver = input.counterparts?.get(c.counterpart.entity_id.toString())
+                if (giver) {
+                    const returned = t.cargo.reduce(
+                        (s, c) => s + calcCargoItemMass(c).toNumber(),
+                        0
+                    )
+                    const cap = giver.capacity ? giver.capacity.toNumber() : Number.MAX_SAFE_INTEGER
+                    if (giver.cargomass.toNumber() + returned > cap) {
+                        return {
+                            ok: false,
+                            blockedReason: CancelBlockReason.WOULD_OVERFILL,
+                            range,
+                            effects: {...EMPTY_EFFECTS},
                         }
                     }
                 }

package/src/scheduling/jobs.ts

@@ -0,0 +1,71 @@
+export interface JobWindow {
+    id: number
+    socket: number
+    owner: string
+    startsAt: Date
+    completesAt: Date
+    recipeId: number
+    quantity: number
+}
+
+export interface JobLaneEntry {
+    kind: 'idle' | 'job'
+    startsAt: Date
+    completesAt: Date
+    job?: JobWindow
+}
+
+export interface JobLane {
+    socket: number
+    entries: JobLaneEntry[]
+}
+
+export const JOB_QUEUE_CAP = 25
+
+function activeOn(jobs: JobWindow[], socket: number, now: Date): JobWindow[] {
+    return jobs
+        .filter((j) => j.socket === socket && j.completesAt > now)
+        .sort((a, b) => a.startsAt.getTime() - b.startsAt.getTime())
+}
+
+export function jobsToLanes(jobs: JobWindow[], socketCount: number, now: Date): JobLane[] {
+    const lanes: JobLane[] = []
+    for (let socket = 0; socket < socketCount; socket++) {
+        const entries: JobLaneEntry[] = []
+        let cursor: Date | null = null
+        for (const j of activeOn(jobs, socket, now)) {
+            if (cursor && j.startsAt > cursor) {
+                entries.push({kind: 'idle', startsAt: cursor, completesAt: j.startsAt})
+            }
+            entries.push({kind: 'job', startsAt: j.startsAt, completesAt: j.completesAt, job: j})
+            cursor = j.completesAt
+        }
+        lanes.push({socket, entries})
+    }
+    return lanes
+}
+
+export function socketTail(jobs: JobWindow[], socket: number, now: Date): Date {
+    const active = activeOn(jobs, socket, now)
+    const last = active[active.length - 1]
+    return last && last.completesAt > now ? last.completesAt : now
+}
+
+export function pickFabricator(
+    jobs: JobWindow[],
+    sockets: Array<{open: boolean}>,
+    durationBySocketMinutes: number[],
+    now: Date
+): {slot: number; startsAt: Date; completesAt: Date} | null {
+    let best: {slot: number; startsAt: Date; completesAt: Date} | null = null
+    for (let slot = 0; slot < sockets.length; slot++) {
+        if (!sockets[slot].open) continue
+        if (activeOn(jobs, slot, now).length >= JOB_QUEUE_CAP) continue
+        const startsAt = socketTail(jobs, slot, now)
+        const completesAt = new Date(startsAt.getTime() + durationBySocketMinutes[slot] * 60_000)
+        if (!best || completesAt < best.completesAt) {
+            best = {slot, startsAt, completesAt}
+        }
+    }
+    return best
+}

package/src/scheduling/lanes.ts

@@ -11,6 +11,8 @@ import {
     computeLoaderMass,
     computeCrafterSpeed,
     computeCrafterDrain,
+    computeBuilderSpeed,
+    computeBuilderDrain,
 } from '../nft/description'
 import type {ModuleType} from '../types'
 import {getLane, LANE_MOBILITY, type ScheduleData} from './schedule'
@@ -27,6 +29,13 @@ export interface ResolvedGathererLane {
     outputPct: number
 }
 
+export interface ResolvedBuilderLane {
+    slotIndex: number
+    speed: number
+    drain: number
+    outputPct: number
+}
+
 export interface ResolvedCrafterLane {
     slotIndex: number
     speed: number
@@ -110,6 +119,26 @@ export function resolveLaneCrafter(
     return {slotIndex: idx, speed, drain, outputPct: amp}
 }
 
+export function resolveLaneBuilder(
+    modules: ModuleEntry[],
+    entityItemId: number,
+    laneKey: number
+): ResolvedBuilderLane {
+    const idx = laneKey - 1
+    const installed = idx >= 0 && idx < modules.length ? modules[idx].installed : undefined
+    if (!installed) throw new Error('builder lane has no module')
+    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 res = decodeStat(stats, 0)
+    const fin = decodeStat(stats, 1)
+    const layout = getEntityLayout(entityItemId)?.slots ?? []
+    const amp = getSlotAmp(layout, idx)
+    const speed = applySlotMultiplier(computeBuilderSpeed(res), amp)
+    const drain = computeBuilderDrain(fin)
+    return {slotIndex: idx, speed, drain, outputPct: amp}
+}
+
 // LANE_MOBILITY or a missing module soft-returns valid=false (never throws); callers check `valid`.
 export function resolveLaneLoader(
     modules: ModuleEntry[],

package/src/scheduling/projection.ts

@@ -1,4 +1,4 @@
-import {Name, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
+import {Name, type UInt16, UInt32, UInt64} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
 import {Coordinates, TaskType} from '../types'
 import {
@@ -16,6 +16,7 @@ import {
     ENTITY_CARGO_NOT_LOADED,
 } from '../errors'
 import {getEntityLayout, getRecipe, type RecipeInput} from '../data/recipes-runtime'
+import {ITEM_SHIP_T1_PACKED} from '../data/item-ids'
 import {computeEntityCapabilities} from '../derivation/capabilities'
 import {decodeCraftedItemStats, decodeStat} from '../derivation/crafting'
 import {packedModulesToInstalled, type InstalledModule} from '../entities/slot-multiplier'
@@ -33,7 +34,7 @@ import type {ScheduleData} from './schedule'
 
 export interface ProjectedEntity {
     location: Coordinates
-    energy: UInt16
+    energy: UInt32
     cargo: CargoStack[]
     shipMass: UInt32
     capacity?: UInt64
@@ -46,6 +47,7 @@ export interface ProjectedEntity {
     readonly totalMass: UInt64
     readonly gathererLanes: ServerContract.Types.gatherer_lane[]
     readonly crafterLanes: ServerContract.Types.crafter_lane[]
+    readonly builderLanes: ServerContract.Types.builder_lane[]
 
     hasMovement(): boolean
     hasStorage(): boolean
@@ -58,13 +60,14 @@ export interface ProjectedEntity {
 
 export interface Projectable extends ScheduleData {
     coordinates: Coordinates | ServerContract.Types.coordinates
-    energy?: UInt16
+    energy?: UInt32
     hullmass?: UInt32
     generator?: ServerContract.Types.energy_stats
     engines?: ServerContract.Types.movement_stats
     loader_lanes?: ServerContract.Types.loader_lane[]
     gatherer_lanes?: ServerContract.Types.gatherer_lane[]
     crafter_lanes?: ServerContract.Types.crafter_lane[]
+    builder_lanes?: ServerContract.Types.builder_lane[]
     hauler?: ServerContract.Types.hauler_stats
     launcher?: ServerContract.Types.launcher_stats
     capacity?: UInt32
@@ -93,6 +96,7 @@ interface ProjectedCaps {
     loaderLanes: ServerContract.Types.loader_lane[]
     gathererLanes: ServerContract.Types.gatherer_lane[]
     crafterLanes: ServerContract.Types.crafter_lane[]
+    builderLanes: ServerContract.Types.builder_lane[]
     hauler?: ServerContract.Types.hauler_stats
     launcher?: ServerContract.Types.launcher_stats
 }
@@ -112,6 +116,14 @@ function recomputeCaps(entity: Projectable): ProjectedCaps | undefined {
     const hullStats = decodeCraftedItemStats(itemId, entity.stats)
     if (hullStats.strength === undefined) hullStats.strength = decodeStat(entity.stats, 0)
     if (hullStats.hardness === undefined) hullStats.hardness = decodeStat(entity.stats, 2)
+    // The retired Ship T1 recipe only assigned names to its first two stat slots.
+    // Its on-chain entity row still carries five packed channels, and the ship hull
+    // formula deliberately consumes all five. Keep the unlabelled channels internal
+    // to projection so replay remains contract-parity until deployment replaces it.
+    if (itemId === ITEM_SHIP_T1_PACKED) {
+        hullStats.__legacyShipChannel3 = decodeStat(entity.stats, 3)
+        hullStats.__legacyShipChannel4 = decodeStat(entity.stats, 4)
+    }
     const layout = getEntityLayout(itemId)?.slots ?? []
     const installed = toInstalledModules(entity.modules)
     const caps = computeEntityCapabilities(hullStats, itemId, installed, layout)
@@ -157,6 +169,19 @@ function recomputeCaps(entity: Projectable): ProjectedCaps | undefined {
             output_pct: l.outputPct,
         })
 
+    const toBuilderLane = (l: {
+        slotIndex: number
+        speed: number
+        drain: number
+        outputPct: number
+    }): ServerContract.Types.builder_lane =>
+        ServerContract.Types.builder_lane.from({
+            slot_index: l.slotIndex,
+            speed: l.speed,
+            drain: l.drain,
+            output_pct: l.outputPct,
+        })
+
     return {
         hullmass: UInt32.from(caps.hullmass),
         capacity: UInt32.from(caps.capacity),
@@ -167,6 +192,7 @@ function recomputeCaps(entity: Projectable): ProjectedCaps | undefined {
         loaderLanes: (caps.loaderLanes ?? []).map(toLoaderLane),
         gathererLanes: (caps.gathererLanes ?? []).map(toGathererLane),
         crafterLanes: (caps.crafterLanes ?? []).map(toCrafterLane),
+        builderLanes: (caps.builderLanes ?? []).map(toBuilderLane),
         hauler: caps.hauler
             ? ServerContract.Types.hauler_stats.from({
                   capacity: caps.hauler.capacity,
@@ -206,6 +232,7 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
     const loaderLanes = entity.loader_lanes ?? caps?.loaderLanes ?? []
     const gathererLanes = entity.gatherer_lanes ?? caps?.gathererLanes ?? []
     const crafterLanes = entity.crafter_lanes ?? caps?.crafterLanes ?? []
+    const builderLanes = entity.builder_lanes ?? caps?.builderLanes ?? []
     const engines = entity.engines ?? caps?.engines
     const generator = entity.generator ?? caps?.generator
     const hauler = entity.hauler ?? caps?.hauler
@@ -216,7 +243,7 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
 
     const projected: ProjectedEntity = {
         location: Coordinates.from(entity.coordinates),
-        energy: UInt16.from(entity.energy ?? 0),
+        energy: UInt32.from(entity.energy ?? 0),
         cargo,
         shipMass,
         capacity: capacity ? UInt64.from(capacity) : undefined,
@@ -227,6 +254,7 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
         loaderLanes,
         gathererLanes,
         crafterLanes,
+        builderLanes,
 
         get cargoMass() {
             return calcStacksMass(this.cargo)
@@ -286,12 +314,12 @@ function applyRechargeTask(
     if (!projected.generator) return
 
     if (options.complete) {
-        projected.energy = UInt16.from(projected.generator.capacity)
+        projected.energy = UInt32.from(projected.generator.capacity)
     } else if (options.progress !== undefined) {
         const capacity = Number(projected.generator.capacity)
         const currentEnergy = Number(projected.energy)
         const rechargeAmount = (capacity - currentEnergy) * options.progress
-        projected.energy = UInt16.from(Math.min(capacity, currentEnergy + rechargeAmount))
+        projected.energy = UInt32.from(Math.min(capacity, currentEnergy + rechargeAmount))
     }
 }
 
@@ -317,8 +345,8 @@ function applyFlightTask(
             Math.floor(Number(task.energy_cost ?? 0) * options.progress)
         )
         projected.energy = projected.energy.gt(partialEnergy)
-            ? UInt16.from(projected.energy.subtracting(partialEnergy))
-            : UInt16.from(0)
+            ? UInt32.from(projected.energy.subtracting(partialEnergy))
+            : UInt32.from(0)
     }
 }
 
@@ -344,10 +372,10 @@ function applyRemoveCargoTask(projected: ProjectedEntity, task: ServerContract.T
 
 function applyEnergyCost(projected: ProjectedEntity, task: ServerContract.Types.task): void {
     if (!task.energy_cost) return
-    const energyCost = UInt16.from(task.energy_cost)
+    const energyCost = UInt32.from(task.energy_cost)
     projected.energy = projected.energy.gt(energyCost)
-        ? UInt16.from(projected.energy.subtracting(energyCost))
-        : UInt16.from(0)
+        ? UInt32.from(projected.energy.subtracting(energyCost))
+        : UInt32.from(0)
 }
 
 function applyGatherTask(
@@ -357,7 +385,7 @@ function applyGatherTask(
 ): void {
     if (!options.complete) return
     applyEnergyCost(projected, task)
-    if (!task.entitytarget) {
+    if (task.couplings.length === 0) {
         applyAddCargoTask(projected, task)
     }
 }
@@ -369,13 +397,8 @@ function applyCraftTask(projected: ProjectedEntity, task: ServerContract.Types.t
     for (let i = 0; i < task.cargo.length - 1; i++) {
         removeCargoItem(projected, task.cargo[i])
     }
-    addCargoItem(projected, task.cargo[task.cargo.length - 1])
-}
-
-function applyDeployTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
-    applyEnergyCost(projected, task)
-    if (task.cargo.length > 0) {
-        removeCargoItem(projected, task.cargo[0])
+    if (task.couplings.length === 0) {
+        addCargoItem(projected, task.cargo[task.cargo.length - 1])
     }
 }
 
@@ -402,9 +425,6 @@ function applyTask(projected: ProjectedEntity, task: ServerContract.Types.task):
         case TaskType.CRAFT:
             applyCraftTask(projected, task)
             break
-        case TaskType.DEPLOY:
-            applyDeployTask(projected, task)
-            break
         case TaskType.UNDEPLOY:
         case TaskType.DEMOLISH:
             break
@@ -561,9 +581,6 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
             case TaskType.CRAFT:
                 if (taskComplete) applyCraftTask(projected, task)
                 break
-            case TaskType.DEPLOY:
-                if (taskComplete) applyDeployTask(projected, task)
-                break
             case TaskType.UNDEPLOY:
             case TaskType.DEMOLISH:
                 break

package/src/scheduling/task-cargo.ts

@@ -32,7 +32,7 @@ export function taskCargoChanges(task: ServerContract.Types.task): TaskCargoChan
         case TaskType.UNWRAP:
             return items.map((i) => toChange(i, 'in'))
         case TaskType.GATHER:
-            return task.entitytarget ? [] : items.map((i) => toChange(i, 'in'))
+            return task.couplings.length > 0 ? [] : items.map((i) => toChange(i, 'in'))
         case TaskType.UNLOAD:
             return items.map((i) => toChange(i, 'out'))
         case TaskType.CRAFT:

package/src/testing/projection-parity.ts

@@ -1,4 +1,4 @@
-import type {UInt16, UInt32} from '@wharfkit/antelope'
+import type {UInt32} from '@wharfkit/antelope'
 import type {ServerContract} from '../contracts'
 import type {ProjectedEntity} from '../scheduling/projection'
 import {type CargoStack, cargoItemToStack, mergeStacks} from '../capabilities/storage'
@@ -6,7 +6,7 @@ import {type CargoStack, cargoItemToStack, mergeStacks} from '../capabilities/st
 export interface ContractProjectedState {
     owner: {toString(): string}
     coordinates: ServerContract.Types.coordinates
-    energy?: UInt16
+    energy?: UInt32
     cargomass: UInt32
     cargo: ServerContract.Types.cargo_view[]
     hullmass?: UInt32

package/src/travel/reach.ts

@@ -1,23 +1,21 @@
 export interface ReachStats {
     generator?: {capacity: bigint}
     engines?: {drain: bigint}
-    hauler?: {drain: bigint}
 }
 
-export function computePerLegReach(s: ReachStats, haulCount = 0): number {
+export function computePerLegReach(s: ReachStats): number {
     const capacity = s.generator?.capacity
     const drain = s.engines?.drain
     if (capacity === undefined || drain === undefined || drain === 0n) {
         throw new Error('entity has no usable engine/generator (cannot compute per-leg reach)')
     }
-    const haulDrain = s.hauler && haulCount > 0 ? s.hauler.drain * BigInt(haulCount) : 0n
-    return Number(capacity) / Number(drain + haulDrain)
+    return Number(capacity) / Number(drain)
 }
 
-export function computeGroupPerLegReach(participants: ReachStats[], haulCount: number): number {
+export function computeGroupPerLegReach(participants: ReachStats[]): number {
     const movers = participants.filter((p) => p.engines !== undefined && p.engines.drain !== 0n)
     if (movers.length === 0) {
         throw new Error('group has no moving entity (cannot compute per-leg reach)')
     }
-    return Math.min(...movers.map((p) => computePerLegReach(p, haulCount)))
+    return Math.min(...movers.map(computePerLegReach))
 }