@shipload/sdk 1.0.0-next.34 → 1.0.0-next.36

package/src/scheduling/projection.ts

@@ -2,7 +2,6 @@ import {Name, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
 import {Coordinates, TaskType} from '../types'
 import {
-    capsHasLoaders,
     capsHasMovement,
     capsHasStorage,
     type EntityCapabilities,
@@ -18,7 +17,7 @@ import {
 } from '../errors'
 import {getEntityLayout, getRecipe, type RecipeInput} from '../data/recipes-runtime'
 import {computeEntityCapabilities} from '../derivation/capabilities'
-import {decodeCraftedItemStats} from '../derivation/crafting'
+import {decodeCraftedItemStats, decodeStat} from '../derivation/crafting'
 import {packedModulesToInstalled, type InstalledModule} from '../entities/slot-multiplier'
 import {lerp} from '../travel/travel'
 import {
@@ -39,11 +38,13 @@ export interface ProjectedEntity {
     shipMass: UInt32
     capacity?: UInt64
     engines?: ServerContract.Types.movement_stats
-    loaders?: ServerContract.Types.loader_stats
+    loaderLanes: ServerContract.Types.loader_lane[]
     generator?: ServerContract.Types.energy_stats
     hauler?: ServerContract.Types.hauler_stats
     readonly cargoMass: UInt64
     readonly totalMass: UInt64
+    readonly gathererLanes: ServerContract.Types.gatherer_lane[]
+    readonly crafterLanes: ServerContract.Types.crafter_lane[]
 
     hasMovement(): boolean
     hasStorage(): boolean
@@ -59,7 +60,9 @@ export interface Projectable extends ScheduleData {
     hullmass?: UInt32
     generator?: ServerContract.Types.energy_stats
     engines?: ServerContract.Types.movement_stats
-    loaders?: ServerContract.Types.loader_stats
+    loader_lanes?: ServerContract.Types.loader_lane[]
+    gatherer_lanes?: ServerContract.Types.gatherer_lane[]
+    crafter_lanes?: ServerContract.Types.crafter_lane[]
     hauler?: ServerContract.Types.hauler_stats
     capacity?: UInt32
     cargo: ServerContract.Types.cargo_item[]
@@ -84,7 +87,9 @@ interface ProjectedCaps {
     capacity?: UInt32
     engines?: ServerContract.Types.movement_stats
     generator?: ServerContract.Types.energy_stats
-    loaders?: ServerContract.Types.loader_stats
+    loaderLanes: ServerContract.Types.loader_lane[]
+    gathererLanes: ServerContract.Types.gatherer_lane[]
+    crafterLanes: ServerContract.Types.crafter_lane[]
     hauler?: ServerContract.Types.hauler_stats
 }
 
@@ -101,10 +106,53 @@ function recomputeCaps(entity: Projectable): ProjectedCaps | undefined {
         typeof entity.item_id === 'number' ? entity.item_id : entity.item_id.value
     )
     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)
     const layout = getEntityLayout(itemId)?.slots ?? []
     const installed = toInstalledModules(entity.modules)
     const caps = computeEntityCapabilities(hullStats, itemId, installed, layout)
 
+    const toLoaderLane = (l: {
+        slotIndex: number
+        mass: number
+        thrust: number
+        outputPct: number
+    }): ServerContract.Types.loader_lane =>
+        ServerContract.Types.loader_lane.from({
+            slot_index: l.slotIndex,
+            mass: l.mass,
+            thrust: l.thrust,
+            output_pct: l.outputPct,
+        })
+
+    const toGathererLane = (l: {
+        slotIndex: number
+        yield: number
+        drain: number
+        depth: number
+        outputPct: number
+    }): ServerContract.Types.gatherer_lane =>
+        ServerContract.Types.gatherer_lane.from({
+            slot_index: l.slotIndex,
+            yield: l.yield,
+            drain: l.drain,
+            depth: l.depth,
+            output_pct: l.outputPct,
+        })
+
+    const toCrafterLane = (l: {
+        slotIndex: number
+        speed: number
+        drain: number
+        outputPct: number
+    }): ServerContract.Types.crafter_lane =>
+        ServerContract.Types.crafter_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),
@@ -112,15 +160,23 @@ function recomputeCaps(entity: Projectable): ProjectedCaps | undefined {
         generator: caps.generator
             ? ServerContract.Types.energy_stats.from(caps.generator)
             : undefined,
-        loaders: caps.loaders ? ServerContract.Types.loader_stats.from(caps.loaders) : undefined,
+        loaderLanes: (caps.loaderLanes ?? []).map(toLoaderLane),
+        gathererLanes: (caps.gathererLanes ?? []).map(toGathererLane),
+        crafterLanes: (caps.crafterLanes ?? []).map(toCrafterLane),
         hauler: caps.hauler ? ServerContract.Types.hauler_stats.from(caps.hauler) : undefined,
     }
 }
 
+function loaderLanesTotalMass(lanes: ServerContract.Types.loader_lane[]): UInt64 {
+    let total = 0
+    for (const l of lanes) total += Number(l.mass)
+    return UInt64.from(total)
+}
+
 export function createProjectedEntity(entity: Projectable): ProjectedEntity {
     const needsRecompute =
         entity.hullmass === undefined ||
-        entity.loaders === undefined ||
+        entity.loader_lanes === undefined ||
         entity.engines === undefined ||
         entity.generator === undefined ||
         entity.hauler === undefined ||
@@ -128,7 +184,9 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
     const caps = needsRecompute ? recomputeCaps(entity) : undefined
 
     const shipMass = UInt32.from(entity.hullmass ?? caps?.hullmass ?? 0)
-    const loaders = entity.loaders ?? caps?.loaders
+    const loaderLanes = entity.loader_lanes ?? caps?.loaderLanes ?? []
+    const gathererLanes = entity.gatherer_lanes ?? caps?.gathererLanes ?? []
+    const crafterLanes = entity.crafter_lanes ?? caps?.crafterLanes ?? []
     const engines = entity.engines ?? caps?.engines
     const generator = entity.generator ?? caps?.generator
     const hauler = entity.hauler ?? caps?.hauler
@@ -145,18 +203,18 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
         engines,
         generator,
         hauler,
-        loaders,
+        loaderLanes,
+        gathererLanes,
+        crafterLanes,
 
         get cargoMass() {
             return calcStacksMass(this.cargo)
         },
 
         get totalMass() {
-            let mass = UInt64.from(this.shipMass).adding(this.cargoMass)
-            if (this.loaders) {
-                mass = mass.adding(this.loaders.mass.multiplying(this.loaders.quantity))
-            }
-            return mass
+            return UInt64.from(this.shipMass)
+                .adding(this.cargoMass)
+                .adding(loaderLanesTotalMass(this.loaderLanes))
         },
 
         hasMovement() {
@@ -168,7 +226,7 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
         },
 
         hasLoaders() {
-            return capsHasLoaders(this.capabilities())
+            return this.loaderLanes.length > 0
         },
 
         capabilities(): EntityCapabilities {
@@ -177,7 +235,6 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
                 capacity: this.capacity ? UInt32.from(this.capacity) : undefined,
                 engines: this.engines,
                 generator: this.generator,
-                loaders: this.loaders,
             }
         },
 
@@ -303,6 +360,7 @@ function applyTask(projected: ProjectedEntity, task: ServerContract.Types.task):
             break
         case TaskType.TRAVEL:
         case TaskType.WARP:
+        case TaskType.TRANSIT:
             applyFlightTask(projected, task, {complete: true})
             break
         case TaskType.LOAD:
@@ -461,6 +519,7 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
                 break
             case TaskType.TRAVEL:
             case TaskType.WARP:
+            case TaskType.TRANSIT:
                 applyFlightTask(projected, task, {complete: taskComplete, progress})
                 break
             case TaskType.LOAD:

package/src/scheduling/schedule.ts

@@ -294,7 +294,9 @@ function entityDoesTaskType(entity: ScheduleData, taskType: TaskType, now: Date)
 
 export function isInFlight(entity: ScheduleData, now: Date): boolean {
     const lane = mobilityLane(entity)
-    return lane ? core.currentTaskType(lane.schedule, now) === TaskType.TRAVEL : false
+    if (!lane) return false
+    const t = core.currentTaskType(lane.schedule, now)
+    return t === TaskType.TRAVEL || t === TaskType.TRANSIT
 }
 
 export function isRecharging(entity: ScheduleData, now: Date): boolean {

package/src/shipload.ts

@@ -7,6 +7,7 @@ import {GameContext} from './managers/context'
 import type {EntitiesManager} from './managers/entities'
 import type {PlayersManager} from './managers/players'
 import type {LocationsManager} from './managers/locations'
+import type {CoordinatesManager} from './managers/coordinates'
 import type {EpochsManager} from './managers/epochs'
 import type {ActionsManager} from './managers/actions'
 import type {NftManager} from './managers/nft'
@@ -110,6 +111,10 @@ export class Shipload {
         return this._context.locations
     }
 
+    get coordinates(): CoordinatesManager {
+        return this._context.coordinates
+    }
+
     get epochs(): EpochsManager {
         return this._context.epochs
     }

package/src/testing/projection-parity.ts

@@ -12,9 +12,11 @@ export interface ContractProjectedState {
     hullmass?: UInt32
     capacity?: UInt32
     engines?: ServerContract.Types.movement_stats
-    loaders?: ServerContract.Types.loader_stats
     generator?: ServerContract.Types.energy_stats
     hauler?: ServerContract.Types.hauler_stats
+    gatherer_lanes: ServerContract.Types.gatherer_lane[]
+    crafter_lanes: ServerContract.Types.crafter_lane[]
+    loader_lanes: ServerContract.Types.loader_lane[]
 }
 
 export interface ProjectionComparisonOptions {
@@ -55,10 +57,32 @@ export function assertProjectionEquals(
     record('capacity', toNum(contract.capacity), sdk.capacity ? Number(sdk.capacity) : undefined)
 
     recordStatBlock('engines', contract.engines, sdk.engines)
-    recordStatBlock('loaders', contract.loaders, sdk.loaders)
     recordStatBlock('generator', contract.generator, sdk.generator)
     recordStatBlock('hauler', contract.hauler, sdk.hauler)
 
+    const normLane = (l: {slot_index?: unknown; [k: string]: unknown}) =>
+        Object.fromEntries(
+            Object.entries(l)
+                .filter(([k]) => k !== 'slot_index')
+                .map(([k, v]) => [k, toNum(v) ?? 0])
+        )
+
+    const compareLanes = (name: string, cLanes: unknown[], sLanes: unknown[]) => {
+        if (cLanes.length !== sLanes.length) {
+            mismatches.push(`  ${name}.length: contract=${cLanes.length} sdk=${sLanes.length}`)
+            return
+        }
+        for (let i = 0; i < cLanes.length; i++) {
+            const cn = JSON.stringify(normLane(cLanes[i] as Record<string, unknown>))
+            const sn = JSON.stringify(normLane(sLanes[i] as Record<string, unknown>))
+            if (cn !== sn) mismatches.push(`  ${name}[${i}]: contract=${cn} sdk=${sn}`)
+        }
+    }
+
+    compareLanes('gatherer_lanes', contract.gatherer_lanes as unknown[], sdk.gathererLanes ?? [])
+    compareLanes('crafter_lanes', contract.crafter_lanes as unknown[], sdk.crafterLanes ?? [])
+    compareLanes('loader_lanes', contract.loader_lanes as unknown[], sdk.loaderLanes ?? [])
+
     if (contract.cargo.length > 0 || sdk.cargo.length > 0) {
         const contractCargo = normaliseCargo(mergeContractCargo(contract.cargo))
         const sdkCargo = normaliseCargo(sdk.cargo)

package/src/travel/travel.ts

@@ -37,9 +37,14 @@ import {
 import {EntityClass} from '../data/kind-registry'
 import {getItem} from '../data/catalog'
 import {hasSystem} from '../utils/system'
+import {WH} from '../derivation/wormhole'
 import * as scheduleModel from '../scheduling/schedule'
 import type {ScheduleData} from '../scheduling/schedule'
 
+function isPositionalTask(task: ServerContract.Types.task): boolean {
+    return task.type.equals(TaskType.TRAVEL) || task.type.equals(TaskType.TRANSIT)
+}
+
 export function calc_orbital_altitude(mass: number): number {
     if (mass <= BASE_ORBITAL_MASS) {
         return MIN_ORBITAL_ALTITUDE
@@ -125,7 +130,7 @@ export function getInterpolatedPosition(
         return {x: Number(settled.x), y: Number(settled.y)}
     }
     const task = tasks[taskIndex]
-    if (!task.type.equals(TaskType.TRAVEL) || !task.coordinates) {
+    if (!isPositionalTask(task) || !task.coordinates) {
         const origin = getFlightOrigin(entity, taskIndex)
         return {x: Number(origin.x), y: Number(origin.y)}
     }
@@ -198,15 +203,31 @@ export function calc_flighttime(distance: UInt64Type, acceleration: number): UIn
     return UInt32.from(2 * Math.sqrt(Number(distance) / acceleration))
 }
 
+export function calc_transit_duration(ax: number, ay: number, bx: number, by: number): UInt32 {
+    const distance = distanceBetweenPoints(ax, ay, bx, by)
+    return UInt32.from(Math.floor(distance.toNumber() / (PRECISION * WH.TRANSIT_SPEED)))
+}
+
+// The active entity's chosen loader lane (lowest slot), mirroring cargo.cpp lane selection.
+export function shipLoaderLane(ship: ShipLike): {thrust: number; mass: number} | undefined {
+    const lanes = ship.loader_lanes ?? []
+    if (lanes.length === 0) return undefined
+    let lowest = lanes[0]
+    for (const lane of lanes) {
+        if (Number(lane.slot_index) < Number(lowest.slot_index)) lowest = lane
+    }
+    return {thrust: Number(lowest.thrust), mass: Number(lowest.mass)}
+}
+
 export function calc_loader_flighttime(ship: ShipLike, mass: UInt64, altitude?: number): UInt32 {
     const z = altitude ?? ship.coordinates.z?.toNumber() ?? calc_orbital_altitude(Number(mass))
     return calc_flighttime(z, calc_loader_acceleration(ship, mass))
 }
 
 export function calc_loader_acceleration(ship: ShipLike, mass: UInt64): number {
-    const thrust = ship.loaders ? Number(ship.loaders.thrust) : 0
-    const loaderMass = ship.loaders ? Number(ship.loaders.mass) : 0
-    return calc_acceleration(thrust, Number(mass) + loaderMass)
+    const lane = shipLoaderLane(ship)
+    const thrust = lane ? lane.thrust : 0
+    return calc_acceleration(thrust, Number(mass))
 }
 
 export function calc_ship_flighttime(ship: ShipLike, mass: UInt64, distance: UInt64): UInt32 {
@@ -228,8 +249,10 @@ export function calc_ship_mass(ship: ShipLike, cargos: CargoMassInfo[]): UInt64
 
     mass.add(ship.hullmass)
 
-    if (ship.loaders && ship.loaders.quantity.gt(UInt32.zero)) {
-        mass.add(ship.loaders.mass.multiplying(ship.loaders.quantity))
+    if (ship.loader_lanes && ship.loader_lanes.length > 0) {
+        for (const l of ship.loader_lanes) {
+            mass.add(UInt64.from(l.mass))
+        }
     }
 
     for (const cargo of cargos) {
@@ -264,10 +287,10 @@ export function calculateTransferTime(
         return UInt32.from(0)
     }
 
-    if (!ship.loaders) return UInt32.from(0)
-    mass = UInt64.from(mass).adding(ship.loaders.mass)
-    const transfer_time = calc_loader_flighttime(ship, mass)
-    return transfer_time.dividing(ship.loaders.quantity)
+    const lane = shipLoaderLane(ship)
+    if (!lane) return UInt32.from(0)
+    mass = UInt64.from(mass).adding(UInt64.from(lane.mass))
+    return calc_loader_flighttime(ship, mass)
 }
 
 export function calculateRefuelingTime(ship: ShipLike): UInt32 {
@@ -322,25 +345,22 @@ export function calculateLoadTimeBreakdown(
     let unloadTime = 0
     let loadTime = 0
 
-    if (mass_unload.gt(UInt64.zero) && ship.loaders) {
-        const totalMass = UInt64.from(mass_unload).adding(ship.loaders.mass)
+    const lane = shipLoaderLane(ship)
+
+    if (mass_unload.gt(UInt64.zero) && lane) {
+        const totalMass = UInt64.from(mass_unload).adding(UInt64.from(lane.mass))
         unloadTime = Number(calc_loader_flighttime(ship, totalMass))
     }
 
-    if (mass_load.gt(UInt64.zero) && ship.loaders) {
-        const totalMass = UInt64.from(mass_load).adding(ship.loaders.mass)
+    if (mass_load.gt(UInt64.zero) && lane) {
+        const totalMass = UInt64.from(mass_load).adding(UInt64.from(lane.mass))
         loadTime = Number(calc_loader_flighttime(ship, totalMass))
     }
 
-    const numLoaders = ship.loaders ? Number(ship.loaders.quantity) : 0
-    const totalTime = numLoaders > 0 ? (unloadTime + loadTime) / numLoaders : 0
-    const unloadTimePerLoader = numLoaders > 0 ? unloadTime / numLoaders : 0
-    const loadTimePerLoader = numLoaders > 0 ? loadTime / numLoaders : 0
-
     return {
-        unloadTime: unloadTimePerLoader,
-        loadTime: loadTimePerLoader,
-        totalTime,
+        unloadTime,
+        loadTime,
+        totalTime: unloadTime + loadTime,
         unloadMass: Number(mass_unload),
         loadMass: Number(mass_load),
     }
@@ -374,24 +394,16 @@ export function estimateTravelTime(
     let loadTime = UInt32.zero
     let unloadTime = UInt32.zero
 
-    if (
-        loadMass &&
-        UInt32.from(loadMass).gt(UInt32.zero) &&
-        ship.loaders &&
-        ship.loaders.quantity.gt(UInt32.zero)
-    ) {
-        const totalMass = UInt64.from(loadMass).adding(ship.loaders.mass)
-        loadTime = calc_loader_flighttime(ship, totalMass).dividing(ship.loaders.quantity)
+    const lane = shipLoaderLane(ship)
+
+    if (loadMass && UInt32.from(loadMass).gt(UInt32.zero) && lane) {
+        const totalMass = UInt64.from(loadMass).adding(UInt64.from(lane.mass))
+        loadTime = calc_loader_flighttime(ship, totalMass)
     }
 
-    if (
-        unloadMass &&
-        UInt32.from(unloadMass).gt(UInt32.zero) &&
-        ship.loaders &&
-        ship.loaders.quantity.gt(UInt32.zero)
-    ) {
-        const totalMass = UInt64.from(unloadMass).adding(ship.loaders.mass)
-        unloadTime = calc_loader_flighttime(ship, totalMass).dividing(ship.loaders.quantity)
+    if (unloadMass && UInt32.from(unloadMass).gt(UInt32.zero) && lane) {
+        const totalMass = UInt64.from(unloadMass).adding(UInt64.from(lane.mass))
+        unloadTime = calc_loader_flighttime(ship, totalMass)
     }
 
     return {
@@ -423,14 +435,32 @@ export function hasEnergyForDistance(ship: ShipLike, distance: UInt64Type): bool
     return UInt64.from(ship.energy ?? 0).gte(energyNeeded)
 }
 
+export interface TransferLoaderLane {
+    slot_index?: {toNumber(): number} | number
+    thrust: {toNumber(): number} | number
+    mass: {toNumber(): number} | number
+}
+
 export interface TransferEntity {
     location: {z?: {toNumber(): number} | number}
     entityClass: EntityClass
-    loaders?: {
-        thrust: {toNumber(): number} | number
-        mass: {toNumber(): number} | number
-        quantity: {toNumber(): number} | number
+    loaderLanes?: TransferLoaderLane[]
+}
+
+function toNum(v: {toNumber(): number} | number | undefined): number {
+    if (v === undefined) return 0
+    return typeof v === 'number' ? v : v.toNumber()
+}
+
+// Mirrors cargo.cpp worker_lane_key_or_mobility: lowest-slot loader lane (display has no busy context).
+function chosenLoaderLane(entity: TransferEntity): TransferLoaderLane | undefined {
+    const lanes = entity.loaderLanes ?? []
+    if (lanes.length === 0) return undefined
+    let lowest = lanes[0]
+    for (const lane of lanes) {
+        if (toNum(lane.slot_index) < toNum(lowest.slot_index)) lowest = lane
     }
+    return lowest
 }
 
 export interface HasScheduleAndLocation extends ScheduleData {
@@ -449,7 +479,7 @@ export function getFlightOrigin(
     let origin = entity.coordinates
     for (let i = 0; i < flightTaskIndex && i < tasks.length; i++) {
         const task = tasks[i]
-        if (task.type.equals(TaskType.TRAVEL) && task.coordinates) {
+        if (isPositionalTask(task) && task.coordinates) {
             origin = task.coordinates
         }
     }
@@ -462,7 +492,7 @@ export function getDestinationLocation(
     const tasks = mobilityTasks(entity)
     for (let i = tasks.length - 1; i >= 0; i--) {
         const task = tasks[i]
-        if (task.type.equals(TaskType.TRAVEL) && task.coordinates) {
+        if (isPositionalTask(task) && task.coordinates) {
             return task.coordinates
         }
     }
@@ -485,7 +515,7 @@ export function getPositionAt(
 
     const task = tasks[taskIndex]
 
-    if (!task.type.equals(TaskType.TRAVEL) || !task.coordinates) {
+    if (!isPositionalTask(task) || !task.coordinates) {
         return getFlightOrigin(entity, taskIndex)
     }
 
@@ -505,73 +535,54 @@ export function minTransferDistance(entityClass: EntityClass): number {
         : MIN_TRANSFER_DISTANCE_PLANETARY_STRUCTURE
 }
 
-export function calc_transfer_duration(
-    source: TransferEntity,
-    dest: TransferEntity,
+// Mirrors cargo.cpp calc_onesided_duration: single active loader's thrust + mass, no ÷quantity.
+export function calc_onesided_duration(
+    loaderThrust: number,
+    loaderMass: number,
+    activeZ: number,
+    counterpartZ: number,
+    activeEntityClass: EntityClass,
+    counterpartEntityClass: EntityClass,
     cargoMass: number
 ): number {
-    if (cargoMass === 0) {
-        return 0
-    }
-
-    let totalThrust = 0
-    let totalLoaderMass = 0
-    let totalQuantity = 0
-
-    if (source.loaders) {
-        const thrust =
-            typeof source.loaders.thrust === 'number'
-                ? source.loaders.thrust
-                : source.loaders.thrust.toNumber()
-        const mass =
-            typeof source.loaders.mass === 'number'
-                ? source.loaders.mass
-                : source.loaders.mass.toNumber()
-        const qty =
-            typeof source.loaders.quantity === 'number'
-                ? source.loaders.quantity
-                : source.loaders.quantity.toNumber()
-        totalThrust += thrust * qty
-        totalLoaderMass += mass * qty
-        totalQuantity += qty
-    }
-
-    if (dest.loaders) {
-        const thrust =
-            typeof dest.loaders.thrust === 'number'
-                ? dest.loaders.thrust
-                : dest.loaders.thrust.toNumber()
-        const mass =
-            typeof dest.loaders.mass === 'number' ? dest.loaders.mass : dest.loaders.mass.toNumber()
-        const qty =
-            typeof dest.loaders.quantity === 'number'
-                ? dest.loaders.quantity
-                : dest.loaders.quantity.toNumber()
-        totalThrust += thrust * qty
-        totalLoaderMass += mass * qty
-        totalQuantity += qty
-    }
-
-    if (totalThrust === 0 || totalQuantity === 0) {
+    if (cargoMass === 0 || loaderThrust === 0) {
         return 0
     }
-
-    const sourceZ =
-        typeof source.location.z === 'number'
-            ? source.location.z
-            : (source.location.z?.toNumber() ?? 0)
-    const destZ =
-        typeof dest.location.z === 'number' ? dest.location.z : (dest.location.z?.toNumber() ?? 0)
-    const rawDistance = Math.abs(sourceZ - destZ)
+    const rawDistance = Math.abs(activeZ - counterpartZ)
     const minDistance = Math.max(
-        minTransferDistance(source.entityClass),
-        minTransferDistance(dest.entityClass)
+        minTransferDistance(activeEntityClass),
+        minTransferDistance(counterpartEntityClass)
     )
     const distance = rawDistance < minDistance ? minDistance : rawDistance
+    const totalMass = cargoMass + loaderMass
+    const acceleration = calc_acceleration(loaderThrust, totalMass)
+    const flightTime = Math.floor(2 * Math.sqrt(distance / acceleration))
+    return flightTime === 0 ? 1 : flightTime
+}
 
-    const totalMass = cargoMass + totalLoaderMass
-    const acceleration = calc_acceleration(totalThrust, totalMass)
-    const flightTime = 2 * Math.sqrt(distance / acceleration)
+// Mirrors cargo.cpp: the active (loader-bearing) entity's chosen loader lane drives the duration.
+export function calc_transfer_duration(
+    source: TransferEntity,
+    dest: TransferEntity,
+    cargoMass: number
+): number {
+    const active = chosenLoaderLane(source) ? source : dest
+    const counterpart = active === source ? dest : source
+    const lane = chosenLoaderLane(active)
+    if (!lane) {
+        return 0
+    }
 
-    return Math.floor(flightTime / totalQuantity)
+    const activeZ = toNum(active.location.z)
+    const counterpartZ = toNum(counterpart.location.z)
+
+    return calc_onesided_duration(
+        toNum(lane.thrust),
+        toNum(lane.mass),
+        activeZ,
+        counterpartZ,
+        active.entityClass,
+        counterpart.entityClass,
+        cargoMass
+    )
 }

package/src/types/capabilities.ts

@@ -1,6 +1,23 @@
-import type {Name, UInt16, UInt32} from '@wharfkit/antelope'
+import type {Name, UInt16, UInt32, UInt8} from '@wharfkit/antelope'
 import type {ServerContract} from '../contracts'
 
+export interface LoaderStats {
+    mass: {toNumber(): number; multiplying(v: unknown): {toNumber(): number}}
+    thrust: {toNumber(): number}
+    quantity: {toNumber(): number; gt(v: unknown): boolean}
+}
+
+export interface GathererStats {
+    yield: {toNumber(): number}
+    drain: {toNumber(): number}
+    depth: {toNumber(): number; toString(): string}
+}
+
+export interface CrafterStats {
+    speed: {toNumber(): number}
+    drain: {toNumber(): number}
+}
+
 export interface MovementCapability {
     engines: ServerContract.Types.movement_stats
     generator: ServerContract.Types.energy_stats
@@ -17,11 +34,11 @@ export interface StorageCapability {
 }
 
 export interface LoaderCapability {
-    loaders: ServerContract.Types.loader_stats
+    loaders: LoaderStats
 }
 
 export interface GathererCapability {
-    gatherer: ServerContract.Types.gatherer_stats
+    gatherer: GathererStats
 }
 
 export interface MassCapability {
@@ -38,9 +55,9 @@ export interface EntityCapabilities {
     capacity?: UInt32
     engines?: ServerContract.Types.movement_stats
     generator?: ServerContract.Types.energy_stats
-    loaders?: ServerContract.Types.loader_stats
-    gatherer?: ServerContract.Types.gatherer_stats
-    crafter?: ServerContract.Types.crafter_stats
+    loaders?: LoaderStats
+    gatherer?: GathererStats
+    crafter?: CrafterStats
     hauler?: ServerContract.Types.hauler_stats
 }
 

package/src/types/entity.ts

@@ -3,6 +3,7 @@ import type {ServerContract} from '../contracts'
 import type {Coordinates} from '../types'
 import type {
     EnergyCapability,
+    GathererCapability,
     LoaderCapability,
     MassCapability,
     MovementCapability,
@@ -24,9 +25,8 @@ export type ShipEntity = Entity &
     StorageCapability &
     Partial<LoaderCapability> &
     MassCapability &
-    ScheduleCapability & {
-        gatherer?: ServerContract.Types.gatherer_stats
-    }
+    ScheduleCapability &
+    Partial<GathererCapability>
 
 export type WarehouseEntity = Entity &
     StorageCapability &