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

package/src/capabilities/craftable.test.ts

@@ -0,0 +1,82 @@
+import {describe, expect, test} from 'bun:test'
+import {ServerContract} from '../contracts'
+import {UInt16, UInt32, UInt64} from '@wharfkit/antelope'
+import {
+    ITEM_ENGINE_T1,
+    ITEM_GENERATOR_T1,
+    ITEM_CRAFTER_T1,
+    ITEM_PLASMA_CELL,
+    ITEM_SHIP_T1_PACKED,
+} from '../data/item-ids'
+import {getRecipe} from '../data/recipes-runtime'
+import {encodeStats} from '../derivation/crafting'
+import {rollupCrafter} from '../derivation/rollups'
+import {makeEntity} from '../entities/makers'
+import type {IncomingSource} from '../scheduling/availability'
+import {maxCraftable} from './craftable'
+
+const NOW = new Date('2026-06-11T17:06:40.000Z')
+
+function ship(cargo: ServerContract.Types.cargo_item[] = []) {
+    return makeEntity(ITEM_SHIP_T1_PACKED, {
+        id: 99,
+        owner: 'tester.gm',
+        name: 'Craft Tester',
+        coordinates: {x: 0, y: 0},
+        hullmass: 200_000,
+        capacity: 8_000_000,
+        cargomass: 0,
+        energy: 500_000,
+        modules: [
+            {itemId: ITEM_GENERATOR_T1, stats: encodeStats([999, 999])},
+            {itemId: ITEM_CRAFTER_T1, stats: encodeStats([999, 999])},
+        ],
+        cargo,
+    })
+}
+
+function crafterSpeed(entity: ReturnType<typeof ship>): number {
+    return rollupCrafter(entity.crafter_lanes)!.speed.toNumber()
+}
+
+function plasmaCell(quantity: number) {
+    return ServerContract.Types.cargo_item.from({
+        item_id: UInt16.from(ITEM_PLASMA_CELL),
+        quantity: UInt32.from(quantity),
+        stats: UInt64.from(0),
+        modules: [],
+    })
+}
+
+describe('maxCraftable — incoming', () => {
+    test('on-hand-only baseline stays 0 for an empty-cargo entity', () => {
+        const recipe = getRecipe(ITEM_ENGINE_T1)!
+        const entity = ship([])
+        expect(maxCraftable(entity, recipe, crafterSpeed(entity), NOW)).toBe(0)
+    })
+
+    test('incoming source alone covers the recipe inputs', () => {
+        const recipe = getRecipe(ITEM_ENGINE_T1)!
+        const entity = ship([])
+        const incoming: IncomingSource[] = [
+            {holdId: '1', until: new Date(NOW.getTime() - 1000), items: [plasmaCell(1800)]},
+        ]
+
+        expect(maxCraftable(entity, recipe, crafterSpeed(entity), NOW)).toBe(0)
+        expect(maxCraftable(entity, recipe, crafterSpeed(entity), NOW, incoming)).toBe(3)
+    })
+
+    test('an incoming source arriving well after craft completion still resolves (eventually craftable)', () => {
+        const recipe = getRecipe(ITEM_ENGINE_T1)!
+        const entity = ship([])
+        const farFuture: IncomingSource[] = [
+            {
+                holdId: '1',
+                until: new Date(NOW.getTime() + 1_000_000_000),
+                items: [plasmaCell(1800)],
+            },
+        ]
+
+        expect(maxCraftable(entity, recipe, crafterSpeed(entity), NOW, farFuture)).toBe(3)
+    })
+})

package/src/capabilities/craftable.ts

