@shipload/sdk 1.0.0-next.56 → 1.0.0-next.59

package/src/scheduling/availability.test.ts

@@ -0,0 +1,157 @@
+import {describe, expect, test} from 'bun:test'
+import {HoldKind, ServerContract, TaskType} from '../index-module'
+import {
+    calcCounterpartDelivery,
+    cargoReadyAt,
+    type CargoInput,
+    type IncomingSource,
+    projectedCargoAvailableAt,
+} from './availability'
+
+const T0 = '2026-06-19T00:00:00'
+const EPOCH = new Date(0)
+
+function cargoItem(itemId: number, stats: number, quantity: number) {
+    return ServerContract.Types.cargo_item.from({item_id: itemId, stats, modules: [], quantity})
+}
+
+function task(over: {type?: number; duration?: number; cargo?: ReturnType<typeof cargoItem>[]}) {
+    return ServerContract.Types.task.from({
+        type: over.type ?? TaskType.LOAD,
+        duration: over.duration ?? 60,
+        cancelable: 0,
+        cargo: over.cargo ?? [],
+        couplings: [],
+    })
+}
+
+function coupling(kind: number) {
+    return ServerContract.Types.coupling.from({
+        counterpart: {entity_type: 'ship', entity_id: 2},
+        hold: 1,
+        kind,
+    })
+}
+
+function entity(
+    cargo: ReturnType<typeof cargoItem>[],
+    tasks: ReturnType<typeof task>[] = [],
+    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: cargo.map((c) => ({
+            item_id: c.item_id,
+            stats: c.stats,
+            modules: c.modules,
+            quantity: c.quantity,
+            id: 0,
+        })),
+        modules: [],
+        lanes: [{lane_key: 0, schedule: {started: startedISO, tasks}}],
+        gatherer_lanes: [],
+        crafter_lanes: [],
+        builder_lanes: [],
+        loader_lanes: [],
+        holds: [],
+    })
+}
+
+describe('cargoReadyAt', () => {
+    test('on-hand covers demand → epoch', () => {
+        const e = entity([cargoItem(7, 0, 10)])
+        const demand: CargoInput[] = [{itemId: 7, stats: 0n, quantity: 5}]
+        expect(cargoReadyAt(e, demand)).toEqual(EPOCH)
+    })
+
+    test('own-lane LOAD covers demand → its completion', () => {
+        const loadCompletesAt = new Date('2026-06-19T00:01:00.000Z')
+        const e = entity(
+            [],
+            [task({type: TaskType.LOAD, duration: 60, cargo: [cargoItem(7, 0, 10)]})]
+        )
+        const demand: CargoInput[] = [{itemId: 7, stats: 0n, quantity: 5}]
+        expect(cargoReadyAt(e, demand)).toEqual(loadCompletesAt)
+    })
+
+    test('incoming source covers demand → its until', () => {
+        const until = new Date('2026-06-19T00:00:30.000Z')
+        const e = entity([])
+        const incoming: IncomingSource[] = [{holdId: '1', until, items: [cargoItem(7, 0, 10)]}]
+        const demand: CargoInput[] = [{itemId: 7, stats: 0n, quantity: 5}]
+        expect(cargoReadyAt(e, demand, incoming)).toEqual(until)
+    })
+
+    test('on-hand covers demand; unrelated same-item different-stats inflow does not delay readiness', () => {
+        const laterCompletesAt = new Date('2026-06-19T00:01:00.000Z')
+        const e = entity(
+            [cargoItem(7, 0, 10)],
+            [task({type: TaskType.LOAD, duration: 60, cargo: [cargoItem(7, 99, 10)]})]
+        )
+        const demand: CargoInput[] = [{itemId: 7, stats: 0n, quantity: 5}]
+        const result = cargoReadyAt(e, demand)
+        expect(result).toEqual(EPOCH)
+        expect(result).not.toEqual(laterCompletesAt)
+    })
+})
+
+describe('calcCounterpartDelivery', () => {
+    test('coupled CRAFT task returns output cargo only', () => {
+        const output = cargoItem(9, 0, 1)
+        const t = task({
+            type: TaskType.CRAFT,
+            cargo: [cargoItem(7, 0, 2), cargoItem(8, 0, 1), output],
+        })
+        const result = calcCounterpartDelivery(t, coupling(HoldKind.PUSH))
+        expect(result.length).toBe(1)
+        expect(result[0].item_id.toNumber()).toBe(9)
+    })
+
+    test('CRAFT task with empty cargo returns []', () => {
+        const t = task({type: TaskType.CRAFT, cargo: []})
+        expect(calcCounterpartDelivery(t, coupling(HoldKind.PUSH))).toEqual([])
+    })
+
+    test('coupled UNLOAD task returns whole cargo', () => {
+        const t = task({type: TaskType.UNLOAD, cargo: [cargoItem(7, 0, 2), cargoItem(8, 0, 1)]})
+        const result = calcCounterpartDelivery(t, coupling(HoldKind.GATHER))
+        expect(result.length).toBe(2)
+    })
+
+    test('non-incoming coupling kind returns []', () => {
+        const t = task({type: TaskType.UNLOAD, cargo: [cargoItem(7, 0, 2)]})
+        expect(calcCounterpartDelivery(t, coupling(HoldKind.PULL))).toEqual([])
+    })
+})
+
+describe('projectedCargoAvailableAt — incoming', () => {
+    const until = new Date('2026-06-19T00:00:30.000Z')
+
+    function incomingFor(qty: number): IncomingSource[] {
+        return [{holdId: '1', until, items: [cargoItem(7, 0, qty)]}]
+    }
+
+    test('credits an incoming source strictly before its until', () => {
+        const e = entity([])
+        const avail = projectedCargoAvailableAt(e, new Date(until.getTime() + 1), incomingFor(10))
+        expect(avail.get('7:0')).toBe(10n)
+    })
+
+    test('does not credit an incoming source at exactly its until', () => {
+        const e = entity([])
+        const avail = projectedCargoAvailableAt(e, until, incomingFor(10))
+        expect(avail.get('7:0') ?? 0n).toBe(0n)
+    })
+
+    test('does not credit an incoming source before its until', () => {
+        const e = entity([])
+        const avail = projectedCargoAvailableAt(e, new Date(until.getTime() - 1), incomingFor(10))
+        expect(avail.get('7:0') ?? 0n).toBe(0n)
+    })
+})

