@shipload/sdk 1.0.0-next.69 → 1.0.0-next.70

package/src/influence/influence.test.ts

@@ -20,7 +20,7 @@ import {
     popcount5,
 } from './demand'
 import {findDecomp, DECOMP_REGISTRY} from './decomp'
-import {depotTransferDuration, contributeDuration} from './duration'
+import {civicDropoffDuration, depotTransferDuration, contributeDuration} from './duration'
 import {getStatCount, statsSumSq} from './quality'
 import {pricingFromWeights, valueCargoItem, valueContribution} from './valuation'
 import {citizenryName, citizenryPatternCount} from './citizenry'
@@ -382,3 +382,69 @@ describe('depot transfer duration', () => {
         expect(depotTransferDuration(params({cargoMass: 1}))).toBeGreaterThanOrEqual(1)
     })
 })
+
+describe('civic drop-off duration', () => {
+    type ModuleEntry = ServerContract.Types.module_entry
+    const DEPOT_ITEM = 10219
+    const WORKSHOP_ITEM = 10208
+    const LOADER_T1 = 10103
+
+    function makeModuleEntry(itemId: number, stats: bigint): ModuleEntry {
+        return {
+            type: UInt8.from(0),
+            installed: {item_id: UInt16.from(itemId), stats: UInt64.from(stats)},
+        } as unknown as ModuleEntry
+    }
+    function emptySlot(): ModuleEntry {
+        return {type: UInt8.from(0)} as unknown as ModuleEntry
+    }
+
+    const withLoader = () => ({
+        buildingModules: [makeModuleEntry(LOADER_T1, packStats(500)), emptySlot()],
+        buildingItemId: DEPOT_ITEM,
+        buildingKind: 'depot',
+        buildingZ: 0,
+        shipKind: 'ship',
+        shipZ: 400,
+        cargoMass: 100,
+    })
+    const withoutLoader = () => ({
+        buildingModules: [] as ModuleEntry[],
+        buildingItemId: WORKSHOP_ITEM,
+        buildingKind: 'workshop',
+        buildingZ: 0,
+        shipKind: 'ship',
+        shipZ: 400,
+        cargoMass: 100,
+    })
+
+    test('a building with a slot-0 loader prices off that loader', () => {
+        const p = withLoader()
+        expect(civicDropoffDuration(p)).toBe(
+            depotTransferDuration({
+                depotModules: p.buildingModules,
+                depotItemId: p.buildingItemId,
+                depotKind: p.buildingKind,
+                depotZ: p.buildingZ,
+                shipKind: p.shipKind,
+                shipZ: p.shipZ,
+                cargoMass: p.cargoMass,
+            })
+        )
+    })
+
+    test('a building with no loader falls back to the civic loader', () => {
+        const p = withoutLoader()
+        expect(civicDropoffDuration(p)).toBe(contributeDuration(p.cargoMass, p.shipZ))
+        expect(civicDropoffDuration(p)).toBeGreaterThan(0)
+    })
+
+    test('grows with cargo mass on both paths', () => {
+        expect(civicDropoffDuration({...withLoader(), cargoMass: 10_000})).toBeGreaterThan(
+            civicDropoffDuration(withLoader())
+        )
+        expect(civicDropoffDuration({...withoutLoader(), cargoMass: 10_000})).toBeGreaterThan(
+            civicDropoffDuration(withoutLoader())
+        )
+    })
+})

package/src/managers/actions.ts

@@ -562,14 +562,6 @@ export class ActionsManager extends BaseManager {
         return this.server.action('claimcraft', params)
     }
 
-    cancelcraft(jobId: UInt64Type, shipId: UInt64Type): Action {
-        const params: ServerContract.ActionParams.cancelcraft = {
-            job_id: UInt64.from(jobId),
-            ship_id: UInt64.from(shipId),
-        }
-        return this.server.action('cancelcraft', params)
-    }
-
     buildjob(
         targetId: UInt64Type,
         dockId: UInt64Type,

package/src/managers/jobs.test.ts

@@ -15,7 +15,7 @@ const row = (over: Record<string, unknown> = {}) => ({
     recipe_id: {toNumber: () => 10001},
     quantity: {toNumber: () => 5},
     energy_paid: {toNumber: () => 0},
-    cargo: [{item: 'in'}, {item: 'out'}],
+    cargo: [{item: 'out'}],
     ...over,
 })
 
@@ -26,7 +26,7 @@ function managerWith(queryImpl: () => Promise<unknown[]>, allImpl: () => Promise
 }
 
 describe('JobsManager.getOwnedJobs', () => {
-    it('parses owner rows: output = last cargo, inputs = rest, status derived', async () => {
+    it('parses a landed row: cargo is the output, no inputs, status derived', async () => {
         const m = managerWith(
             async () => [row()],
             async () => []
@@ -36,6 +36,24 @@ describe('JobsManager.getOwnedJobs', () => {
         expect(jobs[0]).toMatchObject({id: 7, building: 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([] as never)
+    })
+
+    it('reports a job In Line rather than ready, whatever its zero window says', async () => {
+        const inLine = row({
+            starts_at: {toDate: () => new Date(0)},
+            completes_at: {toDate: () => new Date(0)},
+            deposited: false,
+            cargo: [{item: 'in'}],
+        })
+        const m = managerWith(
+            async () => [inLine],
+            async () => []
+        )
+        const jobs = await m.getOwnedJobs(OWNER, {now: new Date('2026-07-26T11:30:00Z')})
+        expect(jobs[0].status).toBe('inline')
+        expect(jobs[0].deposited).toBe(false)
+        expect(jobs[0].output).toBeNull()
         expect(jobs[0].inputs).toEqual([{item: 'in'}] as never)
     })
 

package/src/managers/jobs.ts

@@ -1,6 +1,6 @@
 import {Name, type NameType} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {jobStatus, splitJobCargo, type OwnedJob} from '../scheduling/jobs'
+import {jobDeposited, jobStatus, splitJobCargo, type OwnedJob} from '../scheduling/jobs'
 import type {ServerContract} from '../contracts'
 
 type JobRow = ServerContract.Types.craftjob_row
@@ -32,7 +32,8 @@ export class JobsManager extends BaseManager {
     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)
+        const deposited = jobDeposited(r.deposited)
+        const {output, inputs} = splitJobCargo(r.cargo, deposited)
         return {
             id: r.id.toNumber(),
             building: r.building.toNumber(),
@@ -43,7 +44,8 @@ export class JobsManager extends BaseManager {
             completesAt,
             recipeId: r.recipe_id.toNumber(),
             quantity: r.quantity.toNumber(),
-            status: jobStatus({startsAt, completesAt}, now),
+            status: jobStatus({startsAt, completesAt, deposited}, now),
+            deposited,
             output,
             inputs,
             outputStats: output?.stats === undefined ? undefined : BigInt(output.stats.toString()),

package/src/receipts.ts

@@ -0,0 +1,22 @@
+import {Serializer} from '@wharfkit/antelope'
+import {ServerContract} from './contracts'
+
+export type BookingReceipt = ServerContract.Types.booking_receipt
+
+export function decodeBookingReceipt(data: unknown): BookingReceipt {
+    if (data === null || data === undefined) {
+        throw new Error('decodeBookingReceipt: no return value')
+    }
+    if (data instanceof Uint8Array || typeof data === 'string') {
+        return Serializer.decode({data, type: ServerContract.Types.booking_receipt})
+    }
+    return ServerContract.Types.booking_receipt.from(data as ServerContract.Types.booking_receipt)
+}
+
+export function bookingReceiptLandsAtMs(receipt: BookingReceipt): number {
+    return receipt.lands_at.toMilliseconds()
+}
+
+export function bookingReceiptRuntimeSeconds(receipt: BookingReceipt): number {
+    return Number(receipt.runtime)
+}

package/src/scheduling/availability.test.ts

@@ -223,13 +223,13 @@ describe('taskCargoEffect task coverage', () => {
     })
 
     test('a depot store removes its cargo', () => {
-        const effect = taskCargoEffect(simpleTask(TaskType.DEPOT_STORE))
+        const effect = taskCargoEffect(simpleTask(TaskType.CIVIC_DEPOSIT))
         expect(effect.removed).toHaveLength(1)
         expect(effect.added).toHaveLength(0)
     })
 
     test('a depot take adds its cargo', () => {
-        const effect = taskCargoEffect(simpleTask(TaskType.DEPOT_TAKE))
+        const effect = taskCargoEffect(simpleTask(TaskType.CIVIC_WITHDRAW))
         expect(effect.added).toHaveLength(1)
         expect(effect.removed).toHaveLength(0)
     })

package/src/scheduling/jobs.test.ts

@@ -1,5 +1,5 @@
 import {describe, expect, it} from 'bun:test'
-import {jobStatus, splitJobCargo} from './jobs'
+import {jobStatus, jobStatusLabel, splitJobCargo} from './jobs'
 
 const at = (s: string) => new Date(s)
 
@@ -15,18 +15,35 @@ describe('jobStatus', () => {
         expect(jobStatus(job, at('2026-07-26T11:00:00Z'))).toBe('ready')
         expect(jobStatus(job, at('2026-07-26T12:00:00Z'))).toBe('ready')
     })
+    it('is inline while the drop-off is still in the air', () => {
+        const booked = {
+            startsAt: at('1970-01-01T00:00:00Z'),
+            completesAt: at('1970-01-01T00:00:00Z'),
+        }
+        expect(jobStatus({...booked, deposited: false}, at('2026-07-26T10:00:00Z'))).toBe('inline')
+        expect(jobStatus({...job, deposited: true}, at('2026-07-26T10:30:00Z'))).toBe('crafting')
+    })
+    it('labels every state', () => {
+        expect(jobStatusLabel('inline')).toBe('In Line')
+        expect(jobStatusLabel('ready')).toBe('Ready for Pickup')
+    })
 })
 
 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)
+    it('reads an In Line row as inputs with no output', () => {
+        const cargo = [{n: 'a'}, {n: 'b'}] as unknown as Parameters<typeof splitJobCargo>[0]
+        const {output, inputs} = splitJobCargo(cargo, false)
+        expect(output).toBeNull()
         expect(inputs).toEqual([{n: 'a'}, {n: 'b'}] as never)
     })
+    it('reads a landed row as the output with no inputs', () => {
+        const cargo = [{n: 'out'}] as unknown as Parameters<typeof splitJobCargo>[0]
+        const {output, inputs} = splitJobCargo(cargo, true)
+        expect(output).toEqual({n: 'out'} as never)
+        expect(inputs).toEqual([] as never)
+    })
     it('returns null output for empty cargo', () => {
-        expect(splitJobCargo([])).toEqual({output: null, inputs: []})
+        expect(splitJobCargo([], true)).toEqual({output: null, inputs: []})
+        expect(splitJobCargo([], false)).toEqual({output: null, inputs: []})
     })
 })

package/src/scheduling/jobs.ts

@@ -10,6 +10,8 @@ export interface JobWindow {
     completesAt: Date
     recipeId: number
     quantity: number
+    /** False while the job is In Line: booked, with its inputs still in transit to the building. */
+    deposited: boolean
     /** Packed stat roll of the job's output, when the source carried the job's cargo. */
     outputStats?: bigint
 }
@@ -76,18 +78,44 @@ export function pickFabricator(
     return best
 }
 
-export type JobStatus = 'waiting' | 'crafting' | 'ready'
+export type JobStatus = 'inline' | 'waiting' | 'crafting' | 'ready'
 
-export function jobStatus(job: {startsAt: Date; completesAt: Date}, now: Date): JobStatus {
+// A job In Line has no window yet, so the window alone would read it as long since ready.
+export function jobStatus(
+    job: {startsAt: Date; completesAt: Date; deposited?: boolean},
+    now: Date
+): JobStatus {
+    if (job.deposited === false) return 'inline'
     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[]} {
+const JOB_STATUS_LABELS: Record<JobStatus, string> = {
+    inline: 'In Line',
+    waiting: 'Waiting',
+    crafting: 'Crafting',
+    ready: 'Ready for Pickup',
+}
+
+export function jobStatusLabel(status: JobStatus): string {
+    return JOB_STATUS_LABELS[status]
+}
+
+// A row written before the deposited flag existed reads as undefined; those jobs were all deposited.
+export function jobDeposited(value: unknown): boolean {
+    if (value === undefined || value === null) return true
+    return Boolean(value)
+}
+
+// A job row holds the inputs while In Line and the output once its drop-off has landed.
+export function splitJobCargo<T>(
+    cargo: readonly T[],
+    deposited: boolean
+): {output: T | null; inputs: T[]} {
     if (cargo.length === 0) return {output: null, inputs: []}
-    return {output: cargo[cargo.length - 1], inputs: cargo.slice(0, -1)}
+    if (!deposited) return {output: null, inputs: [...cargo]}
+    return {output: cargo[0], inputs: []}
 }
 
 export interface OwnedJob {
@@ -101,6 +129,7 @@ export interface OwnedJob {
     recipeId: number
     quantity: number
     status: JobStatus
+    deposited: boolean
     output: CargoItem | null
     inputs: CargoItem[]
     /** Packed stat roll of `output`, so every job shape answers this the same way. */

package/src/scheduling/projection.ts

@@ -405,9 +405,19 @@ function applyTask(projected: ProjectedEntity, task: ServerContract.Types.task):
             break
         case TaskType.LOAD:
         case TaskType.UNWRAP:
+        case TaskType.CIVIC_WITHDRAW:
             applyAddCargoTask(projected, task)
             break
         case TaskType.UNLOAD:
+        case TaskType.CONTRIBUTE:
+            applyRemoveCargoTask(projected, task)
+            break
+        case TaskType.CIVIC_DEPOSIT:
+            applyEnergyCost(projected, task)
+            applyRemoveCargoTask(projected, task)
+            break
+        case TaskType.UPGRADE:
+            applyEnergyCost(projected, task)
             applyRemoveCargoTask(projected, task)
             break
         case TaskType.GATHER:
@@ -417,6 +427,8 @@ function applyTask(projected: ProjectedEntity, task: ServerContract.Types.task):
             applyCraftTask(projected, task)
             break
         case TaskType.UNDEPLOY:
+            applyAddCargoTask(projected, task)
+            break
         case TaskType.DEMOLISH:
             break
     }
@@ -426,16 +438,8 @@ export interface ProjectionOptions {
     upToTaskIndex?: number
 }
 
-// Mirrors the contract's completed_task_count_at: inclusive at the anchor.
 function anchoredSkipCount(entity: Projectable, ordered: readonly schedule.OrderedTask[]): number {
-    const anchor = entity.projected_at
-    if (anchor === undefined) return 0
-    const anchorMs = Number(anchor.toMilliseconds())
-    let count = 0
-    for (const {completesAt} of ordered) {
-        if (completesAt.getTime() <= anchorMs) count++
-    }
-    return count
+    return schedule.appliedTaskCount(entity, ordered)
 }
 
 export function projectEntity(entity: Projectable, options?: ProjectionOptions): ProjectedEntity {
@@ -573,21 +577,8 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
             case TaskType.TRANSIT:
                 applyFlightTask(projected, task, {complete: taskComplete, progress})
                 break
-            case TaskType.LOAD:
-            case TaskType.UNWRAP:
-                if (taskComplete) applyAddCargoTask(projected, task)
-                break
-            case TaskType.UNLOAD:
-                if (taskComplete) applyRemoveCargoTask(projected, task)
-                break
-            case TaskType.GATHER:
-                if (taskComplete) applyGatherTask(projected, task, {complete: true})
-                break
-            case TaskType.CRAFT:
-                if (taskComplete) applyCraftTask(projected, task)
-                break
-            case TaskType.UNDEPLOY:
-            case TaskType.DEMOLISH:
+            default:
+                if (taskComplete) applyTask(projected, task)
                 break
         }
     }

package/src/scheduling/schedule.test.ts

@@ -1,6 +1,13 @@
 import {describe, expect, test} from 'bun:test'
 import {ServerContract, TaskType} from '../index-module'
-import {hasPendingCapper, hasResolvable, isCapperTaskType} from './schedule'
+import {
+    appliedTaskCount,
+    hasPendingCapper,
+    hasResolvable,
+    isCapperTaskType,
+    orderedTasks,
+    unappliedTasks,
+} from './schedule'
 
 const T0 = '2026-06-19T00:00:00'
 const NOW = new Date('2026-06-19T00:01:00.000Z')
@@ -118,3 +125,39 @@ describe('hasResolvable — capper gating', () => {
         expect(hasResolvable(e, NOW)).toBe(false)
     })
 })
+
+function anchoredEntity(anchorISO: string) {
+    const e = entity([
+        task({type: TaskType.TRAVEL, duration: 30}),
+        task({type: TaskType.TRAVEL, duration: 30}),
+        task({type: TaskType.TRAVEL, duration: 30}),
+    ])
+    return ServerContract.Types.entity_info.from({
+        ...ServerContract.Types.entity_info.from(e),
+        projected_at: anchorISO,
+    })
+}
+
+describe('appliedTaskCount / unappliedTasks', () => {
+    test('no anchor leaves every task unapplied', () => {
+        const e = entity([task({duration: 30}), task({duration: 30})])
+        expect(appliedTaskCount({lanes: e.lanes}, orderedTasks(e))).toBe(0)
+        expect(unappliedTasks({lanes: e.lanes})).toHaveLength(2)
+    })
+
+    test('tasks completed at or before the anchor are already applied', () => {
+        const e = anchoredEntity('2026-06-19T00:01:00')
+        expect(appliedTaskCount(e, orderedTasks(e))).toBe(2)
+        expect(unappliedTasks(e)).toHaveLength(1)
+    })
+
+    test('the anchor is inclusive, mirroring completed_task_count_at', () => {
+        const e = anchoredEntity('2026-06-19T00:00:30')
+        expect(appliedTaskCount(e, orderedTasks(e))).toBe(1)
+    })
+
+    test('a whole schedule finished before the anchor leaves nothing unapplied', () => {
+        const e = anchoredEntity('2026-06-19T12:00:00')
+        expect(unappliedTasks(e)).toHaveLength(0)
+    })
+})

package/src/scheduling/schedule.ts

@@ -1,3 +1,4 @@
+import type {TimePoint} from '@wharfkit/antelope'
 import type {ServerContract} from '../contracts'
 import {TaskType} from '../types'
 import * as core from './lane-core'
@@ -15,6 +16,10 @@ export interface ScheduleData {
     holds?: Hold[]
 }
 
+export interface AnchoredScheduleData extends ScheduleData {
+    projected_at?: TimePoint
+}
+
 export interface LaneView {
     laneKey: number
     schedule: Schedule
@@ -240,6 +245,27 @@ export function orderedTasks(entity: ScheduleData): OrderedTask[] {
     return out
 }
 
+// Mirrors the contract's completed_task_count_at: inclusive at the anchor.
+export function appliedTaskCount(
+    entity: AnchoredScheduleData,
+    ordered: readonly OrderedTask[]
+): number {
+    const anchor = entity.projected_at
+    if (anchor === undefined) return 0
+    const anchorMs = Number(anchor.toMilliseconds())
+    let count = 0
+    for (const {completesAt} of ordered) {
+        if (completesAt.getTime() <= anchorMs) count++
+    }
+    return count
+}
+
+// Tasks an entity_info snapshot has NOT yet folded into its cargo and state.
+export function unappliedTasks(entity: AnchoredScheduleData): OrderedTask[] {
+    const ordered = orderedTasks(entity)
+    return ordered.slice(appliedTaskCount(entity, ordered))
+}
+
 export function laneRemainingOf(entity: ScheduleData, laneKey: number, now: Date): number {
     const lane = getLane(entity, laneKey)
     return lane ? core.laneRemaining(lane.schedule, now) : 0

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

@@ -44,9 +44,14 @@ describe('taskCargoChanges', () => {
 })
 
 describe('TaskType', () => {
-    test('covers the depot task types the contract defines', () => {
-        expect(TaskType.DEPOT_STORE).toBe(21)
-        expect(TaskType.DEPOT_TAKE).toBe(22)
+    test('covers the civic transfer task types the contract defines', () => {
+        expect(TaskType.CIVIC_DEPOSIT).toBe(21)
+        expect(TaskType.CIVIC_WITHDRAW).toBe(22)
+    })
+
+    test('keeps the former depot names as aliases of the civic transfer types', () => {
+        expect(TaskType.DEPOT_STORE).toBe(TaskType.CIVIC_DEPOSIT)
+        expect(TaskType.DEPOT_TAKE).toBe(TaskType.CIVIC_WITHDRAW)
     })
 })
 
@@ -62,13 +67,13 @@ function simpleTask(type: number) {
 
 describe('taskCargoChanges task coverage', () => {
     test('a depot store moves cargo out of the entity', () => {
-        const changes = taskCargoChanges(simpleTask(TaskType.DEPOT_STORE))
+        const changes = taskCargoChanges(simpleTask(TaskType.CIVIC_DEPOSIT))
         expect(changes).toHaveLength(1)
         expect(changes[0].direction).toBe('out')
     })
 
     test('a depot take moves cargo into the entity', () => {
-        const changes = taskCargoChanges(simpleTask(TaskType.DEPOT_TAKE))
+        const changes = taskCargoChanges(simpleTask(TaskType.CIVIC_WITHDRAW))
         expect(changes).toHaveLength(1)
         expect(changes[0].direction).toBe('in')
     })
@@ -88,7 +93,7 @@ describe('taskCargoChanges task coverage', () => {
 
 describe('taskCargoChangesChecked', () => {
     test('reports a known task type with its changes', () => {
-        const result = taskCargoChangesChecked(simpleTask(TaskType.DEPOT_TAKE))
+        const result = taskCargoChangesChecked(simpleTask(TaskType.CIVIC_WITHDRAW))
         expect(result.known).toBe(true)
         if (result.known) expect(result.changes[0].direction).toBe('in')
     })

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

@@ -7,13 +7,13 @@ describe('taskCargoRule', () => {
         expect(taskCargoRule(TaskType.UNLOAD)).toBe('all-out')
         expect(taskCargoRule(TaskType.UPGRADE)).toBe('all-out')
         expect(taskCargoRule(TaskType.CONTRIBUTE)).toBe('all-out')
-        expect(taskCargoRule(TaskType.DEPOT_STORE)).toBe('all-out')
+        expect(taskCargoRule(TaskType.CIVIC_DEPOSIT)).toBe('all-out')
     })
 
     test('maps the task types that move cargo into the entity', () => {
         expect(taskCargoRule(TaskType.LOAD)).toBe('all-in')
         expect(taskCargoRule(TaskType.UNWRAP)).toBe('all-in')
-        expect(taskCargoRule(TaskType.DEPOT_TAKE)).toBe('all-in')
+        expect(taskCargoRule(TaskType.CIVIC_WITHDRAW)).toBe('all-in')
     })
 
     test('maps the conditional task types to their own rules', () => {

package/src/scheduling/task-effects.ts

@@ -19,11 +19,11 @@ export const TASK_CARGO_EFFECTS: ReadonlyMap<number, TaskCargoRule> = new Map<
     [TaskType.SHUTTLE, 'none'],
     [TaskType.LOAD, 'all-in'],
     [TaskType.UNWRAP, 'all-in'],
-    [TaskType.DEPOT_TAKE, 'all-in'],
+    [TaskType.CIVIC_WITHDRAW, 'all-in'],
     [TaskType.UNLOAD, 'all-out'],
     [TaskType.UPGRADE, 'all-out'],
     [TaskType.CONTRIBUTE, 'all-out'],
-    [TaskType.DEPOT_STORE, 'all-out'],
+    [TaskType.CIVIC_DEPOSIT, 'all-out'],
     [TaskType.GATHER, 'gather'],
     [TaskType.CRAFT, 'craft'],
     [TaskType.UNDEPLOY, 'undeploy'],

package/src/types.ts

@@ -74,8 +74,12 @@ export enum TaskType {
     SHUTTLE = 18,
     REFIT = 19,
     CONTRIBUTE = 20,
+    /** @deprecated Renamed to CIVIC_DEPOSIT. */
     DEPOT_STORE = 21,
+    /** @deprecated Renamed to CIVIC_WITHDRAW. */
     DEPOT_TAKE = 22,
+    CIVIC_DEPOSIT = 21,
+    CIVIC_WITHDRAW = 22,
 }
 
 export enum RefitOp {