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

package/src/index-module.ts

@@ -35,13 +35,9 @@ export type cargo_item = ServerContract.Types.cargo_item
 export type entity_row = ServerContract.Types.entity_row
 export type craftjob_row = ServerContract.Types.craftjob_row
 export type buildjob_row = ServerContract.Types.buildjob_row
-export type booking_receipt = ServerContract.Types.booking_receipt
-export {
-    decodeBookingReceipt,
-    bookingReceiptLandsAtMs,
-    bookingReceiptRuntimeSeconds,
-} from './receipts'
-export type {BookingReceipt} from './receipts'
+export type window_receipt = ServerContract.Types.window_receipt
+export {decodeWindowReceipt, windowReceiptStartsAtMs, windowReceiptCompletesAtMs} from './receipts'
+export type {WindowReceipt} from './receipts'
 
 export type location_static = ServerContract.Types.location_static
 export type location_derived = ServerContract.Types.location_derived
@@ -61,6 +57,7 @@ export {
     computeFreeCells,
     NftManager,
     BalancesManager,
+    FundManager,
     ConstructionManager,
     JobsManager,
     InfluenceManager,
@@ -84,6 +81,9 @@ export type {
     NftConfigForItem,
     WrapConfig,
     WrapGate,
+    FundBeneficiary,
+    FundToken,
+    FundAccrued,
     DepositConfig,
     PlatformBalance,
     TokenBalance,
@@ -289,6 +289,7 @@ export type {
 } from './scheduling/schedule'
 export {
     candidateLaneCompletesAt,
+    candidateCivicDepositWindow,
     laneKeyForModule,
     rawScheduleEnd,
     resolveLaneGatherer,
@@ -335,10 +336,27 @@ export {
     JOB_QUEUE_CAP,
     jobStatus,
     jobStatusLabel,
+    jobDropoffTask,
+    jobCancelRoute,
+    buildJobCancelRoute,
+    jobCancellable,
+    jobCancellationBlockReason,
     jobDeposited,
     splitJobCargo,
+    workshopAvailability,
+    pickupsInFlight,
+} from './scheduling/jobs'
+export type {
+    JobWindow,
+    JobLane,
+    JobLaneEntry,
+    JobStatus,
+    JobStatusInput,
+    JobCancelRoute,
+    JobCancellationBlockReason,
+    OwnedJob,
+    PickupInFlight,
 } from './scheduling/jobs'
-export type {JobWindow, JobLane, JobLaneEntry, JobStatus, OwnedJob} from './scheduling/jobs'
 
 export {composeIdleResolve} from './scheduling/idle-resolve'
 export type {CounterpartLookup, IdleResolveTarget} from './scheduling/idle-resolve'
@@ -399,6 +417,7 @@ export {
     ENTITY_NEXUS,
     ENTITY_HUB,
     ENTITY_DEPOT,
+    ENTITY_ASSEMBLY_YARD,
     getEntityClass,
     getPackedEntityType,
     getKindMeta,
@@ -424,6 +443,7 @@ export {
     isPlot,
     isHub,
     isDepot,
+    isAssemblyYard,
 } from './data/kind-registry'
 export type {EntityTypeName, KindMeta, TemplateMeta} from './data/kind-registry'
 export * from './capabilities'

package/src/influence/influence.test.ts

@@ -136,7 +136,7 @@ describe('decomposition', () => {
         for (let i = 1; i < DECOMP_REGISTRY.length; i++) {
             expect(DECOMP_REGISTRY[i].itemId).toBeGreaterThan(DECOMP_REGISTRY[i - 1].itemId)
         }
-        expect(DECOMP_REGISTRY.length).toBe(56)
+        expect(DECOMP_REGISTRY.length).toBe(57)
     })
 
     test('the retired Workshop has no decomposition entry', () => {

package/src/managers/actions.ts

@@ -24,6 +24,7 @@ import {Coordinates, PRECISION, type ClusterSlotType, type CoordinatesType} from
 import {ServerContract, TokenContract} from '../contracts'
 import {ATOMICASSETS_ABI, SHIPLOAD_COLLECTION} from '../nft/atomicassets'
 import {getItem} from '../data/catalog'
+import type {JobCancelRoute} from '../scheduling/jobs'
 
 const CHARGE_K = 100n
 const ENERGY_DIVISOR = 10n
@@ -515,7 +516,6 @@ export class ActionsManager extends BaseManager {
     craftjob(
         shipId: UInt64Type,
         workshopId: UInt64Type,
-        slot: UInt8Type,
         recipeId: UInt16Type,
         quantity: UInt32Type,
         inputs: ServerContract.ActionParams.Type.cargo_item[]
@@ -523,7 +523,6 @@ export class ActionsManager extends BaseManager {
         const params: ServerContract.ActionParams.craftjob = {
             ship_id: UInt64.from(shipId),
             workshop_id: UInt64.from(workshopId),
-            slot: UInt8.from(slot),
             recipe_id: UInt16.from(recipeId),
             quantity: UInt32.from(quantity),
             inputs,
@@ -531,6 +530,19 @@ export class ActionsManager extends BaseManager {
         return this.server.action('craftjob', params)
     }
 
+    cancelcraft(jobId: UInt64Type): Action {
+        const params: ServerContract.ActionParams.cancelcraft = {
+            job_id: UInt64.from(jobId),
+        }
+        return this.server.action('cancelcraft', params)
+    }
+
+    canceljob(route: JobCancelRoute): Action {
+        if (route.kind === 'dropoff') return this.cancel(route.shipId, route.laneKey, route.count)
+        if (route.kind === 'build') return this.cancelbuild(route.jobId)
+        return this.cancelcraft(route.jobId)
+    }
+
     clustercraft(
         entityId: UInt64Type,
         recipeId: number,
@@ -565,14 +577,12 @@ export class ActionsManager extends BaseManager {
     buildjob(
         targetId: UInt64Type,
         dockId: UInt64Type,
-        slot: UInt8Type,
         targetItemId: UInt16Type,
         inputs: ServerContract.ActionParams.Type.cargo_item[]
     ): Action {
         const params: ServerContract.ActionParams.buildjob = {
             target_id: UInt64.from(targetId),
             dock_id: UInt64.from(dockId),
-            slot: UInt8.from(slot),
             target_item_id: UInt16.from(targetItemId),
             inputs,
         }
@@ -1028,6 +1038,11 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    /** Pays every nonzero accrued token balance to the beneficiary. */
+    claimFund(beneficiary: NameType): Action {
+        return this.fund.action('claim', {beneficiary_account: Name.from(beneficiary)})
+    }
+
     collectFund(): Action {
         return this.fund.action('collect', {})
     }

package/src/managers/context.ts

@@ -13,6 +13,7 @@ import {ActionsManager} from './actions'
 import {ClusterManager} from './cluster'
 import {NftManager} from './nft'
 import {BalancesManager} from './balances'
+import {FundManager} from './fund'
 import {JobsManager} from './jobs'
 import {InfluenceManager} from './influence'
 import {SubscriptionsManager} from '../subscriptions/manager'
@@ -27,6 +28,7 @@ export class GameContext {
     private _clusters?: ClusterManager
     private _nft?: NftManager
     private _balances?: BalancesManager
+    private _funds?: FundManager
     private _jobs?: JobsManager
     private _influence?: InfluenceManager
     private _subscriptions?: SubscriptionsManager
@@ -106,6 +108,13 @@ export class GameContext {
         return this._balances
     }
 
+    get funds(): FundManager {
+        if (!this._funds) {
+            this._funds = new FundManager(this)
+        }
+        return this._funds
+    }
+
     get jobs(): JobsManager {
         if (!this._jobs) {
             this._jobs = new JobsManager(this)

package/src/managers/fund.ts

@@ -0,0 +1,49 @@
+import {type Asset, Name, type NameType, type UInt16} from '@wharfkit/antelope'
+import type {FundContract} from '../contracts'
+import type {PlatformBalance} from './balances'
+import {BaseManager} from './base'
+
+export interface FundBeneficiary {
+    account: Name
+    bps: UInt16
+}
+
+export interface FundToken {
+    tokenContract: Name
+    symbol: Asset.Symbol
+}
+
+export interface FundAccrued {
+    tokenContract: Name
+    balance: Asset
+}
+
+/** Live fund ledger reads. Token custody can exceed the amounts accrued to beneficiaries. */
+export class FundManager extends BaseManager {
+    async getBeneficiaries(): Promise<FundBeneficiary[]> {
+        const rows = (await this.fund
+            .table('benefs', this.fund.account)
+            .all()) as FundContract.Types.benef_row[]
+        return rows.map((row) => ({account: row.account, bps: row.bps}))
+    }
+
+    async getTokens(): Promise<FundToken[]> {
+        const rows = (await this.fund
+            .table('tokens', this.fund.account)
+            .all()) as FundContract.Types.token_row[]
+        return rows.map((row) => ({tokenContract: row.token_contract, symbol: row.token_symbol}))
+    }
+
+    /** Includes zero rows and claims for tokens no longer accepted; no rows returns []. */
+    async getAccrued(beneficiary: NameType): Promise<FundAccrued[]> {
+        const rows = (await this.fund
+            .table('accrued', Name.from(beneficiary))
+            .all()) as FundContract.Types.accrued_row[]
+        return rows.map((row) => ({tokenContract: row.token_contract, balance: row.balance}))
+    }
+
+    /** Platform balances that have not reached the fund's accrual ledger yet. */
+    async getUncollected(): Promise<PlatformBalance[]> {
+        return this.context.balances.getPlatformBalances(this.fund.account)
+    }
+}

package/src/managers/index.ts

@@ -44,3 +44,6 @@ export type {
     ScheduledBuild,
     Reservation,
 } from './construction-types'
+
+export {FundManager} from './fund'
+export type {FundBeneficiary, FundToken, FundAccrued} from './fund'

package/src/managers/jobs.test.ts

@@ -12,6 +12,7 @@ const row = (over: Record<string, unknown> = {}) => ({
     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')},
+    arrives_at: {toDate: () => new Date('2026-07-26T09:45:00Z')},
     recipe_id: {toNumber: () => 10001},
     quantity: {toNumber: () => 5},
     energy_paid: {toNumber: () => 0},
@@ -26,37 +27,52 @@ function managerWith(queryImpl: () => Promise<unknown[]>, allImpl: () => Promise
 }
 
 describe('JobsManager.getOwnedJobs', () => {
-    it('parses a landed row: cargo is the output, no inputs, status derived', async () => {
+    it('parses a deposited row: inputs then the output tail, status derived', async () => {
         const m = managerWith(
-            async () => [row()],
+            async () => [row({cargo: [{item: 'in'}, {item: 'out'}]})],
             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, building: 42, quantity: 5, status: 'ready'})
+        expect(jobs[0].arrivesAt).toEqual(new Date('2026-07-26T09:45:00Z'))
         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)
+        expect(jobs[0].inputs).toEqual([{item: 'in'}] 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)},
+    it('reports an undeposited row as dropping off, whatever its window says', async () => {
+        const inFlight = row({
             deposited: false,
             cargo: [{item: 'in'}],
         })
         const m = managerWith(
-            async () => [inLine],
+            async () => [inFlight],
             async () => []
         )
         const jobs = await m.getOwnedJobs(OWNER, {now: new Date('2026-07-26T11:30:00Z')})
-        expect(jobs[0].status).toBe('inline')
+        expect(jobs[0].status).toBe('dropping')
         expect(jobs[0].deposited).toBe(false)
         expect(jobs[0].output).toBeNull()
         expect(jobs[0].inputs).toEqual([{item: 'in'}] as never)
     })
 
+    it('reports a cancelled row as ready with its inputs held', async () => {
+        const cancelled = row({
+            quantity: {toNumber: () => 0},
+            deposited: true,
+            cargo: [{item: 'in'}],
+        })
+        const m = managerWith(
+            async () => [cancelled],
+            async () => []
+        )
+        const jobs = await m.getOwnedJobs(OWNER, {now: new Date('2026-07-26T09:00:00Z')})
+        expect(jobs[0].status).toBe('ready')
+        expect(jobs[0].output).toBeNull()
+        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(

package/src/managers/jobs.ts

@@ -32,19 +32,23 @@ 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 arrivesAt = r.arrives_at.toDate()
         const deposited = jobDeposited(r.deposited)
-        const {output, inputs} = splitJobCargo(r.cargo, deposited)
+        const quantity = r.quantity.toNumber()
+        const building = r.building.toNumber()
+        const {output, inputs} = splitJobCargo(r.cargo, deposited, quantity)
         return {
             id: r.id.toNumber(),
-            building: r.building.toNumber(),
+            building,
             socket: r.socket.toNumber(),
             shipId: r.ship_id.toNumber(),
             coords: {x: r.coords.x.toNumber(), y: r.coords.y.toNumber()},
             startsAt,
             completesAt,
+            arrivesAt,
             recipeId: r.recipe_id.toNumber(),
-            quantity: r.quantity.toNumber(),
-            status: jobStatus({startsAt, completesAt, deposited}, now),
+            quantity,
+            status: jobStatus({startsAt, completesAt, deposited, quantity, building, inputs}, now),
             deposited,
             output,
             inputs,

package/src/nft/description.ts

@@ -32,6 +32,7 @@ import {MASS_UNITS_PER_TONNE, type ModuleType} from '../types'
 import {ENTITY_SHIP, getPackedEntityType} from '../data/kind-registry'
 import {getBaseHullmassFor} from '../derivation/capabilities'
 import {computeEffectiveModuleStat} from '../derivation/stat-scaling'
+import {resolveCapacityFnName, type CapacityFnName} from '../derivation/capacity-fn-registry'
 
 function idiv(a: number, b: number): number {
     return Math.floor(a / b)
@@ -89,24 +90,18 @@ export function computeBaseCapacityDepot(stats: bigint): number {
     return Math.floor(500_000 * 6 ** (s / 1998))
 }
 
-const CAPACITY_FN_BY_KIND: Record<string, (stats: bigint) => number> = {
+const CAPACITY_FN_BY_NAME: Record<CapacityFnName, (stats: bigint) => number> = {
     ship: computeBaseCapacityShip,
     warehouse: computeBaseCapacityWarehouse,
     workshop: computeBaseCapacityWorkshop,
-    extractor: computeBaseCapacityContainer,
-    factory: computeBaseCapacityContainer,
-    builddock: computeBaseCapacityContainer,
-    mdriver: computeBaseCapacityContainer,
-    mcatcher: computeBaseCapacityContainer,
     container: computeBaseCapacityContainer,
-    nexus: computeBaseCapacityContainer,
     depot: computeBaseCapacityDepot,
 }
 
 export function computeBaseCapacityForEntity(itemId: number, stats: bigint): number {
-    const kind = getTemplateMeta(itemId)?.kind
-    if (!kind) return 0
-    return CAPACITY_FN_BY_KIND[kind.toString()]?.(stats) ?? 0
+    const fnName = resolveCapacityFnName(itemId)
+    if (!fnName) return 0
+    return CAPACITY_FN_BY_NAME[fnName](stats)
 }
 
 export const computeEngineThrust = (vol: number, tier: number): number =>

package/src/receipts.ts

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

package/src/resolution/resolve-item.test.ts

@@ -2,11 +2,16 @@ import {expect, test} from 'bun:test'
 import {UInt16, UInt64} from '@wharfkit/antelope'
 import {resolveItem} from './resolve-item'
 import {encodeStats} from '../derivation/crafting'
-import {computeBaseHullmass, computeContainerCapabilities} from '../derivation/capabilities'
 import {
-    ITEM_EXTRACTOR_T1_PACKED,
-    ITEM_FACTORY_T1_PACKED,
-    ITEM_HUB_T1_PACKED,
+    computeBaseHullmass,
+    computeContainerCapabilities,
+    applyCapacityTier,
+} from '../derivation/capabilities'
+import {getItem} from '../data/catalog'
+import {
+    ITEM_EXTRACTOR_T2_PACKED,
+    ITEM_FACTORY_T2_PACKED,
+    ITEM_HUB_T2_PACKED,
     ITEM_MASS_DRIVER_T1_PACKED,
     ITEM_MASS_CATCHER_T1_PACKED,
 } from '../data/item-ids'
@@ -16,8 +21,8 @@ function hullStats(strength: number, density: number, hardness: number): UInt64
 }
 
 const CONTAINER_ENTITIES = [
-    ['factory', ITEM_FACTORY_T1_PACKED],
-    ['extractor', ITEM_EXTRACTOR_T1_PACKED],
+    ['factory', ITEM_FACTORY_T2_PACKED],
+    ['extractor', ITEM_EXTRACTOR_T2_PACKED],
     ['mass driver', ITEM_MASS_DRIVER_T1_PACKED],
     ['mass catcher', ITEM_MASS_CATCHER_T1_PACKED],
 ] as const
@@ -28,21 +33,21 @@ for (const [label, itemId] of CONTAINER_ENTITIES) {
         const resolved = resolveItem(UInt16.from(itemId), stats)
         const hull = resolved.attributes?.find((g) => g.capability === 'Hull')
         const capacity = hull?.attributes.find((a) => a.label === 'Capacity')?.value
-        const expected = computeContainerCapabilities({
+        const base = computeContainerCapabilities({
             strength: 300,
             hardness: 400,
             density: 100,
         }).capacity
-        expect(capacity).toBe(expected)
+        expect(capacity).toBe(applyCapacityTier(base, getItem(itemId).tier))
     })
 }
 
 test('resolveItem resolves the station hub with hullmass and zero cargo capacity', () => {
     const stats = hullStats(300, 100, 400)
-    const resolved = resolveItem(UInt16.from(ITEM_HUB_T1_PACKED), stats)
+    const resolved = resolveItem(UInt16.from(ITEM_HUB_T2_PACKED), stats)
     const hull = resolved.attributes?.find((g) => g.capability === 'Hull')
     expect(hull?.attributes.find((a) => a.label === 'Mass')?.value).toBe(
-        computeBaseHullmass(ITEM_HUB_T1_PACKED, {density: 100})
+        computeBaseHullmass(ITEM_HUB_T2_PACKED, {density: 100})
     )
     expect(hull?.attributes.find((a) => a.label === 'Capacity')?.value).toBe(0)
 })