@shipload/sdk 1.0.0-next.6 → 1.0.0-next.60

package/src/scheduling/schedule.test.ts

@@ -0,0 +1,119 @@
+import {describe, expect, test} from 'bun:test'
+import {ServerContract, TaskType} from '../index-module'
+import {hasPendingCapper, hasResolvable, isCapperTaskType} from './schedule'
+
+const T0 = '2026-06-19T00:00:00'
+const NOW = new Date('2026-06-19T00:01:00.000Z')
+
+function task(over: Partial<{type: number; duration: number}>) {
+    return ServerContract.Types.task.from({
+        type: over.type ?? TaskType.TRAVEL,
+        duration: over.duration ?? 30,
+        cancelable: 0,
+        cargo: [],
+        couplings: [],
+    })
+}
+
+function entity(
+    tasks: ReturnType<typeof task>[],
+    holds: ServerContract.Types.hold[] = [],
+    startedISO = T0
+) {
+    return ServerContract.Types.entity_info.from({
+        type: 'ship',
+        id: 1,
+        owner: 'player.gm',
+        entity_name: 'Ship 1',
+        coordinates: {x: 0, y: 0, z: 0},
+        item_id: 1,
+        cargomass: 0,
+        cargo: [],
+        modules: [],
+        lanes: [{lane_key: 0, schedule: {started: startedISO, tasks}}],
+        gatherer_lanes: [],
+        crafter_lanes: [],
+        builder_lanes: [],
+        loader_lanes: [],
+        holds,
+    })
+}
+
+function hold(kind: number) {
+    return ServerContract.Types.hold.from({
+        id: 1,
+        kind,
+        counterpart: {entity_type: 'ship', entity_id: 2},
+        until: T0,
+        incoming_mass: 0,
+    })
+}
+
+describe('isCapperTaskType', () => {
+    test('UNDEPLOY, DEMOLISH are cappers', () => {
+        expect(isCapperTaskType(TaskType.UNDEPLOY)).toBe(true)
+        expect(isCapperTaskType(TaskType.DEMOLISH)).toBe(true)
+    })
+
+    test('REFIT is not a capper', () => {
+        expect(isCapperTaskType(TaskType.REFIT)).toBe(false)
+    })
+
+    test('non-capper task types are not cappers', () => {
+        expect(isCapperTaskType(TaskType.TRAVEL)).toBe(false)
+        expect(isCapperTaskType(TaskType.LOAD)).toBe(false)
+    })
+})
+
+describe('hasPendingCapper', () => {
+    test('false with no schedule', () => {
+        expect(hasPendingCapper(entity([]))).toBe(false)
+    })
+
+    test('false with only non-capper tasks queued', () => {
+        expect(hasPendingCapper(entity([task({type: TaskType.TRAVEL})]))).toBe(false)
+    })
+
+    test('true when a DEMOLISH task is queued anywhere in the lane', () => {
+        const e = entity([task({type: TaskType.TRAVEL}), task({type: TaskType.DEMOLISH})])
+        expect(hasPendingCapper(e)).toBe(true)
+    })
+
+    test('true when a DEMOLISH task is queued', () => {
+        expect(hasPendingCapper(entity([task({type: TaskType.DEMOLISH})]))).toBe(true)
+    })
+})
+
+describe('hasResolvable — capper gating', () => {
+    test('a completed non-capper front is resolvable', () => {
+        const e = entity([task({type: TaskType.TRAVEL, duration: 30})])
+        expect(hasResolvable(e, NOW)).toBe(true)
+    })
+
+    test('a completed capper front with no holds is resolvable', () => {
+        const e = entity([task({type: TaskType.DEMOLISH, duration: 30})])
+        expect(hasResolvable(e, NOW)).toBe(true)
+    })
+
+    test('a completed capper front with a live hold is gated', () => {
+        const e = entity([task({type: TaskType.DEMOLISH, duration: 30})], [hold(2)])
+        expect(hasResolvable(e, NOW)).toBe(false)
+    })
+
+    test('a capper front clears once holds empty', () => {
+        const withHold = entity([task({type: TaskType.DEMOLISH, duration: 30})], [hold(2)])
+        const cleared = entity([task({type: TaskType.DEMOLISH, duration: 30})], [])
+        expect(hasResolvable(withHold, NOW)).toBe(false)
+        expect(hasResolvable(cleared, NOW)).toBe(true)
+    })
+
+    test('a live hold does not gate a non-capper front', () => {
+        const e = entity([task({type: TaskType.TRAVEL, duration: 30})], [hold(2)])
+        expect(hasResolvable(e, NOW)).toBe(true)
+    })
+
+    test('an in-progress front is not resolvable regardless of holds', () => {
+        const e = entity([task({type: TaskType.DEMOLISH, duration: 3600})])
+        expect(hasResolvable(e, NOW)).toBe(false)
+    })
+})

