@shipload/sdk 2.0.0-rc12 → 2.0.0-rc14

package/src/derivation/crafting.ts

@@ -22,27 +22,27 @@ export interface CategoryStacks {
 }
 
 export function encodeStats(values: number[]): bigint {
-    let seed = 0n
+    let stats = 0n
     for (let i = 0; i < values.length && i < 6; i++) {
-        seed |= BigInt(values[i] & 0x3ff) << BigInt(i * 10)
+        stats |= BigInt(values[i] & 0x3ff) << BigInt(i * 10)
     }
-    return seed
+    return stats
 }
 
-export function decodeStat(seed: bigint, index: number): number {
-    return Number((seed >> BigInt(index * 10)) & 0x3ffn)
+export function decodeStat(stats: bigint, index: number): number {
+    return Number((stats >> BigInt(index * 10)) & 0x3ffn)
 }
 
-export function decodeStats(seed: bigint, count: number): number[] {
-    const stats: number[] = []
+export function decodeStats(stats: bigint, count: number): number[] {
+    const result: number[] = []
     for (let i = 0; i < count; i++) {
-        stats.push(decodeStat(seed, i))
+        result.push(decodeStat(stats, i))
     }
-    return stats
+    return result
 }
 
-function mapStatsToKeys(seed: bigint, statDefs: {key: string}[]): Record<string, number> {
-    const values = decodeStats(seed, statDefs.length)
+function mapStatsToKeys(stats: bigint, statDefs: {key: string}[]): Record<string, number> {
+    const values = decodeStats(stats, statDefs.length)
     const result: Record<string, number> = {}
     for (let i = 0; i < statDefs.length; i++) {
         result[statDefs[i].key] = values[i]
@@ -50,15 +50,15 @@ function mapStatsToKeys(seed: bigint, statDefs: {key: string}[]): Record<string,
     return result
 }
 
-export function decodeCraftedItemStats(itemId: number, seed: bigint): Record<string, number> {
+export function decodeCraftedItemStats(itemId: number, stats: bigint): Record<string, number> {
     const comp = getComponentById(itemId)
-    if (comp) return mapStatsToKeys(seed, comp.stats)
+    if (comp) return mapStatsToKeys(stats, comp.stats)
 
     const entityRecipe = entityRecipes.find((r) => r.packedItemId === itemId)
-    if (entityRecipe) return mapStatsToKeys(seed, entityRecipe.stats)
+    if (entityRecipe) return mapStatsToKeys(stats, entityRecipe.stats)
 
     const moduleRecipe = moduleRecipes.find((r) => r.itemId === itemId)
-    if (moduleRecipe) return mapStatsToKeys(seed, moduleRecipe.stats)
+    if (moduleRecipe) return mapStatsToKeys(stats, moduleRecipe.stats)
 
     return {}
 }
@@ -126,12 +126,12 @@ export function computeEntityStats(
     })
 }
 
-function decodeStackStats(itemId: number, seed: UInt64): Record<string, number> {
+function decodeStackStats(itemId: number, stats: UInt64): Record<string, number> {
     if (itemId >= 10000) {
-        return decodeCraftedItemStats(itemId, BigInt(seed.toString()))
+        return decodeCraftedItemStats(itemId, BigInt(stats.toString()))
     }
-    const raw = deriveResourceStats(BigInt(seed.toString()))
-    return {stat1: raw.stat1, stat2: raw.stat2, stat3: raw.stat3}
+    const s = BigInt(stats.toString())
+    return {stat1: decodeStat(s, 0), stat2: decodeStat(s, 1), stat3: decodeStat(s, 2)}
 }
 
 export const categoryItemMass: Record<string, number> = {
@@ -187,11 +187,11 @@ export function blendCrossGroup(sources: {value: number; weight: number}[]): num
 
 export function blendCargoStacks(
     itemId: number,
-    stacks: {quantity: number; seed: UInt64}[]
+    stacks: {quantity: number; stats: UInt64}[]
 ): UInt64 {
     const decoded = stacks.map((s) => ({
         quantity: s.quantity,
-        stats: decodeStackStats(itemId, s.seed),
+        stats: decodeStackStats(itemId, s.stats),
     }))
     const allKeys = Object.keys(decoded[0]?.stats ?? {})
     const blended = allKeys.map((key) => Math.max(1, Math.min(999, blendStacks(decoded, key))))
@@ -201,23 +201,22 @@ export function blendCargoStacks(
 export interface RecipeSlotInput {
     itemId: number
     category: ResourceCategory | undefined
-    stacks: {quantity: number; seed: bigint}[]
+    stacks: {quantity: number; stats: bigint}[]
 }
 
 function decodeRawStackToCategoryStats(
-    seed: bigint,
+    stats: bigint,
     category: ResourceCategory
 ): Record<string, number> {
-    const raw = deriveResourceStats(seed)
     const defs = getStatDefinitions(category)
     const result: Record<string, number> = {}
-    if (defs[0]) result[defs[0].key] = raw.stat1
-    if (defs[1]) result[defs[1].key] = raw.stat2
-    if (defs[2]) result[defs[2].key] = raw.stat3
+    if (defs[0]) result[defs[0].key] = decodeStat(stats, 0)
+    if (defs[1]) result[defs[1].key] = decodeStat(stats, 1)
+    if (defs[2]) result[defs[2].key] = decodeStat(stats, 2)
     return result
 }
 
-export function computeCraftedOutputSeed(
+export function computeCraftedOutputStats(
     outputItemId: number,
     slotInputs: RecipeSlotInput[]
 ): UInt64 {
@@ -230,8 +229,8 @@ export function computeCraftedOutputSeed(
             const stacks: StackInput[] = slot.stacks.map((s) => ({
                 quantity: s.quantity,
                 stats: slotIsComponent
-                    ? decodeCraftedItemStats(slot.itemId, s.seed)
-                    : decodeRawStackToCategoryStats(s.seed, slot.category!),
+                    ? decodeCraftedItemStats(slot.itemId, s.stats)
+                    : decodeRawStackToCategoryStats(s.stats, slot.category!),
             }))
             categoryStacks.push({category: slot.category, stacks})
         }
@@ -257,7 +256,7 @@ export function computeCraftedOutputSeed(
             for (const s of slot.stacks) {
                 list.push({
                     quantity: s.quantity,
-                    stats: decodeCraftedItemStats(slot.itemId, s.seed),
+                    stats: decodeCraftedItemStats(slot.itemId, s.stats),
                 })
             }
         }
@@ -269,5 +268,20 @@ export function computeCraftedOutputSeed(
         return UInt64.from(encodeStats(ordered))
     }
 
-    throw new Error(`computeCraftedOutputSeed: no recipe found for outputItemId=${outputItemId}`)
+    throw new Error(`computeCraftedOutputStats: no recipe found for outputItemId=${outputItemId}`)
+}
+
+/**
+ * Mirrors the contract's gather-time transform. Takes a deposit's entropy
+ * seed (bigint from deriveStratum), derives stats via weibull hashing, and
+ * returns a UInt64 whose bit-packed form matches what the contract writes
+ * to cargo_item.stats on gather.
+ *
+ * Use this whenever off-chain code simulates a gather (testmap, player
+ * scanners that project cargo outcomes) and needs a value that matches
+ * what on-chain cargo would carry.
+ */
+export function encodeGatheredCargoStats(depositSeed: bigint): UInt64 {
+    const raw = deriveResourceStats(depositSeed)
+    return UInt64.from(encodeStats([raw.stat1, raw.stat2, raw.stat3]))
 }

package/src/derivation/stratum.ts

@@ -89,6 +89,18 @@ export function deriveStratum(
     return {itemId: selectedItemId, seed: seedBigInt, richness, reserve}
 }
 
+/**
+ * Derives the three stat values for a raw resource from a deposit's
+ * entropy seed (hash-based, weibull-transformed).
+ *
+ * **Use only on deposit seeds** — the bigint returned by `deriveStratum`
+ * or carried on a `MassDeposit`. Do NOT call this on a cargo item's
+ * `stats` field; cargo stats are bit-packed and must be read via
+ * `decodeStat` (or `decodeStackStats` for category-mapped output).
+ *
+ * Passing a cargo `stats` value here produces meaningless output
+ * (hash of the packed bits, unrelated to the actual stats).
+ */
 export function deriveResourceStats(seed: bigint): ResourceStats {
     const seedBytes = new Uint8Array(8)
     for (let i = 0; i < 8; i++) {

package/src/entities/container.ts

@@ -13,6 +13,7 @@ export interface ContainerStateInput {
     hullmass: number
     capacity: number
     cargomass?: number
+    cargo?: ServerContract.Types.cargo_item[]
     schedule?: ServerContract.Types.schedule
 }
 

package/src/entities/makers.ts

@@ -1,8 +1,86 @@
-import {Name, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
+import {Name, UInt16, UInt32, UInt64, UInt8} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
-import {Ship, ShipStateInput} from './ship'
-import {Warehouse, WarehouseStateInput} from './warehouse'
+import {PackedModuleInput, Ship, ShipStateInput} from './ship'
+import {computeWarehouseCapabilities, Warehouse, WarehouseStateInput} from './warehouse'
 import {Container, ContainerStateInput} from './container'
+import {
+    getEntitySlotLayout,
+    getModuleRecipeByItemId,
+    ITEM_SHIP_T1_PACKED,
+    ITEM_WAREHOUSE_T1_PACKED,
+} from '../data/recipes'
+import {getModuleCapabilityType, MODULE_STORAGE, moduleAccepts} from '../capabilities/modules'
+import {computeShipCapabilities, computeStorageCapabilities} from './ship-deploy'
+import {decodeCraftedItemStats} from '../derivation/crafting'
+
+function assignModulesToSlots(
+    packedEntityItemId: number,
+    modules: PackedModuleInput[],
+    entityLabel: string
+): ServerContract.Types.module_entry[] {
+    const slots = getEntitySlotLayout(packedEntityItemId)
+    const result: Array<{type: number; installed?: ServerContract.Types.packed_module}> = slots.map(
+        (s) => ({type: s.type, installed: undefined})
+    )
+
+    for (const mod of modules) {
+        const itemId = Number(UInt16.from(mod.itemId).value.toString())
+        const modType = getModuleCapabilityType(itemId)
+        const slotIdx = result.findIndex((r) => !r.installed && moduleAccepts(r.type, modType))
+        if (slotIdx === -1) {
+            const recipe = getModuleRecipeByItemId(itemId)
+            const modName = recipe?.name ?? `item ${itemId}`
+            throw new Error(
+                `No compatible slot for module ${modName} (type ${modType}) on ${entityLabel}`
+            )
+        }
+        result[slotIdx].installed = ServerContract.Types.packed_module.from({
+            item_id: UInt16.from(mod.itemId),
+            stats: UInt64.from(mod.stats),
+        })
+    }
+
+    return result.map((r) =>
+        ServerContract.Types.module_entry.from({
+            type: UInt8.from(r.type),
+            installed: r.installed,
+        })
+    )
+}
+
+function decodePackedInput(m: PackedModuleInput): {itemId: number; stats: bigint} {
+    return {
+        itemId: Number(UInt16.from(m.itemId).value.toString()),
+        stats: BigInt(UInt64.from(m.stats).toString()),
+    }
+}
+
+function computeStorageBonus(
+    decoded: {itemId: number; stats: bigint}[],
+    baseCapacity: number
+): number {
+    let totalBonus = 0
+    for (const m of decoded) {
+        if (getModuleCapabilityType(m.itemId) !== MODULE_STORAGE) continue
+        const stats = decodeCraftedItemStats(m.itemId, m.stats)
+        const {capacityBonus} = computeStorageCapabilities(stats, baseCapacity)
+        totalBonus += capacityBonus
+    }
+    return totalBonus
+}
+
+function deriveShipFromModules(
+    modules: PackedModuleInput[],
+    baseCapacity: number
+): {
+    capabilities: ReturnType<typeof computeShipCapabilities>
+    finalCapacity: number
+} {
+    const decoded = modules.map(decodePackedInput)
+    const capabilities = computeShipCapabilities(decoded)
+    const totalBonus = computeStorageBonus(decoded, baseCapacity)
+    return {capabilities, finalCapacity: baseCapacity + totalBonus}
+}
 
 export function makeShip(state: ShipStateInput): Ship {
     const info: Record<string, unknown> = {
@@ -19,14 +97,32 @@ export function makeShip(state: ShipStateInput): Ship {
         pending_tasks: [],
     }
     if (state.hullmass !== undefined) info.hullmass = UInt32.from(state.hullmass)
-    if (state.capacity !== undefined) info.capacity = UInt32.from(state.capacity)
     if (state.energy !== undefined) info.energy = UInt16.from(state.energy)
-    if (state.engines) info.engines = state.engines
-    if (state.generator) info.generator = state.generator
-    if (state.loaders) info.loaders = state.loaders
     if (state.schedule) info.schedule = state.schedule
+
+    let moduleEntries: ServerContract.Types.module_entry[] = []
+    if (state.modules && state.modules.length > 0) {
+        moduleEntries = assignModulesToSlots(ITEM_SHIP_T1_PACKED, state.modules, 'Ship T1')
+        const {capabilities, finalCapacity} = deriveShipFromModules(
+            state.modules,
+            state.capacity ?? 0
+        )
+        if (capabilities.engines) info.engines = capabilities.engines
+        if (capabilities.generator) info.generator = capabilities.generator
+        if (capabilities.gatherer) info.gatherer = capabilities.gatherer
+        if (capabilities.hauler) info.hauler = capabilities.hauler
+        if (capabilities.loaders) info.loaders = capabilities.loaders
+        if (capabilities.crafter) info.crafter = capabilities.crafter
+        if (state.capacity !== undefined) info.capacity = UInt32.from(finalCapacity)
+    } else {
+        moduleEntries = assignModulesToSlots(ITEM_SHIP_T1_PACKED, [], 'Ship T1')
+        if (state.capacity !== undefined) info.capacity = UInt32.from(state.capacity)
+    }
+
     const entityInfo = ServerContract.Types.entity_info.from(info)
-    return new Ship(entityInfo)
+    const ship = new Ship(entityInfo)
+    ship.setModules(moduleEntries)
+    return ship
 }
 
 export function makeWarehouse(state: WarehouseStateInput): Warehouse {
@@ -45,10 +141,29 @@ export function makeWarehouse(state: WarehouseStateInput): Warehouse {
         pending_tasks: [],
     }
     if (state.hullmass !== undefined) info.hullmass = UInt32.from(state.hullmass)
-    if (state.loaders) info.loaders = state.loaders
     if (state.schedule) info.schedule = state.schedule
+
+    let moduleEntries: ServerContract.Types.module_entry[] = []
+    if (state.modules && state.modules.length > 0) {
+        moduleEntries = assignModulesToSlots(
+            ITEM_WAREHOUSE_T1_PACKED,
+            state.modules,
+            'Warehouse T1'
+        )
+        const decoded = state.modules.map(decodePackedInput)
+        const capabilities = computeWarehouseCapabilities(decoded)
+        if (capabilities.loaders) info.loaders = capabilities.loaders
+
+        const totalBonus = computeStorageBonus(decoded, state.capacity)
+        info.capacity = UInt32.from(state.capacity + totalBonus)
+    } else {
+        moduleEntries = assignModulesToSlots(ITEM_WAREHOUSE_T1_PACKED, [], 'Warehouse T1')
+    }
+
     const entityInfo = ServerContract.Types.entity_info.from(info)
-    return new Warehouse(entityInfo)
+    const warehouse = new Warehouse(entityInfo)
+    warehouse.setModules(moduleEntries)
+    return warehouse
 }
 
 export function makeContainer(state: ContainerStateInput): Container {
@@ -61,7 +176,7 @@ export function makeContainer(state: ContainerStateInput): Container {
         hullmass: UInt32.from(state.hullmass),
         capacity: UInt32.from(state.capacity),
         cargomass: UInt32.from(state.cargomass || 0),
-        cargo: [],
+        cargo: state.cargo || [],
         is_idle: !state.schedule,
         current_task_elapsed: UInt32.from(0),
         current_task_remaining: UInt32.from(0),

package/src/entities/ship-deploy.ts

@@ -48,7 +48,7 @@ export function computeGeneratorCapabilities(stats: Record<string, number>): {
 
     return {
         capacity: 300 + Math.floor(res / 6),
-        recharge: 5 + Math.floor((clr * 15) / 1000),
+        recharge: 1 + Math.floor((clr * 3) / 1000),
     }
 }
 
@@ -65,7 +65,7 @@ export function computeGathererCapabilities(stats: Record<string, number>): {
 
     return {
         yield: 200 + str,
-        drain: Math.max(10, 50 - Math.floor(con / 20)),
+        drain: Math.max(250, 1250 - Math.floor((con * 25) / 20)),
         depth: 200 + Math.floor((tol * 3) / 2),
         speed: 100 + Math.floor((ref * 4) / 5),
     }
@@ -160,7 +160,7 @@ export interface ShipCapabilities {
 }
 
 export function computeShipCapabilities(
-    modules: {itemId: number; seed: bigint}[]
+    modules: {itemId: number; stats: bigint}[]
 ): ShipCapabilities {
     const ship: ShipCapabilities = {}
 
@@ -169,7 +169,7 @@ export function computeShipCapabilities(
         let totalThrust = 0
         let totalDrain = 0
         for (const m of engineModules) {
-            const caps = computeEngineCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
+            const caps = computeEngineCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
             totalThrust += caps.thrust
             totalDrain += caps.drain
         }
@@ -183,7 +183,7 @@ export function computeShipCapabilities(
         let totalCapacity = 0
         let totalRecharge = 0
         for (const m of generatorModules) {
-            const caps = computeGeneratorCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
+            const caps = computeGeneratorCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
             totalCapacity += caps.capacity
             totalRecharge += caps.recharge
         }
@@ -199,7 +199,7 @@ export function computeShipCapabilities(
         let totalDepth = 0
         let totalSpeed = 0
         for (const m of gathererModules) {
-            const caps = computeGathererCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
+            const caps = computeGathererCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
             totalYield += caps.yield
             totalDrain += caps.drain
             totalDepth += caps.depth
@@ -214,12 +214,7 @@ export function computeShipCapabilities(
         let weightedEffNum = 0
         let totalDrain = 0
         for (const m of haulerModules) {
-            const decoded = decodeCraftedItemStats(m.itemId, m.seed)
-            const caps = computeHaulerCapabilities({
-                resonance: decoded.capacity,
-                conductivity: decoded.efficiency,
-                clarity: decoded.drain,
-            })
+            const caps = computeHaulerCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
             totalCapacity += caps.capacity
             weightedEffNum += caps.efficiency * caps.capacity
             totalDrain += caps.drain
@@ -237,7 +232,7 @@ export function computeShipCapabilities(
         let totalThrust = 0
         let totalQuantity = 0
         for (const m of loaderModules) {
-            const caps = computeLoaderCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
+            const caps = computeLoaderCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
             totalMass += caps.mass
             totalThrust += caps.thrust
             totalQuantity += caps.quantity
@@ -252,7 +247,7 @@ export function computeShipCapabilities(
         let totalSpeed = 0
         let totalDrain = 0
         for (const m of crafterModules) {
-            const caps = computeManufacturingCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
+            const caps = computeManufacturingCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
             totalSpeed += caps.speed
             totalDrain += caps.drain
         }

package/src/entities/ship.ts

@@ -1,4 +1,4 @@
-import {UInt16, UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
+import {UInt16, UInt16Type, UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
 import {Coordinates, CoordinatesType} from '../types'
 import {
@@ -23,6 +23,11 @@ import {
 } from '../capabilities/movement'
 import * as schedule from '../scheduling/schedule'
 
+export interface PackedModuleInput {
+    itemId: UInt16Type
+    stats: UInt64Type
+}
+
 export interface ShipStateInput {
     id: UInt64Type
     owner: string
@@ -31,9 +36,7 @@ export interface ShipStateInput {
     hullmass?: number
     capacity?: number
     energy?: number
-    engines?: ServerContract.Types.movement_stats
-    generator?: ServerContract.Types.energy_stats
-    loaders?: ServerContract.Types.loader_stats
+    modules?: PackedModuleInput[]
     schedule?: ServerContract.Types.schedule
     cargo?: ServerContract.Types.cargo_item[]
 }
@@ -47,11 +50,20 @@ type MovementEntity = {
 export class Ship extends ServerContract.Types.entity_info {
     private _sched?: ScheduleAccessor
     private _inv?: InventoryAccessor
+    private _modules: ServerContract.Types.module_entry[] = []
 
     get name(): string {
         return this.entity_name
     }
 
+    get modules(): ServerContract.Types.module_entry[] {
+        return this._modules
+    }
+
+    setModules(modules: ServerContract.Types.module_entry[]): void {
+        this._modules = modules
+    }
+
     get inv(): InventoryAccessor {
         return (this._inv ??= new InventoryAccessor(this))
     }

package/src/entities/warehouse.ts

@@ -6,6 +6,10 @@ import {ScheduleAccessor} from '../scheduling/accessor'
 import {InventoryAccessor} from './inventory-accessor'
 import {EntityInventory} from './entity-inventory'
 import * as schedule from '../scheduling/schedule'
+import type {PackedModuleInput} from './ship'
+import {decodeCraftedItemStats} from '../derivation/crafting'
+import {getModuleCapabilityType, MODULE_LOADER} from '../capabilities/modules'
+import {computeLoaderCapabilities} from './ship-deploy'
 
 export interface WarehouseStateInput {
     id: UInt64Type
@@ -14,7 +18,7 @@ export interface WarehouseStateInput {
     coordinates: CoordinatesType | {x: number; y: number; z?: number}
     hullmass?: number
     capacity: number
-    loaders?: ServerContract.Types.loader_stats
+    modules?: PackedModuleInput[]
     schedule?: ServerContract.Types.schedule
     cargo?: ServerContract.Types.cargo_item[]
 }
@@ -22,11 +26,20 @@ export interface WarehouseStateInput {
 export class Warehouse extends ServerContract.Types.entity_info {
     private _sched?: ScheduleAccessor
     private _inv?: InventoryAccessor
+    private _modules: ServerContract.Types.module_entry[] = []
 
     get name(): string {
         return this.entity_name
     }
 
+    get modules(): ServerContract.Types.module_entry[] {
+        return this._modules
+    }
+
+    setModules(modules: ServerContract.Types.module_entry[]): void {
+        this._modules = modules
+    }
+
     get inv(): InventoryAccessor {
         return (this._inv ??= new InventoryAccessor(this))
     }
@@ -89,3 +102,25 @@ export class Warehouse extends ServerContract.Types.entity_info {
         return hull.adding(this.totalCargoMass)
     }
 }
+
+export function computeWarehouseCapabilities(modules: {itemId: number; stats: bigint}[]): {
+    loaders?: {mass: number; thrust: number; quantity: number}
+} {
+    const warehouse: {loaders?: {mass: number; thrust: number; quantity: number}} = {}
+
+    const loaderModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_LOADER)
+    if (loaderModules.length > 0) {
+        let totalMass = 0
+        let totalThrust = 0
+        let totalQuantity = 0
+        for (const m of loaderModules) {
+            const caps = computeLoaderCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
+            totalMass += caps.mass
+            totalThrust += caps.thrust
+            totalQuantity += caps.quantity
+        }
+        warehouse.loaders = {mass: totalMass, thrust: totalThrust, quantity: totalQuantity}
+    }
+
+    return warehouse
+}

package/src/index-module.ts

@@ -6,8 +6,8 @@ import {ServerContract} from './contracts'
 
 export {Shipload} from './shipload'
 export {Ship} from './entities/ship'
-export type {ShipStateInput} from './entities/ship'
-export {Warehouse} from './entities/warehouse'
+export type {ShipStateInput, PackedModuleInput} from './entities/ship'
+export {Warehouse, computeWarehouseCapabilities} from './entities/warehouse'
 export type {WarehouseStateInput} from './entities/warehouse'
 export {Container} from './entities/container'
 export type {ContainerStateInput} from './entities/container'
@@ -143,7 +143,7 @@ export {
     projectEntityAt,
     validateSchedule,
 } from './scheduling/projection'
-export type {Projectable, ProjectedEntity} from './scheduling/projection'
+export type {Projectable, ProjectedEntity, ProjectionOptions} from './scheduling/projection'
 
 export * from './types/capabilities'
 export * from './types/entity'
@@ -152,11 +152,14 @@ export * from './capabilities'
 export {
     categoryColors,
     tierColors,
+    tierLabels,
     categoryIcons,
+    categoryIconShapes,
     componentIcon,
     moduleIcon,
-    itemIcons,
+    itemAbbreviations,
 } from './data/colors'
+export type {CategoryIconShape} from './data/colors'
 
 export {itemTier, itemOffset, itemCategory, isRelatedItem, isCraftedItem} from './data/tiers'
 export type {CraftedItemCategory} from './data/tiers'
@@ -226,6 +229,7 @@ export type {
 
 export {
     encodeStats,
+    encodeGatheredCargoStats,
     decodeStat,
     decodeStats,
     decodeCraftedItemStats,
@@ -237,7 +241,7 @@ export {
     blendCrossGroup,
     categoryItemMass,
     computeInputMass,
-    computeCraftedOutputSeed,
+    computeCraftedOutputStats,
 } from './derivation/crafting'
 export type {StackInput, CategoryStacks, RecipeSlotInput} from './derivation/crafting'
 
@@ -266,6 +270,19 @@ export type {
     ResolvedItemType,
 } from './resolution/resolve-item'
 
+export {
+    describeModule,
+    describeModuleForItem,
+    describeModuleForSlot,
+    renderDescription,
+} from './resolution/describe-module'
+export type {
+    TextSpan,
+    CapabilityInput,
+    ModuleDescription,
+    RenderDescriptionOptions,
+} from './resolution/describe-module'
+
 export * as NFT from './nft'
 export {
     deserializeAsset,