@shipload/sdk 1.0.0-next.61 → 1.0.0-next.63

package/src/managers/entities.ts

@@ -55,6 +55,17 @@ export class EntitiesManager extends BaseManager {
         return result as ServerContract.Types.entity_summary[]
     }
 
+    async getDepot(
+        depotId: UInt64Type,
+        owner: NameType | ServerContract.Types.player_row
+    ): Promise<ServerContract.Types.depot_view> {
+        const result = await this.server.readonly('getdepot', {
+            depot_id: depotId,
+            owner: this.resolveOwner(owner),
+        })
+        return result as ServerContract.Types.depot_view
+    }
+
     private resolveOwner(owner: NameType | ServerContract.Types.player_row): Name {
         if (typeof owner === 'object' && owner !== null && 'owner' in owner) {
             return owner.owner

package/src/managers/index.ts

@@ -12,6 +12,19 @@ export {ClusterManager, computeFreeCells} from './cluster'
 export type {GridCell, ClusterCell, Cluster} from './cluster'
 export {NftManager} from './nft'
 export type {NftConfigForItem} from './nft'
+export {JobsManager} from './jobs'
+export {InfluenceManager} from './influence'
+export type {
+    CharterProgress,
+    ContributePreview,
+    ContributePreviewRow,
+    FoundedWorld,
+    InfluenceStanding,
+    PendingBallot,
+    VoteCast,
+    VoteOption,
+    VoteStandings,
+} from './influence'
 export {PlotManager} from './plot'
 export type {PlotProgress, PlotProgressInputRow} from './plot'
 export {ConstructionManager} from './construction'

package/src/managers/influence.test.ts

@@ -0,0 +1,58 @@
+import {describe, expect, it} from 'bun:test'
+import {Name, UInt64} from '@wharfkit/antelope'
+import {InfluenceManager} from './influence'
+import {coordsToLocationId} from '../types'
+
+const LOCATION = {x: 12, y: 34}
+
+function managerWith(rowsByTable: Record<string, unknown[]>) {
+    const calls: {table: string; scope: unknown}[] = []
+    const table = (name: string, scope: unknown) => {
+        calls.push({table: name, scope})
+        return {all: async () => rowsByTable[name] ?? []}
+    }
+    const ctx = {server: {table}} as never
+    return {manager: new InfluenceManager(ctx), calls}
+}
+
+describe('InfluenceManager scoped table reads', () => {
+    it('getVoteCasts scopes infvote by location and maps fields', async () => {
+        const {manager, calls} = managerWith({
+            infvote: [{account: Name.from('eggmaple.gm'), epoch: 5, node_id: 2, weight: '100'}],
+        })
+        const rows = await manager.getVoteCasts(LOCATION)
+        expect(calls).toHaveLength(1)
+        expect(calls[0].table).toBe('infvote')
+        expect(UInt64.from(calls[0].scope as never).equals(coordsToLocationId(LOCATION))).toBe(true)
+        expect(rows).toEqual([
+            {account: Name.from('eggmaple.gm'), epoch: 5, nodeId: 2, weight: 100n},
+        ])
+    })
+
+    it('getVoteTallies scopes inftally by location and maps fields', async () => {
+        const {manager, calls} = managerWith({
+            inftally: [{node_id: 3, total: '250'}],
+        })
+        const rows = await manager.getVoteTallies(LOCATION)
+        expect(calls[0].table).toBe('inftally')
+        expect(UInt64.from(calls[0].scope as never).equals(coordsToLocationId(LOCATION))).toBe(true)
+        expect(rows).toEqual([{nodeId: 3, total: 250n}])
+    })
+
+    it('getBuiltCharters scopes charters by location and maps fields', async () => {
+        const {manager, calls} = managerWith({
+            charters: [{node_id: 1, entity_id: '9001'}],
+        })
+        const rows = await manager.getBuiltCharters(LOCATION)
+        expect(calls[0].table).toBe('charters')
+        expect(UInt64.from(calls[0].scope as never).equals(coordsToLocationId(LOCATION))).toBe(true)
+        expect(rows).toEqual([{nodeId: 1, entityId: 9001n}])
+    })
+
+    it('returns an empty array when the scope has no rows', async () => {
+        const {manager} = managerWith({})
+        expect(await manager.getVoteCasts(LOCATION)).toEqual([])
+        expect(await manager.getVoteTallies(LOCATION)).toEqual([])
+        expect(await manager.getBuiltCharters(LOCATION)).toEqual([])
+    })
+})

package/src/managers/influence.ts

@@ -0,0 +1,347 @@
+import {Int64, Name, type NameType, UInt64} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import type {ServerContract} from '../contracts'
+import {coordsToLocationId, locationIdToCoords, type CoordinatesType} from '../types'
+import {
+    type BuiltCharter,
+    citizenryName,
+    contributeDuration,
+    decayActive,
+    deriveDemand,
+    pricingFromWeights,
+    valueCargoItem,
+    type DemandTriple,
+    type DemandView,
+    type ValuedItem,
+} from '../influence'
+import {getItem} from '../data/catalog'
+
+export interface InfluenceStanding {
+    epoch: number
+    playerLifetime: bigint
+    playerActive: bigint
+    standingLifetime: bigint
+    standingActive: bigint
+    locationLifetime: bigint
+    locationActive: bigint
+    watermark: bigint
+    mandate: number
+    founder: Name
+    founded: number
+}
+
+export interface CharterProgress {
+    locationId: bigint
+    lifetime: bigint
+    watermark: bigint
+    surplus: bigint
+    mandate: number
+    nextCost: bigint
+    prereqsMet: boolean
+    buildable: boolean
+    epoch: number
+    built: {nodeId: number; completedEpoch: number; entityId: bigint}[]
+}
+
+export interface ContributePreviewRow {
+    itemId: number
+    quantity: number
+    stats: bigint
+    valueAtomic: bigint
+    massKg: number
+}
+
+export interface ContributePreview {
+    rows: ContributePreviewRow[]
+    totalAtomic: bigint
+    totalMassKg: number
+    durationSeconds: number
+    demand: DemandView
+}
+
+export interface FoundedWorld {
+    locationId: bigint
+    x: number
+    y: number
+    lifetime: bigint
+    active: bigint
+    watermark: bigint
+    chosen: number
+    chosenEpoch: number
+    mandate: number | undefined
+    founder: Name
+    founded: number
+}
+
+export interface VoteOption {
+    nodeId: number
+    cost: bigint
+    eligible: boolean
+    total: bigint | undefined
+}
+
+export interface VoteStandings {
+    locationId: bigint
+    epoch: number
+    chosen: number
+    chosenEpoch: number
+    mandate: number
+    ballotEpoch: number | undefined
+    talliesSuppressed: boolean
+    options: VoteOption[]
+}
+
+export interface VoteCast {
+    account: Name
+    epoch: number
+    nodeId: number
+    weight: bigint
+}
+
+export interface PendingBallot {
+    locationId: bigint
+    x: number
+    y: number
+    epoch: number
+}
+
+function big(value: unknown): bigint {
+    return BigInt(String(value))
+}
+
+export class InfluenceManager extends BaseManager {
+    async getStanding(owner: NameType, location: CoordinatesType): Promise<InfluenceStanding> {
+        const result = (await this.server.readonly('getinfluence', {
+            owner: Name.from(owner),
+            x: Int64.from(location.x),
+            y: Int64.from(location.y),
+        })) as ServerContract.Types.influence_totals
+
+        return {
+            epoch: Number(result.epoch),
+            playerLifetime: big(result.player_lifetime),
+            playerActive: big(result.player_active),
+            standingLifetime: big(result.standing_lifetime),
+            standingActive: big(result.standing_active),
+            locationLifetime: big(result.location_lifetime),
+            locationActive: big(result.location_active),
+            watermark: big(result.watermark),
+            mandate: Number(result.mandate),
+            founder: Name.from(result.founder),
+            founded: Number(result.founded),
+        }
+    }
+
+    async getDemandConfig(): Promise<DemandTriple> {
+        const row = (await this.server.table('infdemand').get()) as
+            | ServerContract.Types.infdemand_row
+            | undefined
+        if (!row) throw new Error('influence demand config is unset')
+        return {peak: big(row.peak), base: big(row.base), floor: big(row.floor)}
+    }
+
+    async getQualityDivisor(): Promise<number> {
+        const row = (await this.server.table('infquality').get()) as
+            | ServerContract.Types.infquality_row
+            | undefined
+        if (!row) throw new Error('influence quality config is unset')
+        return Number(row.d1)
+    }
+
+    async getWeights(): Promise<ServerContract.Types.infweight_row[]> {
+        return (await this.server.table('infweight').all()) as ServerContract.Types.infweight_row[]
+    }
+
+    async getDemand(location: CoordinatesType): Promise<DemandView> {
+        const game = await this.getGame()
+        const state = await this.getState()
+        const triple = await this.getDemandConfig()
+        return deriveDemand({
+            gameSeed: game.config.seed,
+            epochSeed: state.epochSeed,
+            coordinates: location,
+            triple,
+        })
+    }
+
+    async getCitizenryName(location: CoordinatesType): Promise<string | undefined> {
+        const game = await this.getGame()
+        return citizenryName(game.config.seed, location)
+    }
+
+    async previewContribution(
+        location: CoordinatesType,
+        bundle: ValuedItem[],
+        opts: {altitudeZ?: number} = {}
+    ): Promise<ContributePreview> {
+        const [demand, d1, weights] = await Promise.all([
+            this.getDemand(location),
+            this.getQualityDivisor(),
+            this.getWeights(),
+        ])
+        const pricing = pricingFromWeights(
+            d1,
+            weights.map((w) => ({
+                category: Number(w.category),
+                tier: Number(w.tier),
+                weightFp: big(w.weight_fp),
+            }))
+        )
+
+        let totalAtomic = 0n
+        let totalMassKg = 0
+        const rows = bundle.map((item) => {
+            const valueAtomic = valueCargoItem(item, demand, pricing)
+            const massKg = getItem(item.itemId).mass * item.quantity
+            totalAtomic += valueAtomic
+            totalMassKg += massKg
+            return {...item, valueAtomic, massKg}
+        })
+
+        return {
+            rows,
+            totalAtomic,
+            totalMassKg,
+            durationSeconds: contributeDuration(totalMassKg, opts.altitudeZ ?? 0),
+            demand,
+        }
+    }
+
+    async getCharter(location: CoordinatesType): Promise<CharterProgress> {
+        const result = (await this.server.readonly('getcharter', {
+            x: Int64.from(location.x),
+            y: Int64.from(location.y),
+        })) as ServerContract.Types.charter_result
+
+        return {
+            locationId: big(result.location_id),
+            lifetime: big(result.lifetime),
+            watermark: big(result.watermark),
+            surplus: big(result.surplus),
+            mandate: Number(result.mandate),
+            nextCost: big(result.next_cost),
+            prereqsMet: Boolean(result.prereqs_met),
+            buildable: Boolean(result.buildable),
+            epoch: Number(result.epoch),
+            built: result.built.map((b) => ({
+                nodeId: Number(b.node_id),
+                completedEpoch: Number(b.completed_epoch),
+                entityId: big(b.entity_id),
+            })),
+        }
+    }
+
+    async getPools(): Promise<ServerContract.Types.pool_view[]> {
+        const result = (await this.server.readonly('getpools')) as ServerContract.Types.pools_result
+        return result.pools
+    }
+
+    async getPool(category: number, tier: number): Promise<ServerContract.Types.pool_pair_result> {
+        return (await this.server.readonly('getpool', {
+            category,
+            tier,
+        })) as ServerContract.Types.pool_pair_result
+    }
+
+    async getMintConfig(): Promise<ServerContract.Types.mintcfg_result> {
+        return (await this.server.readonly('getmintcfg')) as ServerContract.Types.mintcfg_result
+    }
+
+    async getVotes(location: CoordinatesType): Promise<VoteStandings> {
+        const result = (await this.server.readonly('getvotes', {
+            x: Int64.from(location.x),
+            y: Int64.from(location.y),
+        })) as ServerContract.Types.vote_result
+
+        const epoch = Number(result.epoch)
+        const rawBallotEpoch = Number(result.ballot_epoch)
+        const ballotEpoch = rawBallotEpoch === 0 ? undefined : rawBallotEpoch
+        const talliesSuppressed = ballotEpoch !== undefined && ballotEpoch < epoch
+
+        return {
+            locationId: big(result.location_id),
+            epoch,
+            chosen: Number(result.chosen),
+            chosenEpoch: Number(result.chosen_epoch),
+            mandate: Number(result.effective),
+            ballotEpoch,
+            talliesSuppressed,
+            options: result.options.map((option) => ({
+                nodeId: Number(option.node_id),
+                cost: big(option.cost),
+                eligible: Boolean(option.eligible),
+                total: talliesSuppressed ? undefined : big(option.total),
+            })),
+        }
+    }
+
+    async getVoteCasts(location: CoordinatesType): Promise<VoteCast[]> {
+        const rows = (await this.server
+            .table('infvote', coordsToLocationId(location))
+            .all()) as ServerContract.Types.infvote_row[]
+        return rows.map((row) => ({
+            account: Name.from(row.account),
+            epoch: Number(row.epoch),
+            nodeId: Number(row.node_id),
+            weight: big(row.weight),
+        }))
+    }
+
+    async getVoteTallies(location: CoordinatesType): Promise<{nodeId: number; total: bigint}[]> {
+        const rows = (await this.server
+            .table('inftally', coordsToLocationId(location))
+            .all()) as ServerContract.Types.inftally_row[]
+        return rows.map((row) => ({nodeId: Number(row.node_id), total: big(row.total)}))
+    }
+
+    async getBuiltCharters(location: CoordinatesType): Promise<BuiltCharter[]> {
+        const rows = (await this.server
+            .table('charters', coordsToLocationId(location))
+            .all()) as ServerContract.Types.charters_row[]
+        return rows.map((row) => ({nodeId: Number(row.node_id), entityId: big(row.entity_id)}))
+    }
+
+    async getBallotQueue(): Promise<PendingBallot[]> {
+        const rows = (await this.server
+            .table('infballot')
+            .all()) as ServerContract.Types.infballot_row[]
+        return rows.map((row) => ({
+            locationId: big(row.location_id),
+            ...locationIdToCoords(row.location_id),
+            epoch: Number(row.epoch),
+        }))
+    }
+
+    async getFoundedWorlds(opts: {withMandate?: boolean} = {}): Promise<FoundedWorld[]> {
+        const rows = (await this.server.table('infloc').all()) as ServerContract.Types.infloc_row[]
+        const epoch = (await this.getState()).epoch
+        const worlds = rows.map((row) => ({
+            locationId: big(row.location_id),
+            ...locationIdToCoords(row.location_id),
+            lifetime: big(row.lifetime),
+            active: decayActive(
+                big(row.active),
+                Math.max(0, Number(epoch) - Number(row.last_update_epoch))
+            ),
+            watermark: big(row.watermark),
+            chosen: Number(row.chosen),
+            chosenEpoch: Number(row.chosen_epoch),
+            mandate: undefined as number | undefined,
+            founder: Name.from(row.founder),
+            founded: Number(row.founded),
+        }))
+
+        if (!opts.withMandate) return worlds
+
+        for (const world of worlds) {
+            world.mandate = (await this.getCharter({x: world.x, y: world.y})).mandate
+        }
+        return worlds
+    }
+
+    async isFounded(location: CoordinatesType): Promise<boolean> {
+        const id = coordsToLocationId(location)
+        const row = await this.server.table('infloc').get(UInt64.from(id))
+        return row !== undefined
+    }
+}

package/src/managers/jobs.test.ts

@@ -0,0 +1,62 @@
+import {describe, expect, it} from 'bun:test'
+import {Name} from '@wharfkit/antelope'
+import {JobsManager} from './jobs'
+
+const OWNER = 'eggmaple.gm'
+const row = (over: Record<string, unknown> = {}) => ({
+    id: {toNumber: () => 7},
+    workshop: {toNumber: () => 42},
+    socket: {toNumber: () => 0},
+    owner: Name.from(OWNER),
+    ship_id: {toNumber: () => 100},
+    coords: {x: {toNumber: () => 12}, y: {toNumber: () => 34}},
+    starts_at: {toDate: () => new Date('2026-07-26T10:00:00Z')},
+    completes_at: {toDate: () => new Date('2026-07-26T11:00:00Z')},
+    recipe_id: {toNumber: () => 10001},
+    quantity: {toNumber: () => 5},
+    energy_paid: {toNumber: () => 0},
+    cargo: [{item: 'in'}, {item: 'out'}],
+    ...over,
+})
+
+function managerWith(queryImpl: () => Promise<unknown[]>, allImpl: () => Promise<unknown[]>) {
+    const table = () => ({query: () => ({all: queryImpl}), all: allImpl})
+    const ctx = {server: {table}} as never
+    return new JobsManager(ctx)
+}
+
+describe('JobsManager.getOwnedJobs', () => {
+    it('parses owner rows: output = last cargo, inputs = rest, status derived', async () => {
+        const m = managerWith(
+            async () => [row()],
+            async () => []
+        )
+        const jobs = await m.getOwnedJobs(OWNER, {now: new Date('2026-07-26T11:30:00Z')})
+        expect(jobs).toHaveLength(1)
+        expect(jobs[0]).toMatchObject({id: 7, workshop: 42, quantity: 5, status: 'ready'})
+        expect(jobs[0].coords).toEqual({x: 12, y: 34})
+        expect(jobs[0].output).toEqual({item: 'out'} as never)
+        expect(jobs[0].inputs).toEqual([{item: 'in'}] as never)
+    })
+
+    it('drops rows whose owner does not match (positional-index safety re-filter)', async () => {
+        const other = row({owner: Name.from('someoneelse.gm')})
+        const m = managerWith(
+            async () => [row(), other],
+            async () => []
+        )
+        const jobs = await m.getOwnedJobs(OWNER)
+        expect(jobs).toHaveLength(1)
+    })
+
+    it('falls back to a full-scan .all() when the positional query throws', async () => {
+        const m = managerWith(
+            async () => {
+                throw new Error('bad index_position')
+            },
+            async () => [row()]
+        )
+        const jobs = await m.getOwnedJobs(OWNER)
+        expect(jobs).toHaveLength(1)
+    })
+})

package/src/managers/jobs.ts

@@ -0,0 +1,52 @@
+import {Name, type NameType} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import {jobStatus, splitJobCargo, type OwnedJob} from '../scheduling/jobs'
+import type {ServerContract} from '../contracts'
+
+type JobRow = ServerContract.Types.job_row
+
+export class JobsManager extends BaseManager {
+    async getOwnedJobs(owner: NameType, opts?: {now?: Date}): Promise<OwnedJob[]> {
+        const ownerName = Name.from(owner)
+        const now = opts?.now ?? new Date()
+
+        let rows: JobRow[]
+        try {
+            // index_position 'tertiary' = nodeos slot 3 = owner's secondary index; no ABI metadata for it.
+            rows = (await this.server
+                .table('jobs')
+                .query({
+                    index_position: 'tertiary',
+                    key_type: 'i64',
+                    from: ownerName.value,
+                    to: ownerName.value,
+                })
+                .all()) as JobRow[]
+        } catch {
+            rows = (await this.server.table('jobs').all()) as JobRow[]
+        }
+
+        return rows.filter((r) => ownerName.equals(r.owner)).map((r) => this.parseOwnedJob(r, now))
+    }
+
+    private parseOwnedJob(r: JobRow, now: Date): OwnedJob {
+        const startsAt = r.starts_at.toDate()
+        const completesAt = r.completes_at.toDate()
+        const {output, inputs} = splitJobCargo(r.cargo)
+        return {
+            id: r.id.toNumber(),
+            workshop: r.workshop.toNumber(),
+            socket: r.socket.toNumber(),
+            shipId: r.ship_id.toNumber(),
+            coords: {x: r.coords.x.toNumber(), y: r.coords.y.toNumber()},
+            startsAt,
+            completesAt,
+            recipeId: r.recipe_id.toNumber(),
+            quantity: r.quantity.toNumber(),
+            status: jobStatus({startsAt, completesAt}, now),
+            output,
+            inputs,
+            outputStats: output?.stats === undefined ? undefined : BigInt(output.stats.toString()),
+        }
+    }
+}

package/src/nft/description.ts

@@ -85,6 +85,11 @@ export function computeBaseCapacityWorkshop(stats: bigint): number {
     return Math.floor(5_000_000 * 6 ** (s / 1998))
 }
 
+export function computeBaseCapacityDepot(stats: bigint): number {
+    const s = decodeStat(stats, 0) + decodeStat(stats, 2)
+    return Math.floor(50_000_000 * 6 ** (s / 1998))
+}
+
 const CAPACITY_FN_BY_KIND: Record<string, (stats: bigint) => number> = {
     ship: computeBaseCapacityShip,
     warehouse: computeBaseCapacityWarehouse,
@@ -95,6 +100,8 @@ const CAPACITY_FN_BY_KIND: Record<string, (stats: bigint) => number> = {
     mdriver: computeBaseCapacityContainer,
     mcatcher: computeBaseCapacityContainer,
     container: computeBaseCapacityContainer,
+    nexus: computeBaseCapacityContainer,
+    depot: computeBaseCapacityDepot,
 }
 
 export function computeBaseCapacityForEntity(itemId: number, stats: bigint): number {

package/src/scheduling/jobs.test.ts

@@ -0,0 +1,32 @@
+import {describe, expect, it} from 'bun:test'
+import {jobStatus, splitJobCargo} from './jobs'
+
+const at = (s: string) => new Date(s)
+
+describe('jobStatus', () => {
+    const job = {startsAt: at('2026-07-26T10:00:00Z'), completesAt: at('2026-07-26T11:00:00Z')}
+    it('is waiting before startsAt', () => {
+        expect(jobStatus(job, at('2026-07-26T09:59:59Z'))).toBe('waiting')
+    })
+    it('is crafting between startsAt and completesAt', () => {
+        expect(jobStatus(job, at('2026-07-26T10:30:00Z'))).toBe('crafting')
+    })
+    it('is ready at or after completesAt', () => {
+        expect(jobStatus(job, at('2026-07-26T11:00:00Z'))).toBe('ready')
+        expect(jobStatus(job, at('2026-07-26T12:00:00Z'))).toBe('ready')
+    })
+})
+
+describe('splitJobCargo', () => {
+    it('takes the last element as output, the rest as inputs', () => {
+        const cargo = [{n: 'a'}, {n: 'b'}, {n: 'out'}] as unknown as Parameters<
+            typeof splitJobCargo
+        >[0]
+        const {output, inputs} = splitJobCargo(cargo)
+        expect(output).toEqual({n: 'out'} as never)
+        expect(inputs).toEqual([{n: 'a'}, {n: 'b'}] as never)
+    })
+    it('returns null output for empty cargo', () => {
+        expect(splitJobCargo([])).toEqual({output: null, inputs: []})
+    })
+})

package/src/scheduling/jobs.ts

@@ -1,3 +1,7 @@
+import type {ServerContract} from '../contracts'
+
+type CargoItem = ServerContract.Types.cargo_item
+
 export interface JobWindow {
     id: number
     socket: number
@@ -6,6 +10,8 @@ export interface JobWindow {
     completesAt: Date
     recipeId: number
     quantity: number
+    /** Packed stat roll of the job's output, when the source carried the job's cargo. */
+    outputStats?: bigint
 }
 
 export interface JobLaneEntry {
@@ -69,3 +75,34 @@ export function pickFabricator(
     }
     return best
 }
+
+export type JobStatus = 'waiting' | 'crafting' | 'ready'
+
+export function jobStatus(job: {startsAt: Date; completesAt: Date}, now: Date): JobStatus {
+    if (now < job.startsAt) return 'waiting'
+    if (now < job.completesAt) return 'crafting'
+    return 'ready'
+}
+
+// Generic in the element so raw chain JSON (readonly actions) splits by the same rule as decoded rows.
+export function splitJobCargo<T>(cargo: readonly T[]): {output: T | null; inputs: T[]} {
+    if (cargo.length === 0) return {output: null, inputs: []}
+    return {output: cargo[cargo.length - 1], inputs: cargo.slice(0, -1)}
+}
+
+export interface OwnedJob {
+    id: number
+    workshop: number
+    socket: number
+    shipId: number
+    coords: {x: number; y: number}
+    startsAt: Date
+    completesAt: Date
+    recipeId: number
+    quantity: number
+    status: JobStatus
+    output: CargoItem | null
+    inputs: CargoItem[]
+    /** Packed stat roll of `output`, so every job shape answers this the same way. */
+    outputStats?: bigint
+}

package/src/scheduling/task-cargo.ts

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