package/src/scheduling/schedule.ts

@@ -1,193 +1,333 @@
 import type {ServerContract} from '../contracts'
 import {TaskType} from '../types'
+import * as core from './lane-core'
 
 type Schedule = ServerContract.Types.schedule
 type Task = ServerContract.Types.task
+type Lane = ServerContract.Types.lane
+type Hold = ServerContract.Types.hold
+
+export const LANE_MOBILITY = 0
+export const LANE_BARRIER = 255
 
 export interface ScheduleData {
-    schedule?: Schedule
-}
-
-export interface Scheduleable extends ScheduleData {
-    hasSchedule: boolean
-    isIdle: boolean
-    tasks: Task[]
-    scheduleDuration(): number
-    scheduleElapsed(now: Date): number
-    scheduleRemaining(now: Date): number
-    scheduleComplete(now: Date): boolean
-    currentTaskIndex(now: Date): number
-    currentTask(now: Date): Task | undefined
-    currentTaskType(now: Date): TaskType | undefined
-    getTaskStartTime(index: number): number
-    getTaskElapsed(index: number, now: Date): number
-    getTaskRemaining(index: number, now: Date): number
-    isTaskComplete(index: number, now: Date): boolean
-    isTaskInProgress(index: number, now: Date): boolean
-    currentTaskProgress(now: Date): number
-    scheduleProgress(now: Date): number
+    lanes?: Lane[]
+    holds?: Hold[]
+}
+
+export interface LaneView {
+    laneKey: number
+    schedule: Schedule
+}
+
+export {
+    laneStartsIn,
+    currentTaskIndexForLane,
+    laneTaskComplete,
+    laneTaskInProgress,
+    laneCompletesAt,
+    currentTaskProgressFloatForLane,
+} from './lane-core'
+
+export function getLanes(entity: ScheduleData): LaneView[] {
+    const lanes = entity.lanes
+    if (!lanes || lanes.length === 0) return []
+    return lanes.map((l) => ({laneKey: l.lane_key.toNumber(), schedule: l.schedule}))
+}
+
+export function getLane(entity: ScheduleData, laneKey: number): LaneView | undefined {
+    const lanes = entity.lanes
+    if (!lanes) return undefined
+    for (const l of lanes) {
+        if (l.lane_key.toNumber() === laneKey) return {laneKey, schedule: l.schedule}
+    }
+    return undefined
+}
+
+export function mobilityLane(entity: ScheduleData): LaneView | undefined {
+    return getLane(entity, LANE_MOBILITY)
 }
 
 export function hasSchedule(entity: ScheduleData): boolean {
-    return !!entity.schedule && entity.schedule.tasks.length > 0
+    const lanes = entity.lanes
+    if (!lanes) return false
+    return lanes.some((l) => l.schedule.tasks.length > 0)
+}
+
+export function hasHolds(entity: ScheduleData): boolean {
+    const holds = entity.holds
+    return !!holds && holds.length > 0
 }
 
 export function isIdle(entity: ScheduleData): boolean {
-    return !hasSchedule(entity)
+    return !hasSchedule(entity) && !hasHolds(entity)
+}
+
+// Mirrors is_capper_task_type: demolish/undeploy cap a plan — no further appends once queued.
+export function isCapperTaskType(taskType: number): boolean {
+    return taskType === TaskType.UNDEPLOY || taskType === TaskType.DEMOLISH
+}
+
+export function hasPendingCapper(entity: ScheduleData): boolean {
+    for (const l of entity.lanes ?? []) {
+        for (const t of l.schedule.tasks) {
+            if (isCapperTaskType(t.type.toNumber())) return true
+        }
+    }
+    return false
+}
+
+export function isEntityIdle(entity: ScheduleData, now: Date): boolean {
+    if (hasHolds(entity)) return false
+    const lanes = entity.lanes
+    if (!lanes) return true
+    return lanes.every((l) => core.currentTaskIndexForLane(l.schedule, now) < 0)
+}
+
+export function entityIdleAt(entity: ScheduleData, _now: Date): Date | undefined {
+    const lanes = entity.lanes
+    if (!lanes) return undefined
+    let maxMs: number | undefined
+    for (const l of lanes) {
+        if (l.schedule.tasks.length === 0) continue
+        const endMs = l.schedule.started.toDate().getTime() + core.laneDuration(l.schedule) * 1000
+        if (maxMs === undefined || endMs > maxMs) maxMs = endMs
+    }
+    return maxMs === undefined ? undefined : new Date(maxMs)
 }
 
 export function getTasks(entity: ScheduleData): Task[] {
-    return entity.schedule?.tasks || []
+    const lanes = entity.lanes
+    if (!lanes) return []
+    return lanes.flatMap((l) => l.schedule.tasks)
 }
 
 export function scheduleDuration(entity: ScheduleData): number {
-    if (!entity.schedule) return 0
-    return entity.schedule.tasks.reduce((sum, task) => sum + task.duration.toNumber(), 0)
+    let max = 0
+    for (const l of entity.lanes ?? []) max = Math.max(max, core.laneDuration(l.schedule))
+    return max
 }
 
 export function scheduleElapsed(entity: ScheduleData, now: Date): number {
-    if (!entity.schedule) return 0
-    const started = entity.schedule.started.toDate()
-    const elapsed = Math.floor((now.getTime() - started.getTime()) / 1000)
-    return Math.max(0, elapsed)
+    let max = 0
+    for (const l of entity.lanes ?? []) max = Math.max(max, core.laneElapsed(l.schedule, now))
+    return max
 }
 
 export function scheduleRemaining(entity: ScheduleData, now: Date): number {
-    if (!entity.schedule) return 0
-    const duration = scheduleDuration(entity)
-    const elapsed = scheduleElapsed(entity, now)
-    return Math.max(0, duration - elapsed)
+    let remaining = 0
+    for (const l of entity.lanes ?? []) {
+        remaining = Math.max(remaining, core.laneRemaining(l.schedule, now))
+    }
+    return remaining
 }
 
 export function scheduleComplete(entity: ScheduleData, now: Date): boolean {
-    return hasSchedule(entity) && scheduleRemaining(entity, now) === 0
+    const lanes = entity.lanes
+    if (!lanes) return false
+    let hasAnyTask = false
+    let remaining = 0
+    for (const l of lanes) {
+        if (l.schedule.tasks.length > 0) hasAnyTask = true
+        remaining = Math.max(remaining, core.laneRemaining(l.schedule, now))
+    }
+    if (!hasAnyTask) return false
+    return remaining === 0
 }
 
