@shipload/sdk 1.0.0-next.72 → 1.0.0-next.74

package/src/data/task-types.json

@@ -0,0 +1,184 @@
+{
+  "types": [
+    {
+      "type": 0,
+      "positionBound": false,
+      "mobility": false,
+      "consumer": false,
+      "isTerminal": false,
+      "capsPlan": false,
+      "cargoEffectResolve": true
+    },
+    {
+      "type": 1,
+      "positionBound": false,
+      "mobility": true,
+      "consumer": false,
+      "isTerminal": false,
+      "capsPlan": false,
+      "cargoEffectResolve": true
+    },
+    {
+      "type": 2,
+      "positionBound": false,
+      "mobility": false,
+      "consumer": false,
+      "isTerminal": false,
+      "capsPlan": false,
+      "cargoEffectResolve": true
+    },
+    {
+      "type": 3,
+      "positionBound": true,
+      "mobility": false,
+      "consumer": false,
+      "isTerminal": false,
+      "capsPlan": false,
+      "cargoEffectResolve": true
+    },
+    {
+      "type": 4,
+      "positionBound": true,
+      "mobility": false,
+      "consumer": true,
+      "isTerminal": false,
+      "capsPlan": false,
+      "cargoEffectResolve": true
+    },
+    {
+      "type": 5,
+      "positionBound": true,
+      "mobility": false,
+      "consumer": false,
+      "isTerminal": false,
+      "capsPlan": false,
+      "cargoEffectResolve": true
+    },
+    {
+      "type": 6,
+      "positionBound": false,
+      "mobility": true,
+      "consumer": false,
+      "isTerminal": false,
+      "capsPlan": false,
+      "cargoEffectResolve": true
+    },
+    {
+      "type": 7,
+      "positionBound": false,
+      "mobility": false,
+      "consumer": true,
+      "isTerminal": false,
+      "capsPlan": false,
+      "cargoEffectResolve": false
+    },
+    {
+      "type": 9,
+      "positionBound": false,
+      "mobility": true,
+      "consumer": false,
+      "isTerminal": false,
+      "capsPlan": false,
+      "cargoEffectResolve": true
+    },
+    {
+      "type": 10,
+      "positionBound": false,
+      "mobility": false,
+      "consumer": false,
+      "isTerminal": false,
+      "capsPlan": false,
+      "cargoEffectResolve": false
+    },
+    {
+      "type": 11,
+      "positionBound": false,
+      "mobility": false,
+      "consumer": false,
+      "isTerminal": true,
+      "capsPlan": true,
+      "cargoEffectResolve": false
+    },
+    {
+      "type": 12,
+      "positionBound": false,
+      "mobility": false,
+      "consumer": false,
+      "isTerminal": false,
+      "capsPlan": false,
+      "cargoEffectResolve": true
+    },
+    {
+      "type": 13,
+      "positionBound": false,
+      "mobility": false,
+      "consumer": false,
+      "isTerminal": true,
+      "capsPlan": true,
+      "cargoEffectResolve": false
+    },
+    {
+      "type": 15,
+      "positionBound": true,
+      "mobility": false,
+      "consumer": false,
+      "isTerminal": false,
+      "capsPlan": false,
+      "cargoEffectResolve": false
+    },
+    {
+      "type": 16,
+      "positionBound": false,
+      "mobility": false,
+      "consumer": false,
+      "isTerminal": false,
+      "capsPlan": false,
+      "cargoEffectResolve": true
+    },
+    {
+      "type": 17,
+      "positionBound": true,
+      "mobility": false,
+      "consumer": true,
+      "isTerminal": false,
+      "capsPlan": false,
+      "cargoEffectResolve": false
+    },
+    {
+      "type": 18,
+      "positionBound": true,
+      "mobility": false,
+      "consumer": false,
+      "isTerminal": false,
+      "capsPlan": false,
+      "cargoEffectResolve": true
+    },
+    {
+      "type": 20,
+      "positionBound": false,
+      "mobility": false,
+      "consumer": true,
+      "isTerminal": false,
+      "capsPlan": false,
+      "cargoEffectResolve": false
+    },
+    {
+      "type": 21,
+      "positionBound": true,
+      "mobility": false,
+      "consumer": true,
+      "isTerminal": false,
+      "capsPlan": false,
+      "cargoEffectResolve": false
+    },
+    {
+      "type": 22,
+      "positionBound": true,
+      "mobility": false,
+      "consumer": false,
+      "isTerminal": false,
+      "capsPlan": false,
+      "cargoEffectResolve": false
+    }
+  ]
+}