@@ -0,0 +1,82 @@
+import type {ServerContract} from '../contracts'
+import {getItem} from '../data/catalog'
+import type {Recipe} from '../data/recipes-runtime'
+import {
+    availableForItem,
+    projectedCargoAvailableAt,
+    taskCargoEffect,
+    type IncomingSource,
+} from '../scheduling/availability'
+import {candidateLaneCompletesAt, workerLaneKey} from '../scheduling/lanes'
+import * as schedule from '../scheduling/schedule'
+import type {ScheduleData} from '../scheduling/schedule'
+import {calc_craft_duration} from './crafting'
+
+type CargoItem = ServerContract.Types.cargo_item
+type ModuleEntry = ServerContract.Types.module_entry
+
+export interface CraftableEntity extends ScheduleData {
+    cargo: CargoItem[]
+    modules: ModuleEntry[]
+}
+
+// Recipe inputs aren't stat-pinned (any variant counts, mirroring availableForItem's item-id aggregation).
+function itemReadyAt(
+    entity: CraftableEntity,
+    itemIds: readonly number[],
+    incoming: readonly IncomingSource[]
+): Date {
+    let readyMs = 0
+    for (const ordered of schedule.orderedTasks(entity)) {
+        for (const item of taskCargoEffect(ordered.task).added) {
+            if (itemIds.includes(item.item_id.toNumber())) {
+                readyMs = Math.max(readyMs, ordered.completesAt.getTime())
+                break
+            }
+        }
+    }
+    for (const src of incoming) {
+        if (src.items.some((item) => itemIds.includes(item.item_id.toNumber()))) {
+            readyMs = Math.max(readyMs, src.until.getTime())
+        }
+    }
+    return new Date(readyMs)
+}
+
+export function maxCraftable(
+    entity: CraftableEntity,
+    recipe: Recipe,
+    crafterSpeed: number,
+    now: Date,
+    incoming: readonly IncomingSource[] = []
+): number {
+    if (recipe.inputs.length === 0) return 0
+
+    const perUnitMass = recipe.inputs.reduce(
+        (sum, input) => sum + getItem(input.itemId).mass * input.quantity,
+        0
+    )
+    const perUnitDuration = calc_craft_duration(crafterSpeed, perUnitMass).toNumber()
+    const crafterLane = workerLaneKey(entity.modules, 'crafter', entity.lanes ?? [])
+    const naiveCompletesAt = candidateLaneCompletesAt(entity, crafterLane, perUnitDuration, now)
+    const laneStartMs = naiveCompletesAt.getTime() - perUnitDuration * 1000
+    const readyMs = itemReadyAt(
+        entity,
+        recipe.inputs.map((input) => input.itemId),
+        incoming
+    ).getTime()
+    const completesAt = new Date(Math.max(laneStartMs, readyMs) + perUnitDuration * 1000)
+    const availability = projectedCargoAvailableAt(entity, completesAt, incoming)
+
+    let maxUnits: bigint | undefined
+    for (const input of recipe.inputs) {
+        if (input.quantity <= 0) return 0
+
+        const units = availableForItem(availability, input.itemId) / BigInt(input.quantity)
+        maxUnits = maxUnits === undefined || units < maxUnits ? units : maxUnits
+    }
+
+    if (maxUnits === undefined) return 0
+    if (maxUnits > BigInt(Number.MAX_SAFE_INTEGER)) return Number.MAX_SAFE_INTEGER
+    return Number(maxUnits)
+}

package/src/capabilities/crafting.test.ts