-export function currentTaskIndex(entity: ScheduleData, now: Date): number {
-    if (!entity.schedule || entity.schedule.tasks.length === 0) return -1
-
-    const elapsed = scheduleElapsed(entity, now)
-    let timeAccum = 0
-
-    for (let i = 0; i < entity.schedule.tasks.length; i++) {
-        const taskDuration = entity.schedule.tasks[i].duration.toNumber()
-        if (elapsed < timeAccum + taskDuration) {
-            return i
-        }
-        timeAccum += taskDuration
+// Mirrors lane_front_complete && !capper_front_gated for own-entity holds (workshop/undeploy-target gates need cross-entity context this ScheduleData lacks).
+export function hasResolvable(entity: ScheduleData, now: Date): boolean {
+    for (const l of entity.lanes ?? []) {
+        if (!core.laneTaskComplete(l.schedule, 0, now)) continue
+        const front = l.schedule.tasks[0]
+        if (isCapperTaskType(front.type.toNumber()) && hasHolds(entity)) continue
+        return true
     }
+    return false
+}
+
+export function currentTaskForLane(
+    entity: ScheduleData,
+    laneKey: number,
+    now: Date
+): Task | undefined {
+    const lane = getLane(entity, laneKey)
+    return lane ? core.currentTask(lane.schedule, now) : undefined
+}
 
-    return -1
+export function currentTaskTypeForLane(
+    entity: ScheduleData,
+    laneKey: number,
+    now: Date
+): TaskType | undefined {
+    const lane = getLane(entity, laneKey)
+    return lane ? core.currentTaskType(lane.schedule, now) : undefined
 }
 
-export function currentTask(entity: ScheduleData, now: Date): Task | undefined {
-    const index = currentTaskIndex(entity, now)
-    if (index < 0 || !entity.schedule) return undefined
-    return entity.schedule.tasks[index]
+export function activeTasks(entity: ScheduleData, now: Date): Task[] {
+    const out: Task[] = []
+    for (const l of entity.lanes ?? []) {
+        const idx = core.currentTaskIndexForLane(l.schedule, now)
+        if (idx >= 0) out.push(l.schedule.tasks[idx])
+    }
+    return out
 }
 
-export function currentTaskType(entity: ScheduleData, now: Date): TaskType | undefined {
-    const task = currentTask(entity, now)
-    if (!task) return undefined
-    return task.type.toNumber() as TaskType
+export interface ResolvedEvent {
+    laneKey: number
+    taskIndex: number
+    task: Task
+    completesAt: Date
 }
 
-export function getTaskStartTime(entity: ScheduleData, index: number): number {
-    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length) return 0
-    let timeAccum = 0
-    for (let i = 0; i < index; i++) {
-        timeAccum += entity.schedule.tasks[i].duration.toNumber()
+// Canonical lane-front order (mirrors contract front_precedes): completion, then RECHARGE-last, then lane key.
+function frontPrecedes(
+    a: {completesAt: Date; task: Task; laneKey: number},
+    b: {completesAt: Date; task: Task; laneKey: number}
+): number {
+    if (a.completesAt.getTime() !== b.completesAt.getTime()) {
+        return a.completesAt.getTime() - b.completesAt.getTime()
     }
-    return timeAccum
+    const aRecharge = a.task.type.toNumber() === TaskType.RECHARGE
+    const bRecharge = b.task.type.toNumber() === TaskType.RECHARGE
+    if (aRecharge !== bRecharge) return aRecharge ? 1 : -1
+    return a.laneKey - b.laneKey
 }
 
-export function getTaskElapsed(entity: ScheduleData, index: number, now: Date): number {
-    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length) return 0
+// Completed lane-fronts in canonical order (mirrors contract front_precedes).
+export function resolveOrder(entity: ScheduleData, now: Date): ResolvedEvent[] {
+    const events: ResolvedEvent[] = []
+    for (const l of entity.lanes ?? []) {
+        const laneKey = l.lane_key.toNumber()
+        const startedMs = l.schedule.started.toDate().getTime()
+        let endSec = 0
+        for (let i = 0; i < l.schedule.tasks.length; i++) {
+            const task = l.schedule.tasks[i]
+            endSec += task.duration.toNumber()
+            const completesAt = new Date(startedMs + endSec * 1000)
+            if (completesAt.getTime() > now.getTime()) break
+            events.push({laneKey, taskIndex: i, task, completesAt})
+        }
+    }
+    events.sort(frontPrecedes)
+    return events
+}
 
-    const elapsed = scheduleElapsed(entity, now)
-    const taskStart = getTaskStartTime(entity, index)
-    const taskDuration = entity.schedule.tasks[index].duration.toNumber()
+export interface OrderedTask {
+    laneKey: number
+    taskIndex: number
+    task: Task
+    startsAt: Date
+    completesAt: Date
+}
 
-    if (elapsed <= taskStart) return 0
-    const elapsedInTask = elapsed - taskStart
-    return Math.min(elapsedInTask, taskDuration)
+// Every task across all lanes in canonical order (mirrors contract front_precedes).
+export function orderedTasks(entity: ScheduleData): OrderedTask[] {
+    const out: OrderedTask[] = []
+    for (const l of entity.lanes ?? []) {
+        const laneKey = l.lane_key.toNumber()
+        const startedMs = l.schedule.started.toDate().getTime()
+        let endSec = 0
+        for (let i = 0; i < l.schedule.tasks.length; i++) {
+            const task = l.schedule.tasks[i]
+            const startsAt = new Date(startedMs + endSec * 1000)
+            endSec += task.duration.toNumber()
+            const completesAt = new Date(startedMs + endSec * 1000)
+            out.push({laneKey, taskIndex: i, task, startsAt, completesAt})
+        }
+    }
+    out.sort(frontPrecedes)
+    return out
 }
 
-export function getTaskRemaining(entity: ScheduleData, index: number, now: Date): number {
-    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length) return 0
+export function laneRemainingOf(entity: ScheduleData, laneKey: number, now: Date): number {
+    const lane = getLane(entity, laneKey)
+    return lane ? core.laneRemaining(lane.schedule, now) : 0
+}
 
-    const taskDuration = entity.schedule.tasks[index].duration.toNumber()
-    const taskElapsed = getTaskElapsed(entity, index, now)
-    return Math.max(0, taskDuration - taskElapsed)
+export function laneStartsInOf(entity: ScheduleData, laneKey: number, now: Date): number {
+    const lane = getLane(entity, laneKey)
+    return lane ? core.laneStartsIn(lane.schedule, now) : 0
 }
 
-export function isTaskComplete(entity: ScheduleData, index: number, now: Date): boolean {
-    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length) return false
+export function laneCompleteOf(entity: ScheduleData, laneKey: number, now: Date): boolean {
+    const lane = getLane(entity, laneKey)
+    return lane ? core.laneComplete(lane.schedule, now) : false
+}
 
-    const taskDuration = entity.schedule.tasks[index].duration.toNumber()
-    const taskElapsed = getTaskElapsed(entity, index, now)
-    return taskElapsed >= taskDuration
+export function laneProgressOf(entity: ScheduleData, laneKey: number, now: Date): number {
+    const lane = getLane(entity, laneKey)
+    return lane ? core.laneProgress(lane.schedule, now) : 0
 }
 
-export function isTaskInProgress(entity: ScheduleData, index: number, now: Date): boolean {
-    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length) return false
+export function laneTaskElapsedOf(
+    entity: ScheduleData,
+    laneKey: number,
+    index: number,
+    now: Date
+): number {
+    const lane = getLane(entity, laneKey)
+    return lane ? core.laneTaskElapsed(lane.schedule, index, now) : 0
+}
 
-    const taskElapsed = getTaskElapsed(entity, index, now)
-    const taskDuration = entity.schedule.tasks[index].duration.toNumber()
-    return taskElapsed > 0 && taskElapsed < taskDuration
+export function laneTaskRemainingOf(
+    entity: ScheduleData,
+    laneKey: number,
+    index: number,
+    now: Date
+): number {
+    const lane = getLane(entity, laneKey)
+    return lane ? core.laneTaskRemaining(lane.schedule, index, now) : 0
 }
 
-export function currentTaskProgress(entity: ScheduleData, now: Date): number {
-    const task = currentTask(entity, now)
-    if (!task) return 0
-    const index = currentTaskIndex(entity, now)
-    const elapsed = getTaskElapsed(entity, index, now)
-    const duration = task.duration.toNumber()
-    if (duration === 0) return 1
-    return Math.min(1, elapsed / duration)
+export function laneTaskCompleteOf(
+    entity: ScheduleData,
+    laneKey: number,
+    index: number,
+    now: Date
+): boolean {
+    const lane = getLane(entity, laneKey)
+    return lane ? core.laneTaskComplete(lane.schedule, index, now) : false
 }
 
-export function currentTaskProgressFloat(entity: ScheduleData, now: Date): number {
-    if (!entity.schedule || entity.schedule.tasks.length === 0) return 0
-    const index = currentTaskIndex(entity, now)
-    if (index < 0) return 0
-    const task = entity.schedule.tasks[index]
-    const durationMs = task.duration.toNumber() * 1000
-    if (durationMs === 0) return 1
-    const startedMs = entity.schedule.started.toDate().getTime()
-    const taskStartMs = startedMs + getTaskStartTime(entity, index) * 1000
-    const elapsedMs = now.getTime() - taskStartMs
-    if (elapsedMs <= 0) return 0
-    return Math.min(1, elapsedMs / durationMs)
+export function laneTaskInProgressOf(
+    entity: ScheduleData,
+    laneKey: number,
+    index: number,
+    now: Date
+): boolean {
+    const lane = getLane(entity, laneKey)
+    return lane ? core.laneTaskInProgress(lane.schedule, index, now) : false
 }
 
-export function scheduleProgress(entity: ScheduleData, now: Date): number {
-    const duration = scheduleDuration(entity)
-    if (duration === 0) return hasSchedule(entity) ? 1 : 0
-    const elapsed = scheduleElapsed(entity, now)
-    return Math.min(1, elapsed / duration)
+export function currentTaskIndexOf(entity: ScheduleData, laneKey: number, now: Date): number {
+    const lane = getLane(entity, laneKey)
+    return lane ? core.currentTaskIndexForLane(lane.schedule, now) : -1
 }
 
-export function isTaskType(entity: ScheduleData, taskType: TaskType, now: Date): boolean {
-    return currentTaskType(entity, now) === taskType
+function entityDoesTaskType(entity: ScheduleData, taskType: TaskType, now: Date): boolean {
+    return activeTasks(entity, now).some((t) => t.type.toNumber() === taskType)
 }
 
 export function isInFlight(entity: ScheduleData, now: Date): boolean {
-    return isTaskType(entity, TaskType.TRAVEL, now)
+    const lane = mobilityLane(entity)
+    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 {
-    return isTaskType(entity, TaskType.RECHARGE, now)
+    return entityDoesTaskType(entity, TaskType.RECHARGE, now)
 }
 
 export function isLoading(entity: ScheduleData, now: Date): boolean {
-    return isTaskType(entity, TaskType.LOAD, now)
+    return entityDoesTaskType(entity, TaskType.LOAD, now)
 }
 
 export function isUnloading(entity: ScheduleData, now: Date): boolean {
-    return isTaskType(entity, TaskType.UNLOAD, now)
+    return entityDoesTaskType(entity, TaskType.UNLOAD, now)
 }
 
 export function isGathering(entity: ScheduleData, now: Date): boolean {
-    return isTaskType(entity, TaskType.GATHER, now)
+    return entityDoesTaskType(entity, TaskType.GATHER, now)
 }

package/src/scheduling/task-cargo.test.ts

@@ -0,0 +1,44 @@
+import {describe, expect, test} from 'bun:test'
+import {ServerContract, TaskType} from '../index-module'
+import {taskCargoChanges} from './task-cargo'
+
+function cargoItem(itemId: number, quantity: number) {
+    return ServerContract.Types.cargo_item.from({item_id: itemId, stats: 0, modules: [], quantity})
+}
+
+function craftTask(couplings: ReturnType<typeof coupling>[]) {
+    return ServerContract.Types.task.from({
+        type: TaskType.CRAFT,
+        duration: 60,
+        cancelable: 0,
+        cargo: [cargoItem(401, 19680), cargoItem(10008, 1968)],
+        couplings,
+    })
+}
+
+function coupling() {
+    return ServerContract.Types.coupling.from({
+        counterpart: {entity_type: 'warehouse', entity_id: 51},
+        hold: 1,
+        kind: 3,
+    })
+}
+
+describe('taskCargoChanges', () => {
+    test('a self-craft consumes inputs and delivers the output to the crafter', () => {
+        const changes = taskCargoChanges(craftTask([]))
+
+        expect(changes).toEqual([
+            {direction: 'out', item_id: 401, stats: 0n, modules: [], quantity: 19680},
+            {direction: 'in', item_id: 10008, stats: 0n, modules: [], quantity: 1968},
+        ])
+    })
+
+    test('a coupled craft consumes inputs but does not deliver the output to the crafter', () => {
+        const changes = taskCargoChanges(craftTask([coupling()]))
+
+        expect(changes).toEqual([
+            {direction: 'out', item_id: 401, stats: 0n, modules: [], quantity: 19680},
+        ])
+    })
+})

package/src/scheduling/task-cargo.ts

@@ -0,0 +1,46 @@
+import type {ServerContract} from '../contracts'
+import {TaskType} from '../types'
+
+export type TaskCargoDirection = 'in' | 'out'
+
+export interface TaskCargoChange {
+    direction: TaskCargoDirection
+    item_id: number
+    stats: bigint
+    modules: ServerContract.Types.module_entry[]
+    quantity: number
+}
+
+function toChange(
+    item: ServerContract.Types.cargo_item,
+    direction: TaskCargoDirection
+): TaskCargoChange {
+    return {
+        direction,
+        item_id: Number(item.item_id),
+        stats: BigInt(item.stats.toString()),
+        modules: item.modules ?? [],
+        quantity: Number(item.quantity),
+    }
+}
+
+export function taskCargoChanges(task: ServerContract.Types.task): TaskCargoChange[] {
+    const items = task.cargo ?? []
+    if (items.length === 0) return []
+    switch (Number(task.type)) {
+        case TaskType.LOAD:
+        case TaskType.UNWRAP:
+            return items.map((i) => toChange(i, 'in'))
+        case TaskType.GATHER:
+            return task.couplings.length > 0 ? [] : items.map((i) => toChange(i, 'in'))
+        case TaskType.UNLOAD:
+            return items.map((i) => toChange(i, 'out'))
+        case TaskType.CRAFT:
+            return [
+                ...items.slice(0, -1).map((i) => toChange(i, 'out')),
+                ...(task.couplings.length > 0 ? [] : [toChange(items[items.length - 1], 'in')]),
+            ]
+        default:
+            return []
+    }
+}