package/src/entities/makers.ts

@@ -6,7 +6,7 @@ import {getKindMeta, getTemplateMeta} from '../data/kind-registry'
 import type {EntityTypeName} from '../data/kind-registry'
 import {getEntityLayout} from '../data/recipes-runtime'
 import type {EntitySlot} from '../data/recipes-runtime'
-import {itemMetadata} from '../data/metadata'
+import {getItemFamily} from '../data/metadata'
 import {getItem} from '../data/catalog'
 import {getModuleCapabilityType, moduleAccepts, moduleSlotTypeToCode} from '../capabilities/modules'
 import {computeEntityCapabilities} from '../derivation/capabilities'
@@ -52,7 +52,7 @@ function assignModulesToSlots(
             try {
                 modName = getItem(mod.itemId).name
             } catch {
-                modName = itemMetadata[mod.itemId]?.name ?? `item ${mod.itemId}`
+                modName = getItemFamily(mod.itemId)?.name ?? `item ${mod.itemId}`
             }
             throw new Error(
                 `No compatible slot for module ${modName} (type ${modType}) on ${entityLabel}`

package/src/index-module.ts

@@ -62,6 +62,22 @@ export {
     JobsManager,
     InfluenceManager,
 } from './managers'
+export {
+    ShuttleManager,
+    rankShuttleOptions,
+    shuttleReasonCode,
+    shuttleCandidates,
+    BOOKING_LEVEL_CODES,
+    OMITTED_REASONS,
+} from './managers/shuttle'
+export type {
+    ShuttleMode,
+    ShuttleOption,
+    ShuttleOptions,
+    ShuttleReason,
+    ShuttleReasonCode,
+    CandidateEntity,
+} from './managers/shuttle'
 export type {GridCell, ClusterCell, Cluster} from './managers'
 export type {
     CharterProgress,
@@ -124,6 +140,8 @@ export {
     categoryFromIndex,
     categoryLabelFromIndex,
 } from './data/catalog'
+export {getItemFamily, itemFamilies, itemFamilyKey} from './data/metadata'
+export type {ItemFamily} from './data/metadata'
 export {getCurrentEpoch, getEpochInfo} from './scheduling/epoch'
 export type {EpochInfo} from './scheduling/epoch'
 export {
@@ -339,6 +357,7 @@ export {
     jobDropoffTask,
     jobCancelRoute,
     buildJobCancelRoute,
+    hostedDropoff,
     jobCancellable,
     jobCancellationBlockReason,
     jobDeposited,
@@ -354,7 +373,10 @@ export type {
     JobStatusInput,
     JobCancelRoute,
     JobCancellationBlockReason,
+    JobRouteOptions,
+    HostedLeg,
     OwnedJob,
+    BuildJob,
     PickupInFlight,
 } from './scheduling/jobs'
 
@@ -374,12 +396,18 @@ export {
     derivedLoaders,
     estimateUnwrapDuration,
     incomingHoldMass,
+    projectCargomass,
     projectedPeakCargomass,
     receiveFits,
     unwrapLoadDuration,
     unwrapTransitDuration,
 } from './scheduling/unwrap'
-export type {DerivedLoaders, UnwrapDestination, UnwrapItem} from './scheduling/unwrap'
+export type {
+    CargomassProjection,
+    DerivedLoaders,
+    UnwrapDestination,
+    UnwrapItem,
+} from './scheduling/unwrap'
 
 export {
     projectedCargoAvailableAt,
@@ -392,6 +420,7 @@ export {
     cargoInputKey,
     hasSourceCoupling,
     hasIncomingCoupling,
+    isHostedCivicLeg,
 } from './scheduling/availability'
 export type {CargoInput, IncomingHoldEntity, IncomingSource} from './scheduling/availability'
 
@@ -401,7 +430,7 @@ export {calcClusterIntake, calcClustercraftDuration, INTAKE_RATE} from './capabi
 
 export {maxCraftable} from './capabilities/craftable'
 
-export {energyAtTime} from './scheduling/energy'
+export {energyAtTime, energyDrawsFunded} from './scheduling/energy'
 
 export * from './types/capabilities'
 export * from './types/entity'

package/src/influence/civic-shuttle.test.ts

@@ -12,6 +12,7 @@ import {
     pendingCivicTransfers,
     selectCivicShuttleBay,
     CIVIC_TRANSFER_PER_PLAYER_CAP,
+    type CivicShuttleBay,
 } from './civic-shuttle'
 
 type Lane = ServerContract.Types.lane
@@ -63,6 +64,32 @@ function shuttleTask(senderId: number, receiverId: number, group?: number): Task
     } as unknown as Task
 }
 
+function civicTask(type: number, couplings: unknown[]): Task {
+    return {
+        type: UInt8.from(type),
+        duration: UInt32.from(60),
+        cancelable: UInt8.from(2),
+        cargo: [],
+        couplings,
+    } as unknown as Task
+}
+
+function pullCoupling(id: number) {
+    return {
+        counterpart: {entity_id: UInt64.from(id), entity_type: UInt8.from(1)},
+        hold: UInt64.from(1),
+        kind: UInt8.from(HoldKind.PULL),
+    }
+}
+
+function pushCoupling(id: number) {
+    return {
+        counterpart: {entity_id: UInt64.from(id), entity_type: UInt8.from(1)},
+        hold: UInt64.from(1),
+        kind: UInt8.from(HoldKind.PUSH),
+    }
+}
+
 function makeLane(laneKey: number, tasks: Task[]): Lane {
     return {
         lane_key: UInt8.from(laneKey),
@@ -142,6 +169,13 @@ test('selectCivicShuttleBay takes the first free bay, then the lowest occupied o
     expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, bothBusy, T0)?.laneKey).toBe(1)
 })
 
+test('selectCivicShuttleBay picks the earliest finish, not the first free bay', () => {
+    const modules = depotModules()
+    const lanes = [makeLane(1, [shuttleTask(20, 21)])]
+    const fast = (bay: CivicShuttleBay) => (bay.slotIndex === 0 ? 10 : 500)
+    expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, lanes, T0, fast)?.slotIndex).toBe(0)
+})
+
 test('selectCivicShuttleBay returns nothing when the building has no loaders', () => {
     const modules = [makeModuleEntry(ITEM_STORAGE_T1, storageStats)]
     expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, [], T0)).toBeUndefined()
@@ -190,6 +224,30 @@ test('civicTransfersFrom counts only the ships a player sends from', () => {
     expect(civicTransfersFrom(entity, [99], T0).length).toBe(0)
 })
 
+test('civic legs on bays count toward the player cap', () => {
+    const depot = {
+        lanes: [makeLane(1, [civicTask(TaskType.CIVIC_WITHDRAW, [pushCoupling(7)])])],
+    } as never
+    expect(civicTransfersFrom(depot, [7]).length).toBe(1)
+})
+
+test('a civic deposit leg reports the same player id as sender and receiver', () => {
+    const depot = {
+        lanes: [makeLane(1, [civicTask(TaskType.CIVIC_DEPOSIT, [pullCoupling(7)])])],
+    } as never
+    const [transfer] = pendingCivicTransfers(depot, T0)
+    expect(String(transfer.senderId)).toBe('7')
+    expect(String(transfer.receiverId)).toBe('7')
+})
+
+test('a civic pickup leg is not callable while CANCEL_NEVER', () => {
+    const task = civicTask(TaskType.CIVIC_WITHDRAW, [pushCoupling(7)])
+    ;(task as unknown as {cancelable: unknown}).cancelable = UInt8.from(0)
+    const depot = {lanes: [makeLane(1, [task])]} as never
+    const [transfer] = pendingCivicTransfers(depot, T0)
+    expect(transfer.callable).toBe(false)
+})
+
 test('civicTransfersAtCap trips at the per-player cap', () => {
     const mine = Array.from({length: CIVIC_TRANSFER_PER_PLAYER_CAP}, (_, i) =>
         shuttleTask(20 + i, 50)

package/src/influence/civic-shuttle.ts

@@ -4,7 +4,7 @@ import {getItem} from '../data/catalog'
 import {JOB_QUEUE_CAP} from '../scheduling/jobs'
 import {laneKeyForModule, resolveLaneLoader} from '../scheduling/lanes'
 import {orderedTasks, type ScheduleData} from '../scheduling/schedule'
-import {HoldKind, TaskType} from '../types'
+import {HoldKind, TaskCancelable, TaskType} from '../types'
 
 type CargoItem = ServerContract.Types.cargo_item
 type Lane = ServerContract.Types.lane
@@ -22,7 +22,6 @@ export interface CivicShuttleBay {
     full: boolean
 }
 
-// a landed booking clears during the next civicshuttle, so only unfinished tasks occupy a bay
 function unfinishedTasks(lane: Lane | undefined, now: Date): number {
     if (!lane) return 0
     const startedMs = lane.schedule.started.toDate().getTime()
@@ -64,15 +63,38 @@ export function civicShuttleBays(
     return bays
 }
 
-// Mirrors worker_lane_key_or_mobility for loaders: first free bay, else the lowest bay.
+function laneEndMs(lane: Lane | undefined, nowMs: number): number {
+    if (!lane) return nowMs
+    let endSec = 0
+    for (const task of lane.schedule.tasks) endSec += task.duration.toNumber()
+    return Math.max(nowMs, lane.schedule.started.toDate().getTime() + endSec * 1000)
+}
+
+// Mirrors cargo.cpp pick_civic_bay: earliest finish among bays below the queue cap.
 export function selectCivicShuttleBay(
     modules: ModuleEntry[],
     entityItemId: number,
     lanes: Lane[],
-    now: Date = new Date()
+    now: Date = new Date(),
+    durationFor: (bay: CivicShuttleBay) => number = () => 0,
+    minStart?: Date
 ): CivicShuttleBay | undefined {
     const bays = civicShuttleBays(modules, entityItemId, lanes, now)
-    return bays.find((bay) => bay.queued === 0) ?? bays[0]
+    const nowMs = now.getTime()
+    const floorMs = Math.max(nowMs, minStart?.getTime() ?? nowMs)
+    let best: CivicShuttleBay | undefined
+    let bestEnd = Infinity
+    for (const bay of bays) {
+        if (bay.full) continue
+        const lane = lanes.find((l) => l.lane_key.toNumber() === bay.laneKey)
+        const start = Math.max(laneEndMs(lane, nowMs), floorMs)
+        const end = start + durationFor(bay) * 1000
+        if (end < bestEnd) {
+            best = bay
+            bestEnd = end
+        }
+    }
+    return best ?? bays[0]
 }
 
 export interface PendingCivicTransfer {
@@ -98,7 +120,31 @@ export function pendingCivicTransfers(
     }
     const out: PendingCivicTransfer[] = []
     for (const entry of orderedTasks(entity)) {
-        if (entry.task.type.toNumber() !== TaskType.SHUTTLE) continue
+        const type = entry.task.type.toNumber()
+        if (type === TaskType.CIVIC_DEPOSIT || type === TaskType.CIVIC_WITHDRAW) {
+            const side = entry.task.couplings[0]
+            if (!side) continue
+            const isTail = tailIndex.get(entry.laneKey) === entry.taskIndex
+            const complete = entry.completesAt.getTime() <= now.getTime()
+            out.push({
+                laneKey: entry.laneKey,
+                taskIndex: entry.taskIndex,
+                senderId: side.counterpart.entity_id,
+                receiverId: side.counterpart.entity_id,
+                cargo: entry.task.cargo,
+                startsAt: entry.startsAt,
+                completesAt: entry.completesAt,
+                isTail,
+                complete,
+                callable:
+                    isTail &&
+                    !complete &&
+                    !entry.task.entitygroup &&
+                    entry.task.cancelable.toNumber() !== TaskCancelable.NEVER,
+            })
+            continue
+        }
+        if (type !== TaskType.SHUTTLE) continue
         const pull = entry.task.couplings.find((c) => c.kind.toNumber() === HoldKind.PULL)
         const push = entry.task.couplings.find((c) => c.kind.toNumber() === HoldKind.PUSH)
         if (!pull || !push) continue

package/src/influence/duration.ts

@@ -1,9 +1,4 @@
-import type {NameType} from '@wharfkit/antelope'
-import type {ServerContract} from '../contracts'
-import {getEntityClass} from '../data/kind-registry'
 import {computeLoaderMass, computeLoaderThrust} from '../nft/description'
-import {laneKeyForModule, resolveLaneLoader} from '../scheduling/lanes'
-import {calc_onesided_duration} from '../travel/travel'
 import {MASS_STAT_SCALE, MASS_UNITS_PER_TONNE, PRECISION} from '../types'
 import {CIVIC_LOADER_STAT, CIVIC_LOADER_TIER, DEFAULT_ORBITAL_Z} from './constants'
 
@@ -39,63 +34,3 @@ export function contributeDuration(totalMass: number, altitudeZ = 0): number {
 export function contributeDurationForTonnes(tonnes: number, altitudeZ = 0): number {
     return contributeDuration(Math.floor(tonnes * MASS_UNITS_PER_TONNE), altitudeZ)
 }
-
-export const DEPOT_LOADER_SLOT = 0
-
-export interface DepotTransferParams {
-    depotModules: ServerContract.Types.module_entry[]
-    depotItemId: number
-    depotKind: NameType
-    depotZ: number
-    shipKind: NameType
-    shipZ: number
-    cargoMass: number
-}
-
-// Mirrors depot.cpp: the depot's slot-0 loader drives the transfer; 0 when no loader is installed.
-export function depotTransferDuration(params: DepotTransferParams): number {
-    const loader = resolveLaneLoader(
-        params.depotModules,
-        params.depotItemId,
-        laneKeyForModule(DEPOT_LOADER_SLOT)
-    )
-    if (!loader.valid) return 0
-    return calc_onesided_duration(
-        loader.thrust,
-        loader.mass,
-        params.shipZ,
-        params.depotZ,
-        getEntityClass(params.shipKind),
-        getEntityClass(params.depotKind),
-        params.cargoMass
-    )
-}
-
-export interface CivicDropoffParams {
-    buildingModules: ServerContract.Types.module_entry[]
-    buildingItemId: number
-    buildingKind: NameType
-    buildingZ: number
-    shipKind: NameType
-    shipZ: number
-    cargoMass: number
-}
-
-// Mirrors jobs.cpp craftjob: the building's slot-0 loader when one is installed, the civic loader when none is.
-export function civicDropoffDuration(params: CivicDropoffParams): number {
-    const loader = resolveLaneLoader(
-        params.buildingModules,
-        params.buildingItemId,
-        laneKeyForModule(DEPOT_LOADER_SLOT)
-    )
-    if (!loader.valid) return contributeDuration(params.cargoMass, params.shipZ)
-    return calc_onesided_duration(
-        loader.thrust,
-        loader.mass,
-        params.shipZ,
-        params.buildingZ,
-        getEntityClass(params.shipKind),
-        getEntityClass(params.buildingKind),
-        params.cargoMass
-    )
-}

package/src/influence/index.ts

@@ -26,24 +26,23 @@ export {
 export {
     componentBaseAtomic,
     componentEffortAtomic,
+    explainCargoItem,
     pricingFromWeights,
     resourceValueAtomic,
     valueCargoItem,
     valueContribution,
     weightedQualityAtomic,
+    type CargoValuation,
+    type ComponentValuation,
     type InfluencePricing,
+    type ResourceValuation,
     type ValuedItem,
 } from './valuation'
 export {
-    civicDropoffDuration,
     civicLoader,
     contributeDuration,
     contributeDurationForTonnes,
-    depotTransferDuration,
-    DEPOT_LOADER_SLOT,
-    type CivicDropoffParams,
     type CivicLoaderStats,
-    type DepotTransferParams,
 } from './duration'
 export {
     civicShuttleBays,