@@ -0,0 +1,80 @@
+import {UInt16, UInt32} from '@wharfkit/antelope'
+import {describe, expect, test} from 'bun:test'
+import type {ServerContract} from '../contracts'
+import {computeInputMass} from '../derivation/crafting'
+import {getRecipe} from '../data/recipes-runtime'
+import {
+    calc_craft_energy,
+    calcClusterIntake,
+    calcClustercraftDuration,
+    craftEnergyCost,
+    INTAKE_RATE,
+} from './crafting'
+
+function crafterLane(drain: number): ServerContract.Types.crafter_lane {
+    return {
+        slot_index: UInt16.from(0),
+        speed: UInt16.from(1000),
+        drain: UInt32.from(drain),
+        output_pct: UInt16.from(100),
+    } as unknown as ServerContract.Types.crafter_lane
+}
+
+test('calc_craft_energy does not clamp above the old uint16 ceiling', () => {
+    const energy = calc_craft_energy(30, 400_000_000)
+    expect(Number(energy)).toBeGreaterThan(65535)
+})
+
+describe('calcClusterIntake', () => {
+    test('is floor(sourcedMass / INTAKE_RATE)', () => {
+        expect(INTAKE_RATE).toBe(360)
+        expect(calcClusterIntake(360)).toBe(1)
+        expect(calcClusterIntake(359)).toBe(0)
+        expect(calcClusterIntake(196_800)).toBe(546)
+    })
+
+    test('zero sourced mass (all own-hold) charges no intake', () => {
+        expect(calcClusterIntake(0)).toBe(0)
+    })
+})
+
+describe('calcClustercraftDuration', () => {
+    test('adds intake to the base craft duration', () => {
+        // calc_craft_duration = floor(inputMass/speed) + 1
+        const speed = 1000
+        const inputMass = 1000 // base craft = 100 + 1 = 101s
+        const sourcedMass = 720 // intake = 2s
+        expect(calcClustercraftDuration(speed, inputMass, sourcedMass).toNumber()).toBe(103)
+    })
+})
+
+describe('craftEnergyCost', () => {
+    const OUTPUT_ITEM_ID = 10001
+    const DRAIN = 100_000
+
+    test('matches calc_craft_energy against the recipe input mass times units', () => {
+        const recipe = getRecipe(OUTPUT_ITEM_ID)!
+        const lane = crafterLane(DRAIN)
+        const units = 5
+
+        const cost = craftEnergyCost(lane, recipe, units)
+
+        const expected = Number(calc_craft_energy(DRAIN, computeInputMass(OUTPUT_ITEM_ID) * units))
+        expect(cost).toBe(expected)
+    })
+
+    test('is 0 for non-positive units', () => {
+        const recipe = getRecipe(OUTPUT_ITEM_ID)!
+        const lane = crafterLane(DRAIN)
+        expect(craftEnergyCost(lane, recipe, 0)).toBe(0)
+        expect(craftEnergyCost(lane, recipe, -1)).toBe(0)
+    })
+
+    test('scales with unit count', () => {
+        const recipe = getRecipe(OUTPUT_ITEM_ID)!
+        const lane = crafterLane(DRAIN)
+        const one = craftEnergyCost(lane, recipe, 1)
+        const ten = craftEnergyCost(lane, recipe, 10)
+        expect(ten).toBeGreaterThan(one)
+    })
+})

package/src/capabilities/crafting.ts

@@ -1,10 +1,12 @@
-import {UInt16, UInt32} from '@wharfkit/antelope'
-import {CRAFT_ENERGY_DIVISOR} from '../types'
-import type {EntityCapabilities} from '../types/capabilities'
+import {UInt32} from '@wharfkit/antelope'
+import {CRAFT_ENERGY_DIVISOR, MASS_STAT_SCALE} from '../types'
+import type {CrafterStats, EntityCapabilities} from '../types/capabilities'
 import type {ServerContract} from '../contracts'
