@shipload/sdk 1.0.0-next.72 → 1.0.0-next.74

package/src/scheduling/jobs.test.ts

@@ -1,7 +1,11 @@
 import {describe, expect, it} from 'bun:test'
-import type {OrderedTask} from './schedule'
+import {UInt8, UInt32, UInt64} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {HoldKind} from '../types'
+import type {OrderedTask, ScheduleData} from './schedule'
 import {
     buildJobCancelRoute,
+    hostedDropoff,
     jobCancelRoute,
     jobCancellationBlockReason,
     jobCancellable,
@@ -15,6 +19,7 @@ import {
 } from './jobs'
 
 const at = (s: string) => new Date(s)
+const WITH_MODULES = [{item_id: 101, stats: '413333752', quantity: 10, modules: []}] as never
 
 const INPUTS = [{item_id: 101, stats: '413333752', quantity: 10}] as never
 const FULL_INPUT = {
@@ -191,6 +196,28 @@ describe('jobStatus', () => {
     it('reads an undeposited row as dropping off when no schedule is given', () => {
         expect(jobStatus(inFlight, at('2026-07-26T09:00:00Z'))).toBe('dropping')
     })
+    it('finds the Drop-off of a booking-time undeposited job from its inputs-only cargo', () => {
+        const input = {item_id: 1, stats: '0', quantity: 5, modules: [], entity_id: undefined}
+        const {inputs} = splitJobCargo([input], false, 1)
+        const dropoff = task({
+            type: 21,
+            building: 7,
+            cargo: [input],
+            startsAt: at('2026-07-26T00:00:00Z'),
+            completesAt: at('2026-07-26T00:00:01Z'),
+        })
+        expect(
+            jobDropoffTask(
+                {
+                    startsAt: new Date(0),
+                    completesAt: new Date(0),
+                    building: 7,
+                    inputs: inputs as never,
+                },
+                [dropoff]
+            )
+        ).toBe(dropoff)
+    })
     it('labels every phase', () => {
         expect(jobStatusLabel('booked')).toBe('Booked')
         expect(jobStatusLabel('dropping')).toBe('Dropping off')
@@ -262,6 +289,37 @@ describe('jobCancelRoute', () => {
     it('cancels a Queued job through cancelcraft', () => {
         expect(jobCancelRoute(job, at('2026-07-26T09:59:59Z'))).toEqual({kind: 'craft', jobId: 7})
     })
+    it('routes a bay-hosted drop-off cancel through cancelcivic when the task is the lane tail and not yet completed', () => {
+        const route = jobCancelRoute(inFlight, at('2026-07-26T09:00:00Z'), [], {
+            hosted: {hostId: 90000, laneKey: 1, taskIndex: 0, civic: true},
+            hostedTask: dropoff,
+            hostLaneLength: 1,
+        })
+        expect(route).toEqual({kind: 'civic', buildingId: 90000, laneKey: 1, fromId: 5})
+    })
+    it('refuses a bay-hosted civic cancel once the hosted task has completed', () => {
+        const route = jobCancelRoute(inFlight, at('2026-07-26T10:00:00Z'), [], {
+            hosted: {hostId: 90000, laneKey: 1, taskIndex: 0, civic: true},
+            hostedTask: dropoff,
+            hostLaneLength: 1,
+        })
+        expect(route).toBeNull()
+    })
+    it('refuses a bay-hosted civic cancel when the hosted task is not the lane tail', () => {
+        const route = jobCancelRoute(inFlight, at('2026-07-26T09:00:00Z'), [], {
+            hosted: {hostId: 90000, laneKey: 1, taskIndex: 0, civic: true},
+            hostedTask: dropoff,
+            hostLaneLength: 2,
+        })
+        expect(route).toBeNull()
+    })
+    it('routes a third-party-hosted drop-off cancel through the carrier ship', () => {
+        const route = jobCancelRoute(inFlight, at('2026-07-26T09:00:00Z'), [], {
+            hosted: {hostId: 8, laneKey: 2, taskIndex: 0, civic: false},
+            hostLaneLength: 3,
+        })
+        expect(route).toEqual({kind: 'dropoff', shipId: 8, laneKey: 2, count: 3})
+    })
     it('refuses only deposited positive-quantity output-only legacy jobs', () => {
         const legacy = {...job, inputs: []}
         expect(jobCancellationBlockReason(legacy)).toBe('legacy-inputs-unavailable')
@@ -412,6 +470,15 @@ describe('splitJobCargo', () => {
         expect(splitJobCargo([], true, 1)).toEqual({output: null, inputs: []})
         expect(splitJobCargo([], false, 1)).toEqual({output: null, inputs: []})
     })
+    it('reads an undeposited row whose input is booked as more than one stack per recipe slot', () => {
+        const stackA1 = {item_id: 1, quantity: 2}
+        const stackA2 = {item_id: 1, quantity: 1}
+        const stackB = {item_id: 2, quantity: 4}
+        const cargo = [stackA1, stackA2, stackB] as unknown as Parameters<typeof splitJobCargo>[0]
+        const {output, inputs} = splitJobCargo(cargo, false, 1)
+        expect(output).toBeNull()
+        expect(inputs).toEqual([stackA1, stackA2, stackB] as never)
+    })
 })
 
 describe('workshopAvailability', () => {
@@ -446,3 +513,106 @@ describe('workshopAvailability', () => {
         expect(workshopAvailability(jobs, 1, now)).toEqual({open: 1, nextOpeningAt: null})
     })
 })
+
+describe('hostedDropoff', () => {
+    function hostWithDeposit(
+        entityType: string,
+        building: number,
+        holdId: number,
+        owner = 'nex.shipload'
+    ): ScheduleData & {owner: string} {
+        return {
+            owner,
+            lanes: [
+                ServerContract.Types.lane.from({
+                    lane_key: UInt8.from(1),
+                    schedule: {
+                        started: '2026-07-26T09:00:00.000',
+                        tasks: [
+                            {
+                                type: UInt8.from(21),
+                                duration: UInt32.from(600),
+                                cancelable: UInt8.from(2),
+                                cargo: WITH_MODULES,
+                                couplings: [
+                                    {
+                                        counterpart: {entity_type: 'ship', entity_id: 5},
+                                        hold: holdId,
+                                        kind: HoldKind.PULL,
+                                    },
+                                ],
+                                subject: {entity_type: entityType, entity_id: building},
+                            },
+                        ],
+                    },
+                }),
+            ],
+        }
+    }
+
+    function sourceWithHold(hostId: number, hostType: string, holdId: number): ScheduleData {
+        return {
+            holds: [
+                ServerContract.Types.hold.from({
+                    id: holdId,
+                    kind: HoldKind.PULL,
+                    counterpart: {entity_type: hostType, entity_id: hostId},
+                    until: '2026-07-26T09:50:00.000',
+                    incoming_mass: 0,
+                }),
+            ],
+        }
+    }
+
+    const job = {
+        building: 42,
+        inputs: WITH_MODULES,
+        startsAt: at('2026-07-26T10:00:00Z'),
+        completesAt: at('2026-07-26T11:00:00Z'),
+    }
+
+    it('finds the carrier hosting a bay-hosted Drop-off and flags it civic', () => {
+        const host = hostWithDeposit('depot', 42, 3, 'nex.shipload')
+        const source = sourceWithHold(90000, 'depot', 3)
+        const lookup = (id: string) => (id === '90000' ? host : undefined)
+        const result = hostedDropoff(source, lookup, job, 'nex.shipload')
+        expect(result).toMatchObject({hostId: 90000, laneKey: 1, taskIndex: 0, civic: true})
+    })
+
+    it('does not flag a player-owned Depot civic', () => {
+        const host = hostWithDeposit('depot', 42, 3, 'alice')
+        const source = sourceWithHold(90000, 'depot', 3)
+        const lookup = (id: string) => (id === '90000' ? host : undefined)
+        const result = hostedDropoff(source, lookup, job, 'nex.shipload')
+        expect(result).toMatchObject({hostId: 90000, laneKey: 1, taskIndex: 0, civic: false})
+    })
+
+    it('finds a third-party carrier and does not flag it civic', () => {
+        const host = hostWithDeposit('ship', 42, 3, 'alice')
+        const source = sourceWithHold(8, 'ship', 3)
+        const lookup = (id: string) => (id === '8' ? host : undefined)
+        const result = hostedDropoff(source, lookup, job, 'nex.shipload')
+        expect(result).toMatchObject({hostId: 8, laneKey: 1, taskIndex: 0, civic: false})
+    })
+
+    it('returns undefined when no PULL hold names a matching host task', () => {
+        expect(hostedDropoff({holds: []}, () => undefined, job)).toBeUndefined()
+        const host = hostWithDeposit('depot', 99, 3)
+        const source = sourceWithHold(90000, 'depot', 3)
+        const lookup = (id: string) => (id === '90000' ? host : undefined)
+        expect(hostedDropoff(source, lookup, job)).toBeUndefined()
+    })
+
+    it('does not match a Drop-off whose arrival differs from the job', () => {
+        const host = hostWithDeposit('depot', 42, 3, 'nex.shipload')
+        const source = sourceWithHold(90000, 'depot', 3)
+        const lookup = (id: string) => (id === '90000' ? host : undefined)
+        const result = hostedDropoff(
+            source,
+            lookup,
+            {...job, arrivesAt: at('2026-07-26T12:00:00Z')},
+            'nex.shipload'
+        )
+        expect(result).toBeUndefined()
+    })
+})

package/src/scheduling/jobs.ts

@@ -1,6 +1,8 @@
+import type {NameType} from '@wharfkit/antelope'
 import type {ServerContract} from '../contracts'
-import {TaskType} from '../types'
-import type {OrderedTask} from './schedule'
+import {isCivicEntity} from '../influence/civic'
+import {HoldKind, TaskType} from '../types'
+import {orderedTasks, type OrderedTask, type ScheduleData} from './schedule'
 
 type CargoItem = ServerContract.Types.cargo_item
 
@@ -180,13 +182,31 @@ export function jobDropoffTask(
     return matches?.length === 1 ? matches[0] : undefined
 }
 
+export interface HostedLeg {
+    hostId: number
+    laneKey: number
+    taskIndex: number
+    civic: boolean
+}
+
+export interface JobRouteOptions {
+    hosted?: HostedLeg
+    hostedTask?: OrderedTask
+    hostLaneLength?: number
+}
+
 // Without the ship's schedule an undeposited row reads as Dropping off: the transfer usually starts at once.
 export function jobStatus(
     job: JobStatusInput,
     now: Date,
-    tasks?: readonly OrderedTask[]
+    tasks?: readonly OrderedTask[],
+    options?: JobRouteOptions
 ): JobStatus {
     if (job.deposited === false) {
+        if (options?.hosted) {
+            const start = options.hostedTask?.startsAt
+            return start && now < start ? 'booked' : 'dropping'
+        }
         const dropoff = jobDropoffTask(job, tasks)
         return dropoff && now < dropoff.startsAt ? 'booked' : 'dropping'
     }
@@ -231,18 +251,37 @@ export type JobCancelRoute =
     | {kind: 'dropoff'; shipId: number; laneKey: number; count: number}
     | {kind: 'craft'; jobId: number}
     | {kind: 'build'; jobId: number}
+    | {kind: 'civic'; buildingId: number; laneKey: number; fromId: number}
 
 // The ship's cancel pops from the lane tail, so the count reaches from the Drop-off through every task queued behind it.
 function cancelRoute(
     job: JobStatusInput & {id: number; shipId?: number},
     queued: 'craft' | 'build',
     now: Date,
-    tasks?: readonly OrderedTask[]
+    tasks?: readonly OrderedTask[],
+    options?: JobRouteOptions
 ): JobCancelRoute | null {
-    if (!jobCancellable(jobStatus(job, now, tasks))) return null
+    if (!jobCancellable(jobStatus(job, now, tasks, options))) return null
     if (queued === 'craft' && jobCancellationBlockReason(job, tasks)) return null
     if (job.deposited !== false) return {kind: queued, jobId: job.id}
-    if (job.shipId === undefined || !tasks) return null
+    if (job.shipId === undefined) return null
+    if (options?.hosted) {
+        const {hostId, laneKey, taskIndex, civic} = options.hosted
+        const laneLength = options.hostLaneLength ?? taskIndex + 1
+        if (civic) {
+            const isTail = taskIndex === laneLength - 1
+            const notCompleted = options.hostedTask ? options.hostedTask.completesAt > now : false
+            if (!isTail || !notCompleted) return null
+            return {kind: 'civic', buildingId: hostId, laneKey, fromId: job.shipId}
+        }
+        return {
+            kind: 'dropoff',
+            shipId: hostId,
+            laneKey,
+            count: laneLength - taskIndex,
+        }
+    }
+    if (!tasks) return null
     const dropoff = jobDropoffTask(job, tasks)
     if (!dropoff || dropoff.completesAt <= now) return null
     const laneLength = tasks.filter((t) => t.laneKey === dropoff.laneKey).length
@@ -257,18 +296,59 @@ function cancelRoute(
 export function jobCancelRoute(
     job: JobStatusInput & {id: number; shipId?: number},
     now: Date,
-    tasks?: readonly OrderedTask[]
+    tasks?: readonly OrderedTask[],
+    options?: JobRouteOptions
 ): JobCancelRoute | null {
-    return cancelRoute(job, 'craft', now, tasks)
+    return cancelRoute(job, 'craft', now, tasks, options)
 }
 
 // A Build Job's Drop-off rides on the upgrade target itself, so the target plays the ship's part.
 export function buildJobCancelRoute(
     job: JobStatusInput & {id: number; targetId?: number},
     now: Date,
-    tasks?: readonly OrderedTask[]
+    tasks?: readonly OrderedTask[],
+    options?: JobRouteOptions
 ): JobCancelRoute | null {
-    return cancelRoute({...job, shipId: job.targetId}, 'build', now, tasks)
+    return cancelRoute({...job, shipId: job.targetId}, 'build', now, tasks, options)
+}
+
+export interface HostedDropoffEntity extends ScheduleData {
+    owner?: NameType
+}
+
+// The source entity's HOLD_PULL names the carrier; the carrier's schedule carries the Drop-off task.
+export function hostedDropoff(
+    source: ScheduleData,
+    lookup: (id: string) => HostedDropoffEntity | undefined,
+    job: JobStatusInput,
+    civicOwner?: NameType
+): (HostedLeg & {task: OrderedTask}) | undefined {
+    for (const hold of source.holds ?? []) {
+        if (hold.kind.toNumber() !== HoldKind.PULL) continue
+        const host = lookup(hold.counterpart.entity_id.toString())
+        if (!host) continue
+        for (const entry of orderedTasks(host)) {
+            if (Number(entry.task.type) !== TaskType.CIVIC_DEPOSIT) continue
+            if (!entry.task.couplings.some((c) => c.hold.equals(hold.id))) continue
+            if (!matchesJob(entry, job)) continue
+            if (
+                job.arrivesAt !== undefined &&
+                entry.completesAt.getTime() !== job.arrivesAt.getTime()
+            )
+                continue
+            return {
+                hostId: Number(hold.counterpart.entity_id),
+                laneKey: entry.laneKey,
+                taskIndex: entry.taskIndex,
+                civic:
+                    civicOwner !== undefined &&
+                    host.owner !== undefined &&
+                    isCivicEntity({owner: host.owner}, civicOwner),
+                task: entry,
+            }
+        }
+    }
+    return undefined
 }
 
 export interface PickupInFlight {
@@ -312,15 +392,32 @@ export function jobDeposited(value: unknown): boolean {
     return Boolean(value)
 }
 
-// A deposited row's output is the cargo tail; a cancelled row (quantity 0) holds only its inputs.
+// A deposited row's cargo is its inputs plus the output tail; an undeposited row carries inputs only.
 export function splitJobCargo<T>(
     cargo: readonly T[],
     deposited: boolean,
     quantity: number
 ): {output: T | null; inputs: T[]} {
     if (cargo.length === 0) return {output: null, inputs: []}
-    if (!deposited || quantity === 0) return {output: null, inputs: [...cargo]}
-    return {output: cargo[cargo.length - 1], inputs: cargo.slice(0, -1)}
+    if (deposited && quantity > 0)
+        return {output: cargo[cargo.length - 1], inputs: cargo.slice(0, -1)}
+    return {output: null, inputs: [...cargo]}
+}
+
+export interface BuildJob {
+    id: number
+    building: number
+    socket: number
+    targetId: number
+    owner: string
+    coords: {x: number; y: number}
+    startsAt: Date
+    completesAt: Date
+    arrivesAt: Date
+    targetItemId: number
+    status: JobStatus
+    deposited: boolean
+    inputs: CargoItem[]
 }
 
 export interface OwnedJob {

package/src/scheduling/projection.ts

@@ -30,7 +30,7 @@ import {
     stackToCargoItem,
 } from '../capabilities/storage'
 import {hydrateEntityLanes} from '../entity/hydrate'
-import {craftCargoOwnership} from './availability'
+import {craftCargoOwnership, isHostedCivicLeg} from './availability'
 import * as schedule from './schedule'
 import type {ScheduleData} from './schedule'
 
@@ -394,6 +394,7 @@ function applyCraftTask(projected: ProjectedEntity, task: ServerContract.Types.t
 }
 
 function applyTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    if (isHostedCivicLeg(task)) return
     switch (task.type.toNumber()) {
         case TaskType.RECHARGE:
             applyRechargeTask(projected, task, {complete: true})

package/src/scheduling/task-effects.ts

@@ -32,3 +32,41 @@ export const TASK_CARGO_EFFECTS: ReadonlyMap<number, TaskCargoRule> = new Map<
 export function taskCargoRule(taskType: number): TaskCargoRule | undefined {
     return TASK_CARGO_EFFECTS.get(taskType)
 }
+
+// Transcribed from TASK_TRAITS in contracts/src/server/include/server/task_traits.hpp.
+export type TaskEnergyEffect = 'none' | 'fills' | 'draws' | 'zeroes'
+
+export const TASK_ENERGY_EFFECTS: ReadonlyMap<number, TaskEnergyEffect> = new Map<
+    number,
+    TaskEnergyEffect
+>([
+    [TaskType.IDLE, 'none'],
+    [TaskType.TRAVEL, 'draws'],
+    [TaskType.RECHARGE, 'fills'],
+    [TaskType.LOAD, 'none'],
+    [TaskType.UNLOAD, 'none'],
+    [TaskType.GATHER, 'draws'],
+    [TaskType.WARP, 'zeroes'],
+    [TaskType.CRAFT, 'draws'],
+    [TaskType.TRANSIT, 'none'],
+    [TaskType.UNWRAP, 'none'],
+    [TaskType.UNDEPLOY, 'none'],
+    [TaskType.LAUNCH, 'none'],
+    [TaskType.DEMOLISH, 'none'],
+    [TaskType.BUILDPLOT, 'draws'],
+    [TaskType.CHARGE, 'draws'],
+    [TaskType.UPGRADE, 'draws'],
+    [TaskType.SHUTTLE, 'none'],
+    [TaskType.CONTRIBUTE, 'none'],
+    [TaskType.CIVIC_DEPOSIT, 'draws'],
+    [TaskType.CIVIC_WITHDRAW, 'none'],
+])
+
+export function taskEnergyEffect(taskType: number): TaskEnergyEffect {
+    return TASK_ENERGY_EFFECTS.get(taskType) ?? 'none'
+}
+
+// Only TRAVEL is both 'draws' and mobility-trait; WARP's 'zeroes' branch never checks this.
+export function taskEnergyDrawNeedsCoordinates(taskType: number): boolean {
+    return taskType === TaskType.TRAVEL
+}

package/src/scheduling/unwrap.test.ts

@@ -5,8 +5,14 @@ import {
     unwrapLoadDuration,
     estimateUnwrapDuration,
     incomingHoldMass,
+    projectCargomass,
     projectedPeakCargomass,
 } from './unwrap'
+import {TimePoint, UInt8, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {getItem} from '../data/catalog'
+import {ITEM_BEAM} from '../data/item-ids'
+import {TaskType} from '../types'
 
 describe('unwrap duration mirror', () => {
     test('derivedLoaders aggregates lanes like derived_loaders()', () => {
@@ -84,3 +90,57 @@ test('projectedPeakCargomass tracks the running peak from cargomass', () => {
     // No pending tasks: peak = base + candidate add.
     expect(projectedPeakCargomass(entity, new Date(0), 500)).toBe(1500)
 })
+
+const DEPOSIT_START = new Date('2026-09-20T07:48:37.000Z')
+const BEAM_QTY = 2_500
+const BEAM_MASS = getItem(ITEM_BEAM).mass
+
+function unloadingShip(projectedAtMs?: number) {
+    const cargo = ServerContract.Types.cargo_item.from({
+        item_id: UInt16.from(ITEM_BEAM),
+        quantity: UInt32.from(BEAM_QTY),
+        stats: UInt64.from(0),
+        modules: [],
+    })
+    const lane = ServerContract.Types.lane.from({
+        lane_key: UInt8.from(0),
+        schedule: ServerContract.Types.schedule.from({
+            started: TimePoint.fromMilliseconds(DEPOSIT_START.getTime()),
+            tasks: [
+                ServerContract.Types.task.from({
+                    type: UInt8.from(TaskType.CIVIC_DEPOSIT),
+                    duration: UInt32.from(1_309),
+                    cancelable: UInt8.from(2),
+                    cargo: [cargo],
+                    couplings: [],
+                }),
+            ],
+        }),
+    })
+    return {
+        cargomass: BEAM_QTY * BEAM_MASS,
+        lanes: [lane],
+        holds: [],
+        projected_at:
+            projectedAtMs === undefined ? undefined : TimePoint.fromMilliseconds(projectedAtMs),
+    }
+}
+
+const UNLOAD_ENDS = new Date(DEPOSIT_START.getTime() + 1_309_000)
+const AFTER_UNLOAD = new Date(UNLOAD_ENDS.getTime() + 60_000)
+
+test('projectCargomass reports the mass held at the candidate and the peak around it', () => {
+    const plan = projectCargomass(unloadingShip(), AFTER_UNLOAD, 400 * BEAM_MASS)
+    // The queued unload empties the hold before the candidate lands.
+    expect(plan.used).toBe(400 * BEAM_MASS)
+    expect(plan.peak).toBe(BEAM_QTY * BEAM_MASS)
+})
+
+test('a task already applied to a projected row is not replayed', () => {
+    const applied = unloadingShip(UNLOAD_ENDS.getTime())
+    applied.cargomass = 0
+    const plan = projectCargomass(applied, AFTER_UNLOAD, 400 * BEAM_MASS)
+    expect(plan.used).toBe(400 * BEAM_MASS)
+    expect(plan.peak).toBe(400 * BEAM_MASS)
+    expect(projectedPeakCargomass(applied, AFTER_UNLOAD, 400 * BEAM_MASS)).toBe(plan.peak)
+})

package/src/scheduling/unwrap.ts

@@ -133,28 +133,44 @@ function cargoListMass(items: CargoItem[]): number {
     return m
 }
 
-export function projectedPeakCargomass(
-    entity: sched.ScheduleData & {cargomass: number | {toNumber(): number}},
+export interface CargomassProjection {
+    used: number
+    peak: number
+}
+
+export function projectCargomass(
+    entity: sched.AnchoredScheduleData & {cargomass: number | {toNumber(): number}},
     at: Date,
     addMass: number,
     removeMass = 0
-): number {
-    const events: {t: number; delta: number}[] = []
-    for (const ordered of sched.orderedTasks(entity)) {
+): CargomassProjection {
+    const events: {t: number; delta: number; candidate: boolean}[] = []
+    for (const ordered of sched.unappliedTasks(entity)) {
         const eff = taskCargoEffect(ordered.task)
         const delta = cargoListMass(eff.added) - cargoListMass(eff.removed)
-        events.push({t: ordered.completesAt.getTime(), delta})
+        events.push({t: ordered.completesAt.getTime(), delta, candidate: false})
     }
-    events.push({t: at.getTime(), delta: addMass - removeMass})
+    events.push({t: at.getTime(), delta: addMass - removeMass, candidate: true})
     events.sort((a, b) => (a.t !== b.t ? a.t - b.t : b.delta - a.delta))
     let running = Number(entity.cargomass)
     let peak = running
+    let used = running
     for (const e of events) {
         running += e.delta
         if (running < 0) running = 0
         if (running > peak) peak = running
+        if (e.candidate) used = running
     }
-    return Math.min(peak, 0xffff_ffff)
+    return {used: Math.min(used, 0xffff_ffff), peak: Math.min(peak, 0xffff_ffff)}
+}
+
+export function projectedPeakCargomass(
+    entity: sched.AnchoredScheduleData & {cargomass: number | {toNumber(): number}},
+    at: Date,
+    addMass: number,
+    removeMass = 0
+): number {
+    return projectCargomass(entity, at, addMass, removeMass).peak
 }
 
 export function receiveFits(

package/src/shipload.ts

@@ -15,6 +15,7 @@ import type {NftManager} from './managers/nft'
 import type {BalancesManager} from './managers/balances'
 import type {FundManager} from './managers/fund'
 import type {JobsManager} from './managers/jobs'
+import type {ShuttleManager} from './managers/shuttle'
 import type {InfluenceManager} from './managers/influence'
 import type {SubscriptionsManager} from './subscriptions/manager'
 import type {GameState} from './entities/gamestate'
@@ -23,6 +24,9 @@ interface ShiploadOptions {
     platformContractName?: string
     serverContractName?: string
     fundContractName?: string
+    platformContractAccount?: string
+    serverContractAccount?: string
+    fundContractAccount?: string
     client?: APIClient
     subscriptionsUrl?: string
     atomicAssetsAccount?: string
@@ -43,13 +47,24 @@ export class Shipload {
 
         const platform = platformContract
             ? platformContract
-            : new PlatformContract.Contract({client: apiClient})
+            : new PlatformContract.Contract({
+                  client: apiClient,
+                  account: constructorOptions?.platformContractAccount,
+              })
 
         const server = serverContract
             ? serverContract
-            : new ServerContract.Contract({client: apiClient})
-
-        const fund = fundContract ? fundContract : new FundContract.Contract({client: apiClient})
+            : new ServerContract.Contract({
+                  client: apiClient,
+                  account: constructorOptions?.serverContractAccount,
+              })
+
+        const fund = fundContract
+            ? fundContract
+            : new FundContract.Contract({
+                  client: apiClient,
+                  account: constructorOptions?.fundContractAccount,
+              })
 
         this._context = new GameContext(
             apiClient,
@@ -167,6 +182,10 @@ export class Shipload {
         return this._context.jobs
     }
 
+    get shuttle(): ShuttleManager {
+        return this._context.shuttle
+    }
+
     get influence(): InfluenceManager {
         return this._context.influence
     }

package/src/types.ts

@@ -208,6 +208,7 @@ export const CATEGORY_LABELS: Record<ResourceCategory, string> = {
 
 export interface Item {
     id: number
+    family: string
     name: string
     description: string
     color: string