@shipload/sdk 1.0.0-next.71 → 1.0.0-next.73

package/src/derivation/capability-mappings.ts

@@ -4,7 +4,7 @@ import {getRecipe, type Recipe} from '../data/recipes-runtime'
 import {getItem} from '../data/catalog'
 import {
     ITEM_ENGINE_T1,
-    ITEM_EXTRACTOR_T1_PACKED,
+    ITEM_EXTRACTOR_T2_PACKED,
     ITEM_GENERATOR_T1,
     ITEM_GATHERER_T1,
     ITEM_LOADER_T1,
@@ -16,7 +16,7 @@ import {
     ITEM_BATTERY_T1,
     ITEM_SHIP_T1_PACKED,
     ITEM_CONTAINER_T1_PACKED,
-    ITEM_WAREHOUSE_T1_PACKED,
+    ITEM_WAREHOUSE_T2_PACKED,
     ITEM_CONTAINER_T2_PACKED,
 } from '../data/item-ids'
 import type {StatMapping, CapabilityAttributeRow} from '../data/capabilities'
@@ -35,8 +35,8 @@ export const KIND_TO_ITEM_ID: Record<SlotConsumerKind, number> = {
     battery: ITEM_BATTERY_T1,
     'ship-t1': ITEM_SHIP_T1_PACKED,
     'container-t1': ITEM_CONTAINER_T1_PACKED,
-    'warehouse-t1': ITEM_WAREHOUSE_T1_PACKED,
-    'extractor-t1': ITEM_EXTRACTOR_T1_PACKED,
+    'warehouse-t2': ITEM_WAREHOUSE_T2_PACKED,
+    'extractor-t2': ITEM_EXTRACTOR_T2_PACKED,
     'container-t2': ITEM_CONTAINER_T2_PACKED,
 }
 

package/src/derivation/capacity-fn-registry.test.ts

@@ -0,0 +1,9 @@
+import {expect, test} from 'bun:test'
+import {resolveCapacityFnName} from './capacity-fn-registry'
+import kindRegistryJson from '../data/kind-registry.json'
+
+test('every template in the catalog resolves to a known capacity function', () => {
+    for (const t of kindRegistryJson.templates as {itemId: number}[]) {
+        expect(() => resolveCapacityFnName(t.itemId)).not.toThrow()
+    }
+})

package/src/derivation/capacity-fn-registry.ts

@@ -0,0 +1,18 @@
+import {getBaseCapacityFnName} from '../data/kind-registry'
+
+export const CAPACITY_FN_NAMES = ['ship', 'warehouse', 'depot', 'container', 'workshop'] as const
+
+export type CapacityFnName = (typeof CAPACITY_FN_NAMES)[number]
+
+function isCapacityFnName(name: string): name is CapacityFnName {
+    return (CAPACITY_FN_NAMES as readonly string[]).includes(name)
+}
+
+export function resolveCapacityFnName(itemId: number): CapacityFnName | undefined {
+    const name = getBaseCapacityFnName(itemId)
+    if (!name) return undefined
+    if (!isCapacityFnName(name)) {
+        throw new Error(`unrecognized base capacity function "${name}" for item ${itemId}`)
+    }
+    return name
+}

package/src/derivation/recipe-usage.test.ts

@@ -7,6 +7,7 @@ import {
 } from './recipe-usage'
 import {
     ITEM_SENSOR,
+    ITEM_SENSOR_T2,
     ITEM_RESIN,
     ITEM_FRAME,
     ITEM_PLATE,
@@ -14,7 +15,7 @@ import {
     ITEM_GATHERER_T1,
     ITEM_CRAFTER_T1,
     ITEM_BUILDER_T1,
-    ITEM_EXTRACTOR_T1_PACKED,
+    ITEM_EXTRACTOR_T2_PACKED,
     ITEM_ROUSTABOUT_T1A_PACKED,
     ITEM_PROSPECTOR_T1A_PACKED,
     ITEM_TENDER_T1A_PACKED,
@@ -32,12 +33,7 @@ test('getRecipeConsumers lists every recipe that consumes Sensor', () => {
     const consumers = getRecipeConsumers(ITEM_SENSOR)
     const ids = consumers.map((c) => c.outputItemId).sort((a, b) => a - b)
     expect(ids).toEqual(
-        [
-            ITEM_CRAFTER_T1,
-            ITEM_BUILDER_T1,
-            ITEM_EXTRACTOR_T1_PACKED,
-            ITEM_ROUSTABOUT_T1A_PACKED,
-        ].sort((a, b) => a - b)
+        [ITEM_CRAFTER_T1, ITEM_BUILDER_T1, ITEM_ROUSTABOUT_T1A_PACKED].sort((a, b) => a - b)
     )
 })
 
@@ -52,8 +48,8 @@ test('Frame feeds the gatherer drain stat', () => {
 })
 
 test('Sensor is a mass-only sink in the Extractor recipe', () => {
-    const consumers = getRecipeConsumers(ITEM_SENSOR)
-    const extractor = consumers.find((c) => c.outputItemId === ITEM_EXTRACTOR_T1_PACKED)
+    const consumers = getRecipeConsumers(ITEM_SENSOR_T2)
+    const extractor = consumers.find((c) => c.outputItemId === ITEM_EXTRACTOR_T2_PACKED)
     expect(extractor).toBeDefined()
     expect(extractor?.statFlows).toHaveLength(0)
 })
@@ -80,9 +76,9 @@ test('getResourceDemand scales by quantity', () => {
     expect(getResourceDemand(ITEM_PLATE, 3)).toEqual({ore: 30})
 })
 
-test('getComponentDemand reports Resin as consumed by eight recipes', () => {
+test('getComponentDemand reports Resin as consumed by seven recipes', () => {
     const demand = getComponentDemand()
     const resin = demand.find((d) => d.itemId === ITEM_RESIN)
     expect(resin).toBeDefined()
-    expect(resin?.consumerCount).toBe(8)
+    expect(resin?.consumerCount).toBe(7)
 })

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

@@ -57,6 +57,7 @@ export {
     computeFreeCells,
     NftManager,
     BalancesManager,
+    FundManager,
     ConstructionManager,
     JobsManager,
     InfluenceManager,
@@ -80,6 +81,9 @@ export type {
     NftConfigForItem,
     WrapConfig,
     WrapGate,
+    FundBeneficiary,
+    FundToken,
+    FundAccrued,
     DepositConfig,
     PlatformBalance,
     TokenBalance,
@@ -120,6 +124,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 {
@@ -370,12 +376,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,
@@ -413,6 +425,7 @@ export {
     ENTITY_NEXUS,
     ENTITY_HUB,
     ENTITY_DEPOT,
+    ENTITY_ASSEMBLY_YARD,
     getEntityClass,
     getPackedEntityType,
     getKindMeta,
@@ -438,6 +451,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

@@ -610,6 +610,18 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    blenddepot(
+        depotId: UInt64Type,
+        owner: NameType,
+        inputs: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action {
+        return this.server.action('blenddepot', {
+            depot_id: UInt64.from(depotId),
+            owner: Name.from(owner),
+            inputs,
+        })
+    }
+
     deploy(
         entityId: UInt64Type,
         ref: ServerContract.ActionParams.Type.cargo_ref,
@@ -1038,6 +1050,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/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/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)
 })

package/src/resolution/resolve-item.ts

@@ -4,7 +4,7 @@ import type {ResourceCategory} from '../types'
 import {getItem, getModules} from '../data/catalog'
 import {ENTITY_SHIP, getPackedEntityType} from '../data/kind-registry'
 import {getEntityLayout} from '../data/recipes-runtime'
-import {entityMetadata, itemMetadata} from '../data/metadata'
+import {entityMetadata, getItemFamily} from '../data/metadata'
 import {
     getModuleCapabilityType,
     isModuleItem,
@@ -370,7 +370,7 @@ function resolveEntity(
                     modName = modItem.name
                     modTier = modItem.tier
                 } catch {
-                    modName = itemMetadata[modItemId]?.name ?? 'Module'
+                    modName = getItemFamily(modItemId)?.name ?? 'Module'
                 }
                 const group = computeCapabilityGroup(modType, decodedStats, modTier, slot.outputPct)
                 return {

package/src/scheduling/unwrap.test.ts

@@ -5,8 +5,14 @@ import {
     unwrapLoadDuration,
     estimateUnwrapDuration,
     incomingHoldMass,
+    projectCargomass,
     projectedPeakCargomass,
 } from './unwrap'
+import {TimePoint, UInt8, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {getItem} from '../data/catalog'
+import {ITEM_BEAM} from '../data/item-ids'
+import {TaskType} from '../types'
 
 describe('unwrap duration mirror', () => {
     test('derivedLoaders aggregates lanes like derived_loaders()', () => {
@@ -84,3 +90,57 @@ test('projectedPeakCargomass tracks the running peak from cargomass', () => {
     // No pending tasks: peak = base + candidate add.
     expect(projectedPeakCargomass(entity, new Date(0), 500)).toBe(1500)
 })
+
+const DEPOSIT_START = new Date('2026-09-20T07:48:37.000Z')
+const BEAM_QTY = 2_500
+const BEAM_MASS = getItem(ITEM_BEAM).mass
+
+function unloadingShip(projectedAtMs?: number) {
+    const cargo = ServerContract.Types.cargo_item.from({
+        item_id: UInt16.from(ITEM_BEAM),
+        quantity: UInt32.from(BEAM_QTY),
+        stats: UInt64.from(0),
+        modules: [],
+    })
+    const lane = ServerContract.Types.lane.from({
+        lane_key: UInt8.from(0),
+        schedule: ServerContract.Types.schedule.from({
+            started: TimePoint.fromMilliseconds(DEPOSIT_START.getTime()),
+            tasks: [
+                ServerContract.Types.task.from({
+                    type: UInt8.from(TaskType.CIVIC_DEPOSIT),
+                    duration: UInt32.from(1_309),
+                    cancelable: UInt8.from(2),
+                    cargo: [cargo],
+                    couplings: [],
+                }),
+            ],
+        }),
+    })
+    return {
+        cargomass: BEAM_QTY * BEAM_MASS,
+        lanes: [lane],
+        holds: [],
+        projected_at:
+            projectedAtMs === undefined ? undefined : TimePoint.fromMilliseconds(projectedAtMs),
+    }
+}
+
+const UNLOAD_ENDS = new Date(DEPOSIT_START.getTime() + 1_309_000)
+const AFTER_UNLOAD = new Date(UNLOAD_ENDS.getTime() + 60_000)
+
+test('projectCargomass reports the mass held at the candidate and the peak around it', () => {
+    const plan = projectCargomass(unloadingShip(), AFTER_UNLOAD, 400 * BEAM_MASS)
+    // The queued unload empties the hold before the candidate lands.
+    expect(plan.used).toBe(400 * BEAM_MASS)
+    expect(plan.peak).toBe(BEAM_QTY * BEAM_MASS)
+})
+
+test('a task already applied to a projected row is not replayed', () => {
+    const applied = unloadingShip(UNLOAD_ENDS.getTime())
+    applied.cargomass = 0
+    const plan = projectCargomass(applied, AFTER_UNLOAD, 400 * BEAM_MASS)
+    expect(plan.used).toBe(400 * BEAM_MASS)
+    expect(plan.peak).toBe(400 * BEAM_MASS)
+    expect(projectedPeakCargomass(applied, AFTER_UNLOAD, 400 * BEAM_MASS)).toBe(plan.peak)
+})

package/src/scheduling/unwrap.ts

@@ -133,28 +133,44 @@ function cargoListMass(items: CargoItem[]): number {
     return m
 }
 
-export function projectedPeakCargomass(
-    entity: sched.ScheduleData & {cargomass: number | {toNumber(): number}},
+export interface CargomassProjection {
+    used: number
+    peak: number
+}
+
+export function projectCargomass(
+    entity: sched.AnchoredScheduleData & {cargomass: number | {toNumber(): number}},
     at: Date,
     addMass: number,
     removeMass = 0
-): number {
-    const events: {t: number; delta: number}[] = []
-    for (const ordered of sched.orderedTasks(entity)) {
+): CargomassProjection {
+    const events: {t: number; delta: number; candidate: boolean}[] = []
+    for (const ordered of sched.unappliedTasks(entity)) {
         const eff = taskCargoEffect(ordered.task)
         const delta = cargoListMass(eff.added) - cargoListMass(eff.removed)
-        events.push({t: ordered.completesAt.getTime(), delta})
+        events.push({t: ordered.completesAt.getTime(), delta, candidate: false})
     }
-    events.push({t: at.getTime(), delta: addMass - removeMass})
+    events.push({t: at.getTime(), delta: addMass - removeMass, candidate: true})
     events.sort((a, b) => (a.t !== b.t ? a.t - b.t : b.delta - a.delta))
     let running = Number(entity.cargomass)
     let peak = running
+    let used = running
     for (const e of events) {
         running += e.delta
         if (running < 0) running = 0
         if (running > peak) peak = running
+        if (e.candidate) used = running
     }
-    return Math.min(peak, 0xffff_ffff)
+    return {used: Math.min(used, 0xffff_ffff), peak: Math.min(peak, 0xffff_ffff)}
+}
+
+export function projectedPeakCargomass(
+    entity: sched.AnchoredScheduleData & {cargomass: number | {toNumber(): number}},
+    at: Date,
+    addMass: number,
+    removeMass = 0
+): number {
+    return projectCargomass(entity, at, addMass, removeMass).peak
 }
 
 export function receiveFits(

package/src/shipload.ts

@@ -13,6 +13,7 @@ import type {ActionsManager} from './managers/actions'
 import type {ClusterManager} from './managers/cluster'
 import type {NftManager} from './managers/nft'
 import type {BalancesManager} from './managers/balances'
+import type {FundManager} from './managers/fund'
 import type {JobsManager} from './managers/jobs'
 import type {InfluenceManager} from './managers/influence'
 import type {SubscriptionsManager} from './subscriptions/manager'
@@ -154,6 +155,10 @@ export class Shipload {
         return this._context.nft
     }
 
+    get funds(): FundManager {
+        return this._context.funds
+    }
+
     get balances(): BalancesManager {
         return this._context.balances
     }

package/src/types.ts

@@ -208,6 +208,7 @@ export const CATEGORY_LABELS: Record<ResourceCategory, string> = {
 
 export interface Item {
     id: number
+    family: string
     name: string
     description: string
     color: string