+import {getItem} from '../data/catalog'
+import type {Recipe} from '../data/recipes-runtime'
 
 export interface CrafterCapability {
-    crafter: ServerContract.Types.crafter_stats
+    crafter: CrafterStats
 }
 
 export function capsHasCrafter(caps: EntityCapabilities): boolean {
@@ -12,11 +14,51 @@ export function capsHasCrafter(caps: EntityCapabilities): boolean {
 }
 
 export function calc_craft_duration(speed: number, totalInputMass: number): UInt32 {
-    const duration = Math.floor(totalInputMass / speed)
-    return UInt32.from(Math.max(duration, 1))
+    const duration = Math.floor((totalInputMass * MASS_STAT_SCALE) / speed)
+    return UInt32.from(duration + 1)
 }
 
-export function calc_craft_energy(drain: number, totalInputMass: number): UInt16 {
+export const INTAKE_RATE = 360
+
+// Mirrors calc_cluster_intake: whole seconds of intake for cargo sourced off other cluster members.
+export function calcClusterIntake(sourcedMass: number): number {
+    return Math.floor(sourcedMass / INTAKE_RATE)
+}
+
+// Mirrors clustercraft duration: base craft duration + intake time.
+export function calcClustercraftDuration(
+    speed: number,
+    totalInputMass: number,
+    sourcedMass: number
+): UInt32 {
+    return UInt32.from(
+        calc_craft_duration(speed, totalInputMass).toNumber() + calcClusterIntake(sourcedMass)
+    )
+}
+
+export function calc_craft_energy(drain: number, totalInputMass: number): UInt32 {
     const raw = Math.floor((totalInputMass * drain) / CRAFT_ENERGY_DIVISOR)
-    return UInt16.from(Math.min(raw, 65535))
+    return UInt32.from(Math.min(Math.max(raw + 1, 1000), 4294967295))
+}
+
+export function craftEnergyCost(
+    lane: ServerContract.Types.crafter_lane,
+    recipe: Recipe,
+    units: number
+): number {
+    if (units <= 0) return 0
+    const inputMassPerUnit = recipe.inputs.reduce(
+        (sum, input) => sum + getItem(input.itemId).mass * input.quantity,
+        0
+    )
+    return Number(calc_craft_energy(lane.drain.toNumber(), inputMassPerUnit * units))
+}
+
+// Craft-identical today; forked so build balance can diverge from craft without touching it.
+export function calc_build_duration(speed: number, totalInputMass: number): UInt32 {
+    return calc_craft_duration(speed, totalInputMass)
+}
+
+export function calc_build_energy(drain: number, totalInputMass: number): UInt32 {
+    return calc_craft_energy(drain, totalInputMass)
 }

package/src/capabilities/gathering.test.ts

@@ -0,0 +1,29 @@
+import {expect, test} from 'bun:test'
+import type {GathererStats} from '../types/capabilities'
+import {calc_gather_duration, calc_gather_energy} from './gathering'
+
+function gatherer(drain: number): GathererStats {
+    return {
+        yield: {toNumber: () => 1},
+        drain: {toNumber: () => drain},
+        depth: {toNumber: () => 0, toString: () => '0'},
+    }
+}
+
+test('calc_gather_energy does not clamp above the old uint16 ceiling', () => {
+    const energy = calc_gather_energy(gatherer(30), 400_000_000)
+    expect(Number(energy)).toBeGreaterThan(65535)
+})
+
+test('splitting a bulk gather never undercuts total lane-time', () => {
+    const g: GathererStats = {
+        yield: {toNumber: () => 413},
+        drain: {toNumber: () => 30},
+        depth: {toNumber: () => 0, toString: () => '0'},
+    }
+    const bulk = Number(calc_gather_duration(g, 1000, 10, 8, 500))
+    const unit = Number(calc_gather_duration(g, 1000, 1, 8, 500))
+    // d1 >= 1 regime (bulk > quantity), where the split exploit lived
+    expect(bulk).toBeGreaterThan(10)
+    expect(unit * 10).toBeGreaterThanOrEqual(bulk)
+})

package/src/capabilities/gathering.ts

@@ -1,36 +1,54 @@
-import {UInt16, UInt32} from '@wharfkit/antelope'
-import type {ServerContract} from '../contracts'
-import {PRECISION} from '../types'
+import {UInt32} from '@wharfkit/antelope'
+import type {GathererStats} from '../types/capabilities'
+import {MASS_STAT_SCALE, PRECISION} from '../types'
 
 const GATHER_TIME_SCALE = 100
+export const GATHER_MASS_DIVISOR = 228
 const DEPTH_PENALTY_DIVISOR = 5000
-const SPEED_TIME_SCALE = 300
 
-export function calc_gather_duration(
-    gatherer: ServerContract.Types.gatherer_stats,
+function gather_duration_raw(
+    gatherer: GathererStats,
     itemMass: number,
     quantity: number,
     stratum: number,
     richness: number
-): UInt32 {
+): number {
     const yieldValue = gatherer.yield.toNumber()
-    const speed = gatherer.speed.toNumber()
 
-    if (yieldValue === 0 || speed === 0 || richness === 0) return UInt32.from(0)
+    if (yieldValue === 0 || richness === 0) return 0
 
-    const massFactor = Math.sqrt(itemMass)
+    const massFactor = (itemMass * MASS_STAT_SCALE) / GATHER_MASS_DIVISOR
     const depthPenalty = 1 + stratum / DEPTH_PENALTY_DIVISOR
     const richnessMul = richness / 1000
-    const gatherTime =
-        (quantity * massFactor * GATHER_TIME_SCALE * depthPenalty) / (yieldValue * richnessMul)
-    const speedTime = SPEED_TIME_SCALE * Math.log(1 + stratum / speed)
-    return UInt32.from(Math.floor(gatherTime + speedTime))
+    return (quantity * massFactor * GATHER_TIME_SCALE * depthPenalty) / (yieldValue * richnessMul)
+}
+
+export function calc_gather_duration(
+    gatherer: GathererStats,
+    itemMass: number,
+    quantity: number,
+    stratum: number,
+    richness: number
+): UInt32 {
+    const raw = gather_duration_raw(gatherer, itemMass, quantity, stratum, richness)
+    // +1 per-gather setup cost mirrors the contract: splitting a bulk gather must not undercut lane-time
+    return UInt32.from(raw <= 0 ? 0 : Math.floor(raw) + 1)
+}
+
+export function calc_gather_rate(
+    gatherer: GathererStats,
+    itemMass: number,
+    stratum: number,
+    richness: number
+): {unitsPerSec: number; unitsPerMin: number; secPerUnit: number} {
+    const secPerUnit = gather_duration_raw(gatherer, itemMass, 1, stratum, richness)
+    if (secPerUnit <= 0) return {unitsPerSec: 0, unitsPerMin: 0, secPerUnit: 0}
+    const unitsPerSec = 1 / secPerUnit
+    return {unitsPerSec, unitsPerMin: unitsPerSec * 60, secPerUnit}
 }
 
-export function calc_gather_energy(
-    gatherer: ServerContract.Types.gatherer_stats,
-    duration: number
-): UInt16 {
-    const energy = Math.floor((duration * gatherer.drain.toNumber()) / PRECISION)
-    return UInt16.from(energy)
+export function calc_gather_energy(gatherer: GathererStats, duration: number): UInt32 {
+    if (duration <= 0) return UInt32.from(0)
+    const raw = Math.floor((duration * gatherer.drain.toNumber()) / PRECISION)
+    return UInt32.from(Math.min(Math.max(raw, 1000), 4294967295))
 }

package/src/capabilities/hauling.ts

@@ -1,6 +1,5 @@
 const BASE_HAUL_PENALTY_MILLI = 300
 const HAULER_EFFICIENCY_DENOM = 10000
-const PRECISION = 10000
 
 export function computeHaulPenalty(
     totalThrust: number,
@@ -16,7 +15,3 @@ export function computeHaulPenalty(
         )
     return Math.floor((totalThrust * 1000) / penaltyMilli)
 }
-
-export function computeHaulerDrain(distance: number, drain: number, haulCount: number): number {
-    return Math.floor(distance / PRECISION) * drain * haulCount
-}

package/src/capabilities/index.ts

@@ -1,7 +1,6 @@
 export * from './guards'
 export * from './movement'
 export * from './storage'
-export * from './loading'
 export * from './gathering'
 export * from './crafting'
 export * from './modules'

package/src/capabilities/modules.ts

@@ -1,13 +1,5 @@
-import {
-    ITEM_CRAFTER_T1,
-    ITEM_ENGINE_T1,
-    ITEM_GATHERER_T1,
-    ITEM_GENERATOR_T1,
-    ITEM_HAULER_T1,
-    ITEM_LOADER_T1,
-    ITEM_STORAGE_T1,
-    ITEM_WARP_T1,
-} from '../data/item-ids'
+import {getItem, tryGetItem} from '../data/catalog'
+import type {EntitySlot} from '../data/recipes-runtime'
 
 export const MODULE_ANY = 0
 export const MODULE_ENGINE = 1
@@ -19,6 +11,9 @@ export const MODULE_CRAFTER = 6
 export const MODULE_LAUNCHER = 7
 export const MODULE_STORAGE = 8
 export const MODULE_HAULER = 9
+export const MODULE_BATTERY = 10
+export const MODULE_BUILDER = 12
+export const MODULE_AUX = 13
 
 export interface PackedModule {
     itemId: number
@@ -31,30 +26,19 @@ export interface ModuleEntry {
 }
 
 export function moduleAccepts(slotType: number, moduleType: number): boolean {
+    if (slotType === MODULE_AUX) {
+        return (
+            moduleType === MODULE_GENERATOR ||
+            moduleType === MODULE_ENGINE ||
+            moduleType === MODULE_BATTERY
+        )
+    }
     return slotType === MODULE_ANY || slotType === moduleType
 }
 
 export function getModuleCapabilityType(itemId: number): number {
-    switch (itemId) {
-        case ITEM_ENGINE_T1:
-            return MODULE_ENGINE
-        case ITEM_GENERATOR_T1:
-            return MODULE_GENERATOR
-        case ITEM_GATHERER_T1:
-            return MODULE_GATHERER
-        case ITEM_LOADER_T1:
-            return MODULE_LOADER
-        case ITEM_CRAFTER_T1:
-            return MODULE_CRAFTER
-        case ITEM_STORAGE_T1:
-            return MODULE_STORAGE
-        case ITEM_HAULER_T1:
-            return MODULE_HAULER
-        case ITEM_WARP_T1:
-            return MODULE_WARP
-        default:
-            return 0xff
-    }
+    const item = tryGetItem(itemId)
+    return item?.type === 'module' && item.moduleType ? moduleSlotTypeToCode(item.moduleType) : 0xff
 }
 
 export function isModuleItem(itemId: number): boolean {
@@ -77,13 +61,26 @@ export function moduleSlotTypeToCode(slotType: string): number {
             return MODULE_WARP
         case 'crafter':
             return MODULE_CRAFTER
+        case 'builder':
+            return MODULE_BUILDER
         case 'launcher':
             return MODULE_LAUNCHER
         case 'storage':
             return MODULE_STORAGE
         case 'hauler':
             return MODULE_HAULER
+        case 'battery':
+            return MODULE_BATTERY
+        case 'aux':
+            return MODULE_AUX
         default:
             return MODULE_ANY
     }
 }
+
+export function slotAcceptsModule(slot: EntitySlot, moduleItemId: number): boolean {
+    const moduleType = getModuleCapabilityType(moduleItemId)
+    if (moduleType === 0xff) return false
+    if (!moduleAccepts(moduleSlotTypeToCode(slot.type), moduleType)) return false
+    return getItem(moduleItemId).tier <= slot.maxTier
+}

package/src/capabilities/movement.ts

@@ -9,7 +9,7 @@ export function maxTravelDistance(entity: MovementCapability): UInt32 {
 }
 
 export function calcEnergyUsage(entity: MovementCapability, distance: UInt64): UInt64 {
-    return distance.dividing(PRECISION).multiplying(entity.engines.drain)
+    return distance.multiplying(entity.engines.drain).dividing(PRECISION)
 }
 
 export function hasEnergyForDistance(

package/src/capabilities/storage.test.ts

@@ -0,0 +1,26 @@
+import {expect, test} from 'bun:test'
+import {UInt32, UInt64} from '@wharfkit/antelope'
+import {hasSpaceForMass, isFull, isFullFromMass} from './storage'
+
+test('hasSpaceForMass accepts raw numbers', () => {
+    expect(hasSpaceForMass(100, 40, 50)).toBe(true)
+    expect(hasSpaceForMass(100, 60, 50)).toBe(false)
+    expect(hasSpaceForMass(100, 50, 50)).toBe(true)
+})
+
+test('hasSpaceForMass accepts wrapped values', () => {
+    expect(hasSpaceForMass(UInt64.from(100), UInt64.from(40), UInt64.from(50))).toBe(true)
+    expect(hasSpaceForMass(UInt64.from(100), UInt32.from(60), UInt32.from(50))).toBe(false)
+})
+
+test('isFullFromMass accepts raw numbers', () => {
+    expect(isFullFromMass(100, 100)).toBe(true)
+    expect(isFullFromMass(100, 101)).toBe(true)
+    expect(isFullFromMass(100, 99)).toBe(false)
+})
+
+test('isFull accepts raw numbers on the entity', () => {
+    expect(isFull({capacity: 100, cargomass: 100})).toBe(true)
+    expect(isFull({capacity: 100, cargomass: 99})).toBe(false)
+    expect(isFull({capacity: UInt32.from(100), cargomass: UInt32.from(120)})).toBe(true)
+})

package/src/capabilities/storage.ts

@@ -1,4 +1,4 @@
-import {UInt16, UInt32, UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {UInt16, UInt32, UInt64, type UInt32Type, type UInt64Type} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
 import type {StorageCapability} from '../types/capabilities'
 import {getItem} from '../data/catalog'
@@ -9,11 +9,11 @@ export interface HasCargo {
 }
 
 export interface HasCapacity {
-    capacity: UInt32
+    capacity: UInt32Type
 }
 
 export interface HasCargomass {
-    cargomass: UInt32
+    cargomass: UInt32Type
 }
 
 interface MassInput {
@@ -75,15 +75,15 @@ export function hasSpaceForMass(
     currentMass: UInt64Type,
     additionalMass: UInt64Type
 ): boolean {
-    return UInt64.from(currentMass).adding(additionalMass).lte(capacity)
+    return UInt64.from(currentMass).adding(additionalMass).lte(UInt64.from(capacity))
 }
 
 export function isFull(entity: HasCapacity & HasCargomass): boolean {
-    return UInt64.from(entity.cargomass).gte(entity.capacity)
+    return UInt64.from(entity.cargomass).gte(UInt64.from(entity.capacity))
 }
 
 export function isFullFromMass(capacity: UInt64Type, cargoMass: UInt64Type): boolean {
-    return UInt64.from(cargoMass).gte(capacity)
+    return UInt64.from(cargoMass).gte(UInt64.from(capacity))
 }
 
 export interface CargoStack {
@@ -97,7 +97,7 @@ export function cargoItemToStack(item: ServerContract.Types.cargo_item): CargoSt
     return {
         item_id: UInt16.from(item.item_id),
         quantity: UInt32.from(item.quantity),
-        stats: item.stats,
+        stats: UInt64.from(item.stats),
         modules: item.modules ?? [],
     }
 }
@@ -157,3 +157,18 @@ export function removeFromStacks(stacks: CargoStack[], remove: CargoStack): Carg
     result[idx] = {...target, quantity: remaining}
     return result
 }
+
+// Tolerant subtraction mirroring the contract's subtract_cargo (projection replay): missing or oversized removal clamps to zero, never throws.
+export function subtractFromStacks(stacks: CargoStack[], remove: CargoStack): CargoStack[] {
+    const idx = stacks.findIndex((s) => stackIdentityEqual(s, remove))
+    if (idx === -1) {
+        return stacks
+    }
+    const target = stacks[idx]
+    if (target.quantity.lte(remove.quantity)) {
+        return [...stacks.slice(0, idx), ...stacks.slice(idx + 1)]
+    }
+    const result = stacks.slice()
+    result[idx] = {...target, quantity: UInt32.from(target.quantity.subtracting(remove.quantity))}
+    return result
+}