package/src/scheduling/availability.ts

@@ -1,9 +1,11 @@
 import type {ServerContract} from '../contracts'
-import {TaskType} from '../types'
+import {HoldKind, TaskType} from '../types'
 import * as schedule from './schedule'
 
 type Task = ServerContract.Types.task
+type Coupling = ServerContract.Types.coupling
 type CargoItem = ServerContract.Types.cargo_item
+type ModuleEntry = ServerContract.Types.module_entry
 
 export interface CargoEffect {
     added: CargoItem[]
@@ -14,6 +16,35 @@ export interface AvailabilityInput extends schedule.ScheduleData {
     cargo: CargoItem[]
 }
 
+export interface CargoInput {
+    itemId: number
+    stats: bigint
+    modules?: ModuleEntry[]
+    quantity: number
+}
+
+export interface IncomingSource {
+    holdId: string
+    until: Date
+    items: CargoItem[]
+}
+
+const INCOMING_COUPLING_KINDS = new Set<number>([HoldKind.PUSH, HoldKind.GATHER, HoldKind.FLIGHT])
+
+// Mirrors is_incoming_hold_kind: PUSH/GATHER/FLIGHT couplings deliver to the counterpart.
+export function isIncomingCouplingKind(kind: number): boolean {
+    return INCOMING_COUPLING_KINDS.has(kind)
+}
+
+// Mirrors calc_counterpart_delivery: incoming-kind couplings only; a coupled CRAFT yields its output slot.
+export function calcCounterpartDelivery(task: Task, coupling: Coupling): CargoItem[] {
+    if (!isIncomingCouplingKind(coupling.kind.toNumber())) return []
+    if (task.type.toNumber() === TaskType.CRAFT) {
+        return task.cargo.length === 0 ? [] : [task.cargo[task.cargo.length - 1]]
+    }
+    return task.cargo
+}
+
 export function taskCargoEffect(task: Task): CargoEffect {
     switch (task.type.toNumber()) {
         case TaskType.LOAD:
@@ -21,6 +52,7 @@ export function taskCargoEffect(task: Task): CargoEffect {
         case TaskType.UNDEPLOY:
             return {added: task.cargo, removed: []}
         case TaskType.UNLOAD:
+        case TaskType.UPGRADE:
             return {added: [], removed: task.cargo}
         case TaskType.GATHER:
             return task.couplings.length > 0
@@ -37,22 +69,34 @@ export function taskCargoEffect(task: Task): CargoEffect {
     }
 }
 
-export function cargoKey(item: CargoItem): string {
-    const base = `${item.item_id.toNumber()}:${item.stats.toString()}`
-    const modules = item.modules ?? []
-    const entityId = item.entity_id?.toString()
-    const normalizedEntityId = entityId && entityId !== '0' ? entityId : ''
+function refKey(itemId: number, stats: bigint, modules: ModuleEntry[], entityId: string): string {
+    const base = `${itemId}:${stats.toString()}`
+    const normalizedEntityId = entityId !== '0' ? entityId : ''
     if (modules.length === 0 && normalizedEntityId === '') return base
     return `${base}:modules=${JSON.stringify(modules)}:entity=${normalizedEntityId}`
 }
 
+export function cargoKey(item: CargoItem): string {
+    return refKey(
+        item.item_id.toNumber(),
+        BigInt(item.stats.toString()),
+        item.modules ?? [],
+        item.entity_id?.toString() ?? ''
+    )
+}
+
+export function cargoInputKey(input: CargoInput): string {
+    return refKey(input.itemId, input.stats, input.modules ?? [], '')
+}
+
 function cargoQuantity(item: CargoItem): bigint {
     return BigInt(item.quantity.toString())
 }
 
 export function projectedCargoAvailableAt(
     entity: AvailabilityInput,
-    at: Date
+    at: Date,
+    incoming: readonly IncomingSource[] = []
 ): Map<string, bigint> {
     const avail = new Map<string, bigint>()
 
@@ -73,6 +117,14 @@ export function projectedCargoAvailableAt(
         }
     }
 
+    for (const src of incoming) {
+        if (src.until.getTime() >= at.getTime()) continue
+        for (const item of src.items) {
+            const key = cargoKey(item)
+            avail.set(key, (avail.get(key) ?? 0n) + cargoQuantity(item))
+        }
+    }
+
     for (const ordered of tasks) {
         for (const item of taskCargoEffect(ordered.task).removed) {
             const key = cargoKey(item)
@@ -85,18 +137,47 @@ export function projectedCargoAvailableAt(
     return avail
 }
 
-// Latest completion among scheduled tasks producing any of the given inputs (a craft starts no earlier).
-export function cargoReadyAt(entity: AvailabilityInput, inputItemIds: readonly number[]): Date {
-    let readyMs = 0
+// Earliest-sufficient candidate (epoch, own-lane producer completions, incoming untils); else the latest candidate.
+export function cargoReadyAt(
+    entity: AvailabilityInput,
+    inputs: readonly CargoInput[],
+    incoming: readonly IncomingSource[] = []
+): Date {
+    const demand = new Map<string, bigint>()
+    for (const input of inputs) {
+        const key = cargoInputKey(input)
+        demand.set(key, (demand.get(key) ?? 0n) + BigInt(input.quantity))
+    }
+
+    const candidates: number[] = [0]
     for (const ordered of schedule.orderedTasks(entity)) {
         for (const item of taskCargoEffect(ordered.task).added) {
-            if (inputItemIds.includes(item.item_id.toNumber())) {
-                readyMs = Math.max(readyMs, ordered.completesAt.getTime())
+            if (demand.has(cargoKey(item))) {
+                candidates.push(ordered.completesAt.getTime())
+                break
+            }
+        }
+    }
+    for (const src of incoming) {
+        if (src.items.some((item) => demand.has(cargoKey(item)))) {
+            candidates.push(src.until.getTime())
+        }
+    }
+    candidates.sort((a, b) => a - b)
+
+    for (const candidateMs of candidates) {
+        // +1ms mirrors the contract's candidate+1µs probe: inclusive at the candidate instant.
+        const available = projectedCargoAvailableAt(entity, new Date(candidateMs + 1), incoming)
+        let sufficient = true
+        for (const [key, quantity] of demand) {
+            if ((available.get(key) ?? 0n) < quantity) {
+                sufficient = false
                 break
             }
         }
+        if (sufficient) return new Date(candidateMs)
     }
-    return new Date(readyMs)
+    return new Date(candidates[candidates.length - 1])
 }
 
 export function availableForItem(avail: Map<string, bigint>, itemId: number): bigint {

package/src/scheduling/cancel.test.ts

@@ -1,6 +1,7 @@
 import {describe, expect, test} from 'bun:test'
-import {ServerContract, TaskType, TaskCancelable} from '../index-module'
+import {ServerContract, TaskType, TaskCancelable, HoldKind} from '../index-module'
 import {cancelEligibility, CancelBlockReason} from './cancel'
+import type {IncomingSource} from './availability'
 
 const T0 = '2026-06-19T00:00:00'
 
@@ -380,3 +381,162 @@ describe('cancelEligibility — feasibility', () => {
         )
     })
 })
+
+describe('cancelEligibility — cross-entity strand (counterpart queued consumer)', () => {
+    const upcoming = new Date('2026-06-18T23:59:50.000Z')
+
+    function entityWithId(
+        id: number,
+        tasks: ReturnType<typeof ServerContract.Types.task.from>[],
+        cargo: {
+            id: number
+            item_id: number
+            stats: number
+            modules: never[]
+            quantity: number
+        }[] = []
+    ) {
+        return ServerContract.Types.entity_info.from({
+            type: 'ship',
+            id,
+            owner: 'player.gm',
+            entity_name: `Ship ${id}`,
+            coordinates: {x: 0, y: 0, z: 0},
+            item_id: 1,
+            cargomass: 0,
+            cargo,
+            modules: [],
+            lanes: [{lane_key: 0, schedule: {started: T0, tasks}}],
+            gatherer_lanes: [],
+            crafter_lanes: [],
+            builder_lanes: [],
+            loader_lanes: [],
+            holds: [],
+        })
+    }
+
+    function pushTask() {
+        return ServerContract.Types.task.from({
+            type: TaskType.UNLOAD,
+            duration: 50,
+            cancelable: TaskCancelable.ALWAYS,
+            cargo: [{item_id: 7, stats: 0, modules: [], quantity: 2}],
+            couplings: [
+                {counterpart: {entity_type: 'ship', entity_id: 2}, hold: 1, kind: HoldKind.PUSH},
+            ],
+        })
+    }
+
+    function craftConsumerTask() {
+        return ServerContract.Types.task.from({
+            type: TaskType.CRAFT,
+            duration: 100,
+            cancelable: TaskCancelable.ALWAYS,
+            cargo: [
+                {item_id: 7, stats: 0, modules: [], quantity: 2},
+                {item_id: 9, stats: 0, modules: [], quantity: 1},
+            ],
+            couplings: [],
+        })
+    }
+
+    function incoming(): IncomingSource[] {
+        return [
+            {
+                holdId: '1',
+                until: new Date('2026-06-19T00:00:50.000Z'),
+                items: [
+                    ServerContract.Types.cargo_item.from({
+                        item_id: 7,
+                        stats: 0,
+                        modules: [],
+                        quantity: 2,
+                    }),
+                ],
+            },
+        ]
+    }
+
+    function upgradeConsumerTask() {
+        return ServerContract.Types.task.from({
+            type: TaskType.UPGRADE,
+            duration: 100,
+            cancelable: TaskCancelable.ALWAYS,
+            cargo: [{item_id: 7, stats: 0, modules: [], quantity: 2}],
+            couplings: [],
+        })
+    }
+
+    test('blocked: counterpart consumer loses coverage without this delivery', () => {
+        const producer = entityWithId(1, [pushTask()])
+        const counterpart = entityWithId(2, [craftConsumerTask()])
+        const plan = cancelEligibility(producer, 0, 0, {
+            now: upcoming,
+            counterparts: new Map([['2', counterpart]]),
+            counterpartIncoming: new Map([['2', incoming()]]),
+        })
+        expect(plan.ok).toBe(false)
+        expect(plan.blockedReason).toBe(CancelBlockReason.WOULD_STRAND_COUNTERPART)
+        expect(plan.blockedByCounterpart?.entity_id.toNumber()).toBe(2)
+    })
+
+    test('blocked: counterpart upgrade consumer loses coverage without this delivery', () => {
+        const producer = entityWithId(1, [pushTask()])
+        const counterpart = entityWithId(2, [upgradeConsumerTask()])
+        const plan = cancelEligibility(producer, 0, 0, {
+            now: upcoming,
+            counterparts: new Map([['2', counterpart]]),
+            counterpartIncoming: new Map([['2', incoming()]]),
+        })
+        expect(plan.ok).toBe(false)
+        expect(plan.blockedReason).toBe(CancelBlockReason.WOULD_STRAND_COUNTERPART)
+        expect(plan.blockedByCounterpart?.entity_id.toNumber()).toBe(2)
+    })
+
+    test('allowed: counterpart upgrade consumer already covered on-hand', () => {
+        const producer = entityWithId(1, [pushTask()])
+        const counterpart = entityWithId(
+            2,
+            [upgradeConsumerTask()],
+            [{id: 1, item_id: 7, stats: 0, modules: [], quantity: 2}]
+        )
+        const plan = cancelEligibility(producer, 0, 0, {
+            now: upcoming,
+            counterparts: new Map([['2', counterpart]]),
+            counterpartIncoming: new Map([['2', incoming()]]),
+        })
+        expect(plan.ok).toBe(true)
+    })
+
+    test('allowed: counterpart consumer already covered on-hand (surplus coverage)', () => {
+        const producer = entityWithId(1, [pushTask()])
+        const counterpart = entityWithId(
+            2,
+            [craftConsumerTask()],
+            [{id: 1, item_id: 7, stats: 0, modules: [], quantity: 2}]
+        )
+        const plan = cancelEligibility(producer, 0, 0, {
+            now: upcoming,
+            counterparts: new Map([['2', counterpart]]),
+            counterpartIncoming: new Map([['2', incoming()]]),
+        })
+        expect(plan.ok).toBe(true)
+    })
+
+    test('allowed: counterpart data not loaded, check skipped gracefully', () => {
+        const producer = entityWithId(1, [pushTask()])
+        const plan = cancelEligibility(producer, 0, 0, {now: upcoming})
+        expect(plan.ok).toBe(true)
+    })
+
+    test('allowed: counterpart has no queued consumer', () => {
+        const producer = entityWithId(1, [pushTask()])
+        const idleCounterpart = entityWithId(2, [])
+        const plan = cancelEligibility(producer, 0, 0, {
+            now: upcoming,
+            counterparts: new Map([['2', idleCounterpart]]),
+            counterpartIncoming: new Map([['2', incoming()]]),
+        })
+        expect(plan.ok).toBe(true)
+    })
+})

package/src/scheduling/cancel.ts

@@ -1,7 +1,12 @@
 import type {ServerContract} from '../contracts'
 import {HoldKind, TaskCancelable, TaskType} from '../types'
 import {calcCargoItemMass} from '../capabilities/storage'
-import {taskCargoEffect, cargoKey} from './availability'
+import {
+    taskCargoEffect,
+    cargoKey,
+    isIncomingCouplingKind,
+    type IncomingSource,
+} from './availability'
 import * as schedule from './schedule'
 import {validateSchedule, type Projectable} from './projection'
 
@@ -11,6 +16,7 @@ export enum CancelBlockReason {
     DONE = 'DONE',
     CONTAINS_LINKED_TASK = 'CONTAINS_LINKED_TASK',
     WOULD_STRAND = 'WOULD_STRAND',
+    WOULD_STRAND_COUNTERPART = 'WOULD_STRAND_COUNTERPART',
     WOULD_OVERFILL = 'WOULD_OVERFILL',
     NOT_OWNER = 'NOT_OWNER',
 }
@@ -38,12 +44,14 @@ export interface CancelEffects {
 export interface CancelPlan {
     ok: boolean
     blockedReason?: CancelBlockReason
+    blockedByCounterpart?: EntityRef
     range: {count: number; taskIndices: number[]}
     effects: CancelEffects
 }
 export interface CancelEligibilityInput {
     now: Date
     counterparts?: Map<string, EntityInfo>
+    counterpartIncoming?: Map<string, readonly IncomingSource[]>
 }
 
 const EMPTY_EFFECTS: CancelEffects = {refunds: [], releasedHolds: [], abandonsRunning: false}
@@ -57,15 +65,18 @@ function postCancelEntity(entity: EntityInfo, laneKey: number, fromTaskIndex: nu
     return clone
 }
 
-function feasibleAfterCancel(post: EntityInfo): boolean {
-    const ordered = schedule.orderedTasks(post as unknown as Projectable)
+// C1: every pending consumer keeps its inputs covered by on-hand + own-lane producers strictly-before + incoming strictly-before.
+function queueFeasible(entity: EntityInfo, incoming: readonly IncomingSource[] = []): boolean {
+    const ordered = schedule.orderedTasks(entity as unknown as Projectable)
     const base = new Map<string, number>()
-    for (const c of post.cargo ?? []) {
+    for (const c of entity.cargo ?? []) {
         const k = cargoKey(c)
         base.set(k, (base.get(k) ?? 0) + c.quantity.toNumber())
     }
     const isConsumer = (t: Task) =>
-        t.type.toNumber() === TaskType.CRAFT || t.type.toNumber() === TaskType.UNLOAD
+        t.type.toNumber() === TaskType.CRAFT ||
+        t.type.toNumber() === TaskType.UNLOAD ||
+        t.type.toNumber() === TaskType.UPGRADE
     for (const self of ordered) {
         if (!isConsumer(self.task)) continue
         const map = new Map(base)
@@ -75,6 +86,12 @@ function feasibleAfterCancel(post: EntityInfo): boolean {
                 map.set(cargoKey(out), (map.get(cargoKey(out)) ?? 0) + out.quantity.toNumber())
             }
         }
+        for (const src of incoming) {
+            if (src.until.getTime() >= self.completesAt.getTime()) continue
+            for (const item of src.items) {
+                map.set(cargoKey(item), (map.get(cargoKey(item)) ?? 0) + item.quantity.toNumber())
+            }
+        }
         for (const other of ordered) {
             if (other === self) continue
             for (const inp of taskCargoEffect(other.task).removed) {
@@ -86,6 +103,11 @@ function feasibleAfterCancel(post: EntityInfo): boolean {
             if ((map.get(cargoKey(inp)) ?? 0) < inp.quantity.toNumber()) return false
         }
     }
+    return true
+}
+
+function feasibleAfterCancel(post: EntityInfo): boolean {
+    if (!queueFeasible(post)) return false
     try {
         validateSchedule(post as unknown as Projectable)
     } catch {
@@ -162,6 +184,37 @@ export function cancelEligibility(
     const post = postCancelEntity(entity, laneKey, fromTaskIndex)
     if (!feasibleAfterCancel(post)) return block(CancelBlockReason.WOULD_STRAND)
 
+    // cross-entity C1: a counterpart losing this delivery must still feed its own queued consumers.
+    const releasedByCounterpart = new Map<string, {counterpart: EntityRef; holdIds: Set<string>}>()
+    for (const i of taskIndices) {
+        for (const c of tasks[i].couplings ?? []) {
+            if (!isIncomingCouplingKind(c.kind.toNumber())) continue
+            const id = c.counterpart.entity_id.toString()
+            const entry = releasedByCounterpart.get(id) ?? {
+                counterpart: c.counterpart,
+                holdIds: new Set<string>(),
+            }
+            entry.holdIds.add(c.hold.toString())
+            releasedByCounterpart.set(id, entry)
+        }
+    }
+    for (const [counterpartId, released] of releasedByCounterpart) {
+        const counterpart = input.counterparts?.get(counterpartId)
+        if (!counterpart) continue
+        const incoming = (input.counterpartIncoming?.get(counterpartId) ?? []).filter(
+            (src) => !released.holdIds.has(src.holdId)
+        )
+        if (!queueFeasible(counterpart, incoming)) {
+            return {
+                ok: false,
+                blockedReason: CancelBlockReason.WOULD_STRAND_COUNTERPART,
+                blockedByCounterpart: released.counterpart,
+                range,
+                effects: {...EMPTY_EFFECTS},
+            }
+        }
+    }
+
     const effects: CancelEffects = {refunds: [], releasedHolds: [], abandonsRunning: false}
     let energyForfeited = 0
     for (const i of taskIndices) {

package/src/types.ts

@@ -152,6 +152,7 @@ export type ModuleType =
     | 'hauler'
     | 'battery'
     | 'catcher'
+    | 'aux'
 
 export const RESOURCE_TIER_ADJECTIVES: Record<number, string> = {
     1: 'Crude',