@shipload/sdk 1.0.0-next.65 → 1.0.0-next.67

package/src/planner/planner.test.ts

@@ -1,8 +1,11 @@
 import {UInt8, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
 import {expect, test, describe} from 'bun:test'
 import {ServerContract} from '../contracts'
+import {encodeStats} from '../derivation/crafting'
+import {ITEM_GATHERER_T1} from '../data/item-ids'
 import {
     planParallelTransfer,
+    planSingleGather,
     type GatherPlanEntity,
     gatherEnergyCost,
     splitCost,
@@ -10,6 +13,19 @@ import {
     buildGatherPlan,
 } from './index'
 
+type ModuleEntry = ServerContract.Types.module_entry
+type Lane = ServerContract.Types.lane
+
+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 gathererLane(
     slotIndex: number,
     yieldVal: number,
@@ -114,7 +130,7 @@ describe('planParallelTransfer', () => {
 
 describe('cost helpers', () => {
     const STRATUM = 100
-    const ITEM_MASS = 1000
+    const ITEM_MASS = 10
     const RICHNESS = 500
 
     test('gatherEnergyCost is 0 for non-positive quantity and positive otherwise', () => {
@@ -152,7 +168,7 @@ describe('buildGatherPlan', () => {
     const STRATUM = 100
     const OPTS = {
         richness: 500,
-        itemMass: 1000,
+        itemMass: 10,
         holdRoom: 1_000_000,
         reserveRemaining: 1_000_000,
         now: NOW,
@@ -332,3 +348,112 @@ describe('buildGatherPlan', () => {
         expect(plan.cycles[0].rechargeSeconds).toBe(0)
     })
 })
+
+describe('planSingleGather', () => {
+    const STRATUM = 100
+    const ITEM_MASS = 1000
+    const RICHNESS = 500
+    const deepStats = encodeStats([100, 900, 100]) // tol=900 => depth=5000 for tier1
+
+    test('mirrors the bot hand-assembly: laneKey, quantity, energyCost match selectGatherLane + maxQtyForCharge + splitCost', () => {
+        const modules: ModuleEntry[] = [makeModuleEntry(ITEM_GATHERER_T1, deepStats)]
+        const lane = gathererLane(0, 700, 1_250_000, 5000)
+
+        const result = planSingleGather({
+            modules,
+            entityItemId: ITEM_GATHERER_T1,
+            lanes: [],
+            gathererLanes: [lane],
+            stratum: STRATUM,
+            desiredQuantity: 100,
+            itemMass: ITEM_MASS,
+            richness: RICHNESS,
+            generatorCapacity: 1_000_000,
+            currentEnergy: 1_000_000,
+        })
+
+        const expectedLaneKey = 1
+        const expectedQuantity = maxQtyForCharge(
+            [lane],
+            100,
+            1_000_000,
+            STRATUM,
+            ITEM_MASS,
+            RICHNESS
+        )
+        const expectedCost = splitCost([lane], expectedQuantity, STRATUM, ITEM_MASS, RICHNESS)
+
+        expect(result.laneKey).toBe(expectedLaneKey)
+        expect(result.quantity).toBe(expectedQuantity)
+        expect(result.energyCost).toBe(expectedCost)
+        expect(result.needsRecharge).toBe(false)
+    })
+
+    test('needsRecharge is true when current energy is below the priced cost', () => {
+        const modules: ModuleEntry[] = [makeModuleEntry(ITEM_GATHERER_T1, deepStats)]
+        const lane = gathererLane(0, 700, 1_250_000, 5000)
+
+        const result = planSingleGather({
+            modules,
+            entityItemId: ITEM_GATHERER_T1,
+            lanes: [],
+            gathererLanes: [lane],
+            stratum: STRATUM,
+            desiredQuantity: 100,
+            itemMass: ITEM_MASS,
+            richness: RICHNESS,
+            generatorCapacity: 1_000_000,
+            currentEnergy: 0,
+        })
+
+        expect(result.energyCost).toBeGreaterThan(0)
+        expect(result.needsRecharge).toBe(true)
+    })
+
+    test('caps quantity to what fits one full charge, same boundary as maxQtyForCharge', () => {
+        const modules: ModuleEntry[] = [makeModuleEntry(ITEM_GATHERER_T1, deepStats)]
+        const lane = gathererLane(0, 700, 1_250_000, 5000)
+        const capacity = 40_000
+
+        const result = planSingleGather({
+            modules,
+            entityItemId: ITEM_GATHERER_T1,
+            lanes: [],
+            gathererLanes: [lane],
+            stratum: STRATUM,
+            desiredQuantity: 100_000,
+            itemMass: ITEM_MASS,
+            richness: RICHNESS,
+            generatorCapacity: capacity,
+            currentEnergy: capacity,
+        })
+
+        expect(
+            splitCost([lane], result.quantity, STRATUM, ITEM_MASS, RICHNESS)
+        ).toBeLessThanOrEqual(capacity)
+        expect(
+            splitCost([lane], result.quantity + 1, STRATUM, ITEM_MASS, RICHNESS)
+        ).toBeGreaterThan(capacity)
+    })
+
+    test('throws when no gatherer lane reaches the stratum, same as selectGatherLane', () => {
+        const shallowStats = encodeStats([100, 10, 100]) // depth=550 for tier1
+        const modules: ModuleEntry[] = [makeModuleEntry(ITEM_GATHERER_T1, shallowStats)]
+        const lane = gathererLane(0, 700, 1_250_000, 550)
+
+        expect(() =>
+            planSingleGather({
+                modules,
+                entityItemId: ITEM_GATHERER_T1,
+                lanes: [] as Lane[],
+                gathererLanes: [lane],
+                stratum: 5000,
+                desiredQuantity: 100,
+                itemMass: ITEM_MASS,
+                richness: RICHNESS,
+                generatorCapacity: 1_000_000,
+                currentEnergy: 1_000_000,
+            })
+        ).toThrow('no gatherer reaches this stratum')
+    })
+})

package/src/resolution/display-name.ts

@@ -50,7 +50,7 @@ export function displayName(item: DisplayNameInput): string {
 export interface DescribeOptions {
     translate?: (key: string) => string
     formatNumber?: (n: number) => string
-    formatMass?: (kg: number) => string
+    formatMass?: (mass: number) => string
 }
 
 export function describeItem(resolved: ResolvedItem, opts?: DescribeOptions): string {

package/src/scheduling/availability.test.ts

@@ -6,6 +6,7 @@ import {
     type CargoInput,
     hasIncomingCoupling,
     hasSourceCoupling,
+    incomingSources,
     type IncomingSource,
     projectedCargoAvailableAt,
     taskCargoEffect,
@@ -202,3 +203,115 @@ describe('clustercraft projection parity', () => {
         expect(eff.added).toEqual([output])
     })
 })
+
+function simpleTask(type: number) {
+    return ServerContract.Types.task.from({
+        type,
+        duration: 60,
+        cancelable: 0,
+        cargo: [cargoItem(401, 0, 100)],
+        couplings: [],
+    })
+}
+
+describe('taskCargoEffect task coverage', () => {
+    test('a contribute removes its cargo', () => {
+        const effect = taskCargoEffect(simpleTask(TaskType.CONTRIBUTE))
+        expect(effect.removed).toHaveLength(1)
+        expect(effect.added).toHaveLength(0)
+    })
+
+    test('a depot store removes its cargo', () => {
+        const effect = taskCargoEffect(simpleTask(TaskType.DEPOT_STORE))
+        expect(effect.removed).toHaveLength(1)
+        expect(effect.added).toHaveLength(0)
+    })
+
+    test('a depot take adds its cargo', () => {
+        const effect = taskCargoEffect(simpleTask(TaskType.DEPOT_TAKE))
+        expect(effect.added).toHaveLength(1)
+        expect(effect.removed).toHaveLength(0)
+    })
+})
+
+describe('incomingSources', () => {
+    const RECEIVER = 1
+    const SENDER = 2
+
+    function receiver(holds: {id: number; kind: number; from: number; until: string}[]) {
+        const e = entity([])
+        return ServerContract.Types.entity_info.from({
+            ...JSON.parse(JSON.stringify(e)),
+            id: RECEIVER,
+            holds: holds.map((h) => ({
+                id: h.id,
+                kind: h.kind,
+                counterpart: {entity_type: 'ship', entity_id: h.from},
+                until: h.until,
+                incoming_mass: 100,
+            })),
+        })
+    }
+
+    function sender(tasks: ReturnType<typeof craftTask>[]) {
+        const e = entity([], [])
+        return ServerContract.Types.entity_info.from({
+            ...JSON.parse(JSON.stringify(e)),
+            id: SENDER,
+            lanes: [{lane_key: 0, schedule: {started: T0, tasks}}],
+        })
+    }
+
+    function coupledTo(hold: number, entityId: number, kind: number) {
+        return ServerContract.Types.coupling.from({
+            counterpart: {entity_type: 'ship', entity_id: entityId},
+            hold,
+            kind,
+        })
+    }
+
+    test('a coupled craft output resolves to the receiving hold', () => {
+        const to = receiver([{id: 1, kind: HoldKind.GATHER, from: SENDER, until: T0}])
+        const from = sender([
+            craftTask(
+                [cargoItem(7, 0, 4), cargoItem(9, 0, 1)],
+                [coupledTo(1, RECEIVER, HoldKind.GATHER)]
+            ),
+        ])
+        const sources = incomingSources(to, () => from)
+        expect(sources).toHaveLength(1)
+        // A craft delivers its output slot alone, never its inputs.
+        expect(sources[0].items).toHaveLength(1)
+        expect(sources[0].items[0].item_id.toNumber()).toBe(9)
+        expect(sources[0].holdId).toBe('1')
+    })
+
+    test('a hold whose counterpart is unknown yields nothing', () => {
+        const to = receiver([{id: 1, kind: HoldKind.GATHER, from: SENDER, until: T0}])
+        expect(incomingSources(to, () => undefined)).toHaveLength(0)
+    })
+
+    test('an excluded hold is skipped', () => {
+        const to = receiver([{id: 1, kind: HoldKind.GATHER, from: SENDER, until: T0}])
+        const from = sender([
+            craftTask([cargoItem(9, 0, 1)], [coupledTo(1, RECEIVER, HoldKind.GATHER)]),
+        ])
+        expect(incomingSources(to, () => from, ['1'])).toHaveLength(0)
+    })
+
+    test('a coupling naming another hold does not fill this one', () => {
+        const to = receiver([{id: 1, kind: HoldKind.GATHER, from: SENDER, until: T0}])
+        const from = sender([
+            craftTask([cargoItem(9, 0, 1)], [coupledTo(2, RECEIVER, HoldKind.GATHER)]),
+        ])
+        expect(incomingSources(to, () => from)).toHaveLength(0)
+    })
+
+    test('an outgoing hold kind is not an incoming source', () => {
+        const to = receiver([{id: 1, kind: HoldKind.PULL, from: SENDER, until: T0}])
+        const from = sender([
+            craftTask([cargoItem(9, 0, 1)], [coupledTo(1, RECEIVER, HoldKind.GATHER)]),
+        ])
+        expect(incomingSources(to, () => from)).toHaveLength(0)
+    })
+})

package/src/scheduling/availability.ts

@@ -1,6 +1,7 @@
 import type {ServerContract} from '../contracts'
 import {HoldKind, TaskType} from '../types'
 import * as schedule from './schedule'
+import {taskCargoRule} from './task-effects'
 
 type Task = ServerContract.Types.task
 type Coupling = ServerContract.Types.coupling
@@ -64,20 +65,59 @@ export function calcCounterpartDelivery(task: Task, coupling: Coupling): CargoIt
     return task.cargo
 }
 
+export interface IncomingHoldEntity extends schedule.ScheduleData {
+    id: {toString(): string}
+    holds?: ServerContract.Types.hold[]
+}
+
+// Mirrors incoming_sources: each incoming hold resolved through the counterpart task that will fill it.
+export function incomingSources(
+    entity: IncomingHoldEntity,
+    findCounterpart: (entityId: string) => schedule.ScheduleData | undefined,
+    excludedHoldIds: readonly string[] = []
+): IncomingSource[] {
+    const out: IncomingSource[] = []
+    const excluded = new Set(excludedHoldIds.map((id) => String(id)))
+    const selfId = entity.id.toString()
+    for (const hold of entity.holds ?? []) {
+        if (!isIncomingCouplingKind(hold.kind.toNumber())) continue
+        const holdId = hold.id.toString()
+        if (excluded.has(holdId)) continue
+        const counterpart = findCounterpart(hold.counterpart.entity_id.toString())
+        if (!counterpart) continue
+        let matched = false
+        for (const lane of counterpart.lanes ?? []) {
+            if (matched) break
+            for (const task of lane.schedule.tasks) {
+                if (matched) break
+                for (const coupling of task.couplings) {
+                    if (coupling.hold.toString() !== holdId) continue
+                    if (coupling.counterpart.entity_id.toString() !== selfId) continue
+                    const items = calcCounterpartDelivery(task, coupling)
+                    if (items.length > 0) {
+                        out.push({holdId, until: hold.until.toDate(), items})
+                    }
+                    matched = true
+                    break
+                }
+            }
+        }
+    }
+    return out
+}
+
 export function taskCargoEffect(task: Task): CargoEffect {
-    switch (task.type.toNumber()) {
-        case TaskType.LOAD:
-        case TaskType.UNWRAP:
-        case TaskType.UNDEPLOY:
+    switch (taskCargoRule(task.type.toNumber())) {
+        case 'all-in':
+        case 'undeploy':
             return {added: task.cargo, removed: []}
-        case TaskType.UNLOAD:
-        case TaskType.UPGRADE:
+        case 'all-out':
             return {added: [], removed: task.cargo}
-        case TaskType.GATHER:
+        case 'gather':
             return task.couplings.length > 0
                 ? {added: [], removed: []}
                 : {added: task.cargo, removed: []}
-        case TaskType.CRAFT: {
+        case 'craft': {
             if (task.cargo.length === 0) return {added: [], removed: []}
             const {clustered, ownOutput} = craftCargoOwnership(task)
             return {

package/src/scheduling/epoch.ts

@@ -10,6 +10,7 @@ export interface EpochInfo {
 export function getCurrentEpoch(game: PlatformContract.Types.game_row): UInt64 {
     const current = new Date().getTime()
     const difference = (current - game.config.start.toMilliseconds()) / 1000
+    if (difference < 0) return UInt64.from(0)
     const epoch = Math.floor(difference / Number(game.config.epochtime)) + 1
     return UInt64.from(epoch)
 }

package/src/scheduling/jobs.ts

@@ -92,7 +92,7 @@ export function splitJobCargo<T>(cargo: readonly T[]): {output: T | null; inputs
 
 export interface OwnedJob {
     id: number
-    workshop: number
+    building: number
     socket: number
     shipId: number
     coords: {x: number; y: number}

package/src/scheduling/projection.ts

@@ -29,6 +29,7 @@ import {
     subtractFromStacks,
     stackToCargoItem,
 } from '../capabilities/storage'
+import {hydrateEntityLanes} from '../entity/hydrate'
 import {craftCargoOwnership} from './availability'
 import * as schedule from './schedule'
 import type {ScheduleData} from './schedule'
@@ -142,21 +143,6 @@ function recomputeCaps(entity: Projectable): ProjectedCaps | undefined {
             output_pct: l.outputPct,
         })
 
-    const toGathererLane = (l: {
-        slotIndex: number
-        yield: number
-        drain: number
-        depth: number
-        outputPct: number
-    }): ServerContract.Types.gatherer_lane =>
-        ServerContract.Types.gatherer_lane.from({
-            slot_index: l.slotIndex,
-            yield: l.yield,
-            drain: l.drain,
-            depth: l.depth,
-            output_pct: l.outputPct,
-        })
-
     const toCrafterLane = (l: {
         slotIndex: number
         speed: number
@@ -191,7 +177,7 @@ function recomputeCaps(entity: Projectable): ProjectedCaps | undefined {
             ? ServerContract.Types.energy_stats.from(caps.generator)
             : undefined,
         loaderLanes: (caps.loaderLanes ?? []).map(toLoaderLane),
-        gathererLanes: (caps.gathererLanes ?? []).map(toGathererLane),
+        gathererLanes: hydrateEntityLanes(caps),
         crafterLanes: (caps.crafterLanes ?? []).map(toCrafterLane),
         builderLanes: (caps.builderLanes ?? []).map(toBuilderLane),
         hauler: caps.hauler

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

@@ -1,6 +1,6 @@
 import {describe, expect, test} from 'bun:test'
 import {ServerContract, TaskType} from '../index-module'
-import {taskCargoChanges} from './task-cargo'
+import {taskCargoChanges, taskCargoChangesChecked} from './task-cargo'
 
 function cargoItem(itemId: number, quantity: number) {
     return ServerContract.Types.cargo_item.from({item_id: itemId, stats: 0, modules: [], quantity})
@@ -42,3 +42,64 @@ 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)
+    })
+})
+
+function simpleTask(type: number) {
+    return ServerContract.Types.task.from({
+        type,
+        duration: 60,
+        cancelable: 0,
+        cargo: [cargoItem(401, 100)],
+        couplings: [],
+    })
+}
+
+describe('taskCargoChanges task coverage', () => {
+    test('a depot store moves cargo out of the entity', () => {
+        const changes = taskCargoChanges(simpleTask(TaskType.DEPOT_STORE))
+        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))
+        expect(changes).toHaveLength(1)
+        expect(changes[0].direction).toBe('in')
+    })
+
+    test('an upgrade consumes its cargo', () => {
+        const changes = taskCargoChanges(simpleTask(TaskType.UPGRADE))
+        expect(changes).toHaveLength(1)
+        expect(changes[0].direction).toBe('out')
+    })
+
+    test('an undeploy returns cargo to the entity', () => {
+        const changes = taskCargoChanges(simpleTask(TaskType.UNDEPLOY))
+        expect(changes).toHaveLength(1)
+        expect(changes[0].direction).toBe('in')
+    })
+})
+
+describe('taskCargoChangesChecked', () => {
+    test('reports a known task type with its changes', () => {
+        const result = taskCargoChangesChecked(simpleTask(TaskType.DEPOT_TAKE))
+        expect(result.known).toBe(true)
+        if (result.known) expect(result.changes[0].direction).toBe('in')
+    })
+
+    test('distinguishes an unrecognised task type from one that moves nothing', () => {
+        const unknown = taskCargoChangesChecked(simpleTask(99))
+        expect(unknown.known).toBe(false)
+        if (!unknown.known) expect(unknown.taskType).toBe(99)
+
+        const travel = taskCargoChangesChecked(simpleTask(TaskType.TRAVEL))
+        expect(travel.known).toBe(true)
+        if (travel.known) expect(travel.changes).toHaveLength(0)
+    })
+})

package/src/scheduling/task-cargo.ts

@@ -1,5 +1,5 @@
 import type {ServerContract} from '../contracts'
-import {TaskType} from '../types'
+import {type TaskCargoRule, taskCargoRule} from './task-effects'
 
 export type TaskCargoDirection = 'in' | 'out'
 
@@ -11,6 +11,10 @@ export interface TaskCargoChange {
     quantity: number
 }
 
+export type TaskCargoResult =
+    | {known: true; changes: TaskCargoChange[]}
+    | {known: false; taskType: number}
+
 function toChange(
     item: ServerContract.Types.cargo_item,
     direction: TaskCargoDirection
@@ -24,19 +28,18 @@ function toChange(
     }
 }
 
-export function taskCargoChanges(task: ServerContract.Types.task): TaskCargoChange[] {
+function changesForRule(rule: TaskCargoRule, task: ServerContract.Types.task): TaskCargoChange[] {
     const items = task.cargo ?? []
     if (items.length === 0) return []
-    switch (Number(task.type)) {
-        case TaskType.LOAD:
-        case TaskType.UNWRAP:
+    switch (rule) {
+        case 'all-in':
+        case 'undeploy':
             return items.map((i) => toChange(i, 'in'))
-        case TaskType.GATHER:
-            return task.couplings.length > 0 ? [] : items.map((i) => toChange(i, 'in'))
-        case TaskType.UNLOAD:
-        case TaskType.CONTRIBUTE:
+        case 'all-out':
             return items.map((i) => toChange(i, 'out'))
-        case TaskType.CRAFT:
+        case 'gather':
+            return task.couplings.length > 0 ? [] : items.map((i) => toChange(i, 'in'))
+        case 'craft':
             return [
                 ...items.slice(0, -1).map((i) => toChange(i, 'out')),
                 ...(task.couplings.length > 0 ? [] : [toChange(items[items.length - 1], 'in')]),
@@ -45,3 +48,15 @@ export function taskCargoChanges(task: ServerContract.Types.task): TaskCargoChan
             return []
     }
 }
+
+export function taskCargoChanges(task: ServerContract.Types.task): TaskCargoChange[] {
+    const rule = taskCargoRule(Number(task.type))
+    return rule ? changesForRule(rule, task) : []
+}
+
+export function taskCargoChangesChecked(task: ServerContract.Types.task): TaskCargoResult {
+    const type = Number(task.type)
+    const rule = taskCargoRule(type)
+    if (!rule) return {known: false, taskType: type}
+    return {known: true, changes: changesForRule(rule, task)}
+}

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

@@ -0,0 +1,35 @@
+import {describe, expect, test} from 'bun:test'
+import {TaskType} from '../types'
+import {taskCargoRule} from './task-effects'
+
+describe('taskCargoRule', () => {
+    test('maps the task types that move cargo out of the entity', () => {
+        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')
+    })
+
+    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')
+    })
+
+    test('maps the conditional task types to their own rules', () => {
+        expect(taskCargoRule(TaskType.GATHER)).toBe('gather')
+        expect(taskCargoRule(TaskType.CRAFT)).toBe('craft')
+        expect(taskCargoRule(TaskType.UNDEPLOY)).toBe('undeploy')
+    })
+
+    test('maps the task types that move no cargo', () => {
+        expect(taskCargoRule(TaskType.TRAVEL)).toBe('none')
+        expect(taskCargoRule(TaskType.RECHARGE)).toBe('none')
+        expect(taskCargoRule(TaskType.DEMOLISH)).toBe('none')
+        expect(taskCargoRule(TaskType.BUILDPLOT)).toBe('none')
+    })
+
+    test('returns undefined for a task type the table does not know', () => {
+        expect(taskCargoRule(99)).toBeUndefined()
+    })
+})

package/src/scheduling/task-effects.ts

@@ -0,0 +1,34 @@
+import {TaskType} from '../types'
+
+export type TaskCargoRule = 'none' | 'all-in' | 'all-out' | 'gather' | 'craft' | 'undeploy'
+
+// Transcribed from the switch in contracts/src/server/src/projection.cpp.
+export const TASK_CARGO_EFFECTS: ReadonlyMap<number, TaskCargoRule> = new Map<
+    number,
+    TaskCargoRule
+>([
+    [TaskType.IDLE, 'none'],
+    [TaskType.TRAVEL, 'none'],
+    [TaskType.RECHARGE, 'none'],
+    [TaskType.WARP, 'none'],
+    [TaskType.TRANSIT, 'none'],
+    [TaskType.LAUNCH, 'none'],
+    [TaskType.DEMOLISH, 'none'],
+    [TaskType.BUILDPLOT, 'none'],
+    [TaskType.CHARGE, 'none'],
+    [TaskType.SHUTTLE, 'none'],
+    [TaskType.LOAD, 'all-in'],
+    [TaskType.UNWRAP, 'all-in'],
+    [TaskType.DEPOT_TAKE, 'all-in'],
+    [TaskType.UNLOAD, 'all-out'],
+    [TaskType.UPGRADE, 'all-out'],
+    [TaskType.CONTRIBUTE, 'all-out'],
+    [TaskType.DEPOT_STORE, 'all-out'],
+    [TaskType.GATHER, 'gather'],
+    [TaskType.CRAFT, 'craft'],
+    [TaskType.UNDEPLOY, 'undeploy'],
+])
+
+export function taskCargoRule(taskType: number): TaskCargoRule | undefined {
+    return TASK_CARGO_EFFECTS.get(taskType)
+}

package/src/scheduling/unwrap.test.ts

@@ -20,9 +20,9 @@ describe('unwrap duration mirror', () => {
     })
 
     test('transit floors distance then flight time', () => {
-        // distance = floor(sqrt(3^2+4^2)*10000)=50000; accel=400/mass*10000; flight=floor(2*sqrt(d/accel))
+        // distance = floor(sqrt(3^2+4^2)*10000)=50000; accel=400/(mass*100)*10000; flight=floor(2*sqrt(d/accel))
         const mass = 1000
-        const accel = (400 / mass) * 10000
+        const accel = (400 / (mass * 100)) * 10000
         const expected = Math.floor(2 * Math.sqrt(50000 / accel))
         expect(unwrapTransitDuration(mass, {x: 0, y: 0}, {x: 3, y: 4})).toBe(expected)
     })
@@ -30,7 +30,7 @@ describe('unwrap duration mirror', () => {
     test('load uses altitude z, adds loader mass, divides by quantity', () => {
         const loaders = {mass: 1200, thrust: 30, quantity: 2}
         const itemMass = 800
-        const accel = (30 / (itemMass + 1200)) * 10000
+        const accel = (30 / ((itemMass + 1200) * 100)) * 10000
         const flight = Math.floor(2 * Math.sqrt(3000 / accel))
         expect(unwrapLoadDuration(loaders, itemMass, 3000)).toBe(Math.floor(flight / 2))
     })

package/src/scheduling/unwrap.ts

@@ -1,13 +1,13 @@
 import type {UInt16Type, UInt32Type} from '@wharfkit/antelope'
 import {calcCargoItemMass} from '../capabilities/storage'
 import type {ServerContract} from '../contracts'
-import {PRECISION} from '../types'
+import {MASS_STAT_SCALE, PRECISION} from '../types'
 import * as sched from './schedule'
 import {taskCargoEffect} from './availability'
 import {candidateLaneCompletesAt} from './lanes'
 
 const NFT_TRANSIT_THRUST = 400
-const BASELINE_LOADER: DerivedLoaders = {mass: 2000, thrust: 1, quantity: 1}
+const BASELINE_LOADER: DerivedLoaders = {mass: 20, thrust: 1, quantity: 1}
 // ground-level entities (warehouses, z=0) still incur a base orbital climb of load effort
 const MIN_LOAD_Z = 800
 
@@ -37,7 +37,7 @@ export function derivedLoaders(
 
 function acceleration(thrust: number, mass: number): number {
     if (mass <= 0) return 0
-    return (thrust / mass) * PRECISION
+    return (thrust / (mass * MASS_STAT_SCALE)) * PRECISION
 }
 
 function flightTime(distance: number, accel: number): number {