@shipload/sdk 2.0.0-rc6 → 2.0.0-rc7

package/src/data/recipes.ts

@@ -1,8 +1,20 @@
+import {MODULE_ENGINE, MODULE_GENERATOR, MODULE_EXTRACTOR, MODULE_LOADER, MODULE_CRAFTER, ITEM_ENGINE_T1, ITEM_GENERATOR_T1, ITEM_EXTRACTOR_T1, ITEM_LOADER_T1, ITEM_MANUFACTURING_T1} from '../capabilities/modules'
 import type {ResourceCategory} from '../types'
 
+export {ITEM_ENGINE_T1, ITEM_GENERATOR_T1, ITEM_EXTRACTOR_T1, ITEM_LOADER_T1, ITEM_MANUFACTURING_T1}
+
+export const ITEM_DRILL_SHAFT = 10009
+export const ITEM_EXTRACTION_PROBE = 10010
+export const ITEM_CARGO_ARM = 10011
+export const ITEM_TOOL_BIT = 10012
+export const ITEM_REACTION_CHAMBER = 10013
+
 export const ITEM_HULL_PLATES = 10001
 export const ITEM_CARGO_LINING = 10002
 export const ITEM_CONTAINER_PACKED = 10003
+export const ITEM_THRUSTER_CORE = 10004
+export const ITEM_POWER_CELL = 10005
+export const ITEM_SHIP_T1_PACKED = 10008
 
 export interface RecipeInput {
 	category?: ResourceCategory
@@ -23,7 +35,7 @@ export interface ComponentDefinition {
 	mass: number
 	stats: ComponentStat[]
 	recipe: RecipeInput[]
-	usedIn: {type: 'entity'; name: string}[]
+	usedIn: {type: 'entity' | 'module'; name: string}[]
 }
 
 export interface EntityRecipe {
@@ -37,7 +49,7 @@ export interface EntityRecipe {
 }
 
 export interface CraftableItem {
-	type: 'component' | 'entity'
+	type: 'component' | 'entity' | 'module'
 	id: number | string
 	name: string
 	description: string
@@ -55,8 +67,8 @@ export const components: ComponentDefinition[] = [
 			{key: 'strength', source: 'metal'},
 			{key: 'density', source: 'metal'},
 		],
-		recipe: [{category: 'metal', quantity: 40}],
-		usedIn: [{type: 'entity', name: 'Container'}],
+		recipe: [{category: 'metal', quantity: 15}],
+		usedIn: [{type: 'entity', name: 'Container'}, {type: 'entity', name: 'Ship T1'}],
 	},
 	{
 		id: ITEM_CARGO_LINING,
@@ -70,10 +82,101 @@ export const components: ComponentDefinition[] = [
 			{key: 'purity', source: 'organic'},
 		],
 		recipe: [
-			{category: 'precious', quantity: 10},
-			{category: 'organic', quantity: 20},
+			{category: 'precious', quantity: 6},
+			{category: 'organic', quantity: 14},
+		],
+		usedIn: [{type: 'entity', name: 'Container'}, {type: 'entity', name: 'Ship T1'}],
+	},
+	{
+		id: ITEM_THRUSTER_CORE,
+		name: 'Thruster Core',
+		description: 'High-energy propulsion component formed from volatile gases.',
+		color: '#E86344',
+		mass: 50000,
+		stats: [
+			{key: 'volatility', source: 'gas'},
+			{key: 'thermal', source: 'gas'},
+		],
+		recipe: [{category: 'gas' as ResourceCategory, quantity: 32}],
+		usedIn: [{type: 'module', name: 'Engine Module T1'}],
+	},
+	{
+		id: ITEM_POWER_CELL,
+		name: 'Power Cell',
+		description: 'Crystalline energy storage matrix formed from resonant minerals.',
+		color: '#7B5AE8',
+		mass: 30000,
+		stats: [
+			{key: 'resonance', source: 'mineral'},
+			{key: 'clarity', source: 'mineral'},
 		],
-		usedIn: [{type: 'entity', name: 'Container'}],
+		recipe: [{category: 'mineral' as ResourceCategory, quantity: 20}],
+		usedIn: [{type: 'module', name: 'Generator Module T1'}],
+	},
+	{
+		id: ITEM_DRILL_SHAFT,
+		name: 'Drill Shaft',
+		description: 'Heavy-duty metal shaft used in extraction equipment.',
+		color: '#7B8D9E',
+		mass: 50000,
+		stats: [
+			{key: 'strength', source: 'metal'},
+			{key: 'tolerance', source: 'metal'},
+		],
+		recipe: [{category: 'metal' as ResourceCategory, quantity: 15}],
+		usedIn: [{type: 'module', name: 'Extractor Module T1'}],
+	},
+	{
+		id: ITEM_EXTRACTION_PROBE,
+		name: 'Extraction Probe',
+		description: 'Precious metal sensor array for deep resource detection.',
+		color: '#D4A843',
+		mass: 30000,
+		stats: [
+			{key: 'conductivity', source: 'precious'},
+			{key: 'reflectivity', source: 'precious'},
+		],
+		recipe: [{category: 'precious' as ResourceCategory, quantity: 10}],
+		usedIn: [{type: 'module', name: 'Extractor Module T1'}],
+	},
+	{
+		id: ITEM_CARGO_ARM,
+		name: 'Cargo Arm',
+		description: 'Flexible organic composite arm for cargo handling.',
+		color: '#6B8E5A',
+		mass: 30000,
+		stats: [
+			{key: 'plasticity', source: 'organic'},
+			{key: 'insulation', source: 'organic'},
+		],
+		recipe: [{category: 'organic' as ResourceCategory, quantity: 32}],
+		usedIn: [{type: 'module', name: 'Loader Module T1'}],
+	},
+	{
+		id: ITEM_TOOL_BIT,
+		name: 'Tool Bit',
+		description: 'Dense mineral cutting head for manufacturing operations.',
+		color: '#B8A9C9',
+		mass: 30000,
+		stats: [
+			{key: 'hardness', source: 'mineral'},
+			{key: 'clarity', source: 'mineral'},
+		],
+		recipe: [{category: 'mineral' as ResourceCategory, quantity: 20}],
+		usedIn: [{type: 'module', name: 'Manufacturing Module T1'}],
+	},
+	{
+		id: ITEM_REACTION_CHAMBER,
+		name: 'Reaction Chamber',
+		description: 'Gas-pressurized vessel for controlled manufacturing reactions.',
+		color: '#7EC8E3',
+		mass: 50000,
+		stats: [
+			{key: 'reactivity', source: 'gas'},
+			{key: 'thermal', source: 'gas'},
+		],
+		recipe: [{category: 'gas' as ResourceCategory, quantity: 32}],
+		usedIn: [{type: 'module', name: 'Manufacturing Module T1'}],
 	},
 ]
 
@@ -95,8 +198,124 @@ export const entityRecipes: EntityRecipe[] = [
 			{key: 'purity', sourceComponentId: ITEM_CARGO_LINING, sourceStatKey: 'purity'},
 		],
 	},
+	{
+		id: 'ship-t1',
+		name: 'Ship T1',
+		description: 'General-purpose vessel with 5 module slots.',
+		color: '#4AE898',
+		packedItemId: ITEM_SHIP_T1_PACKED,
+		recipe: [
+			{itemId: ITEM_HULL_PLATES, quantity: 8},
+			{itemId: ITEM_CARGO_LINING, quantity: 4},
+		],
+		stats: [
+			{key: 'strength', sourceComponentId: ITEM_HULL_PLATES, sourceStatKey: 'strength'},
+			{key: 'density', sourceComponentId: ITEM_HULL_PLATES, sourceStatKey: 'density'},
+			{key: 'ductility', sourceComponentId: ITEM_CARGO_LINING, sourceStatKey: 'ductility'},
+			{key: 'purity', sourceComponentId: ITEM_CARGO_LINING, sourceStatKey: 'purity'},
+		],
+	},
+]
+
+export interface ModuleRecipe {
+	id: string
+	name: string
+	description: string
+	color: string
+	itemId: number
+	moduleType: number
+	recipe: RecipeInput[]
+	stats: {key: string; sourceComponentId: number; sourceStatKey: string}[]
+}
+
+export const moduleRecipes: ModuleRecipe[] = [
+	{
+		id: 'engine-t1',
+		name: 'Engine Module T1',
+		description: 'Basic propulsion system. Converts volatile gases into thrust.',
+		color: '#E86344',
+		itemId: ITEM_ENGINE_T1,
+		moduleType: MODULE_ENGINE,
+		recipe: [{itemId: ITEM_THRUSTER_CORE, quantity: 6}],
+		stats: [
+			{key: 'volatility', sourceComponentId: ITEM_THRUSTER_CORE, sourceStatKey: 'volatility'},
+			{key: 'thermal', sourceComponentId: ITEM_THRUSTER_CORE, sourceStatKey: 'thermal'},
+		],
+	},
+	{
+		id: 'generator-t1',
+		name: 'Generator Module T1',
+		description: 'Basic energy system. Stores and recharges energy from resonant minerals.',
+		color: '#7B5AE8',
+		itemId: ITEM_GENERATOR_T1,
+		moduleType: MODULE_GENERATOR,
+		recipe: [{itemId: ITEM_POWER_CELL, quantity: 5}],
+		stats: [
+			{key: 'resonance', sourceComponentId: ITEM_POWER_CELL, sourceStatKey: 'resonance'},
+			{key: 'clarity', sourceComponentId: ITEM_POWER_CELL, sourceStatKey: 'clarity'},
+		],
+	},
+	{
+		id: 'extractor-t1',
+		name: 'Extractor Module T1',
+		description: 'Basic extraction system. Drills and probes for raw resources.',
+		color: '#7B8D9E',
+		itemId: ITEM_EXTRACTOR_T1,
+		moduleType: MODULE_EXTRACTOR,
+		recipe: [
+			{itemId: ITEM_DRILL_SHAFT, quantity: 4},
+			{itemId: ITEM_EXTRACTION_PROBE, quantity: 3},
+		],
+		stats: [
+			{key: 'strength', sourceComponentId: ITEM_DRILL_SHAFT, sourceStatKey: 'strength'},
+			{key: 'tolerance', sourceComponentId: ITEM_DRILL_SHAFT, sourceStatKey: 'tolerance'},
+			{key: 'reflectivity', sourceComponentId: ITEM_EXTRACTION_PROBE, sourceStatKey: 'reflectivity'},
+			{key: 'conductivity', sourceComponentId: ITEM_EXTRACTION_PROBE, sourceStatKey: 'conductivity'},
+			{key: 'reflectivity_drill', sourceComponentId: ITEM_EXTRACTION_PROBE, sourceStatKey: 'reflectivity'},
+		],
+	},
+	{
+		id: 'loader-t1',
+		name: 'Loader Module T1',
+		description: 'Basic cargo handling system. Loads and unloads cargo with articulated arms.',
+		color: '#6B8E5A',
+		itemId: ITEM_LOADER_T1,
+		moduleType: MODULE_LOADER,
+		recipe: [
+			{itemId: ITEM_CARGO_LINING, quantity: 3},
+			{itemId: ITEM_CARGO_ARM, quantity: 3},
+		],
+		stats: [
+			{key: 'ductility', sourceComponentId: ITEM_CARGO_LINING, sourceStatKey: 'ductility'},
+			{key: 'plasticity', sourceComponentId: ITEM_CARGO_ARM, sourceStatKey: 'plasticity'},
+		],
+	},
+	{
+		id: 'manufacturing-t1',
+		name: 'Manufacturing Module T1',
+		description: 'Basic crafting system. Processes materials using reaction chambers and cutting tools.',
+		color: '#7EC8E3',
+		itemId: ITEM_MANUFACTURING_T1,
+		moduleType: MODULE_CRAFTER,
+		recipe: [
+			{itemId: ITEM_TOOL_BIT, quantity: 3},
+			{itemId: ITEM_REACTION_CHAMBER, quantity: 3},
+		],
+		stats: [
+			{key: 'reactivity', sourceComponentId: ITEM_REACTION_CHAMBER, sourceStatKey: 'reactivity'},
+			{key: 'clarity', sourceComponentId: ITEM_TOOL_BIT, sourceStatKey: 'clarity'},
+		],
+	},
 ]
 
+export function getModuleRecipe(id: string): ModuleRecipe | undefined {
+	return moduleRecipes.find((r) => r.id === id)
+}
+
+export function getModuleRecipeByItemId(itemId: number): ModuleRecipe | undefined {
+	return moduleRecipes.find((r) => r.itemId === itemId)
+}
+
 export function getComponentById(id: number): ComponentDefinition | undefined {
 	return components.find((c) => c.id === id)
 }
@@ -117,6 +336,9 @@ export function getAllCraftableItems(): CraftableItem[] {
 	for (const entity of entityRecipes) {
 		items.push({type: 'entity', id: entity.id, name: entity.name, description: entity.description, color: entity.color})
 	}
+	for (const mod of moduleRecipes) {
+		items.push({type: 'module', id: mod.id, name: mod.name, description: mod.description, color: mod.color})
+	}
 	return items
 }
 

package/src/derivation/crafting.ts

@@ -1,10 +1,13 @@
+import {UInt64} from '@wharfkit/antelope'
 import type {ResourceCategory} from '../types'
 import {
-	components,
 	entityRecipes,
 	getComponentById,
 	getEntityRecipe,
+	getModuleRecipe,
+	moduleRecipes,
 } from '../data/recipes'
+import {deriveResourceStats} from './stratum'
 
 export interface StackInput {
 	quantity: number
@@ -32,26 +35,24 @@ export function decodeStats(seed: bigint, count: number): number[] {
 	return stats
 }
 
+function mapStatsToKeys(seed: bigint, statDefs: {key: string}[]): Record<string, number> {
+	const values = decodeStats(seed, statDefs.length)
+	const result: Record<string, number> = {}
+	for (let i = 0; i < statDefs.length; i++) {
+		result[statDefs[i].key] = values[i]
+	}
+	return result
+}
+
 export function decodeCraftedItemStats(itemId: number, seed: bigint): Record<string, number> {
 	const comp = getComponentById(itemId)
-	if (comp) {
-		const values = decodeStats(seed, comp.stats.length)
-		const result: Record<string, number> = {}
-		for (let i = 0; i < comp.stats.length; i++) {
-			result[comp.stats[i].key] = values[i]
-		}
-		return result
-	}
+	if (comp) return mapStatsToKeys(seed, comp.stats)
 
 	const entityRecipe = entityRecipes.find((r) => r.packedItemId === itemId)
-	if (entityRecipe) {
-		const values = decodeStats(seed, entityRecipe.stats.length)
-		const result: Record<string, number> = {}
-		for (let i = 0; i < entityRecipe.stats.length; i++) {
-			result[entityRecipe.stats[i].key] = values[i]
-		}
-		return result
-	}
+	if (entityRecipe) return mapStatsToKeys(seed, entityRecipe.stats)
+
+	const moduleRecipe = moduleRecipes.find((r) => r.itemId === itemId)
+	if (moduleRecipe) return mapStatsToKeys(seed, moduleRecipe.stats)
 
 	return {}
 }
@@ -65,7 +66,7 @@ export function blendStacks(stacks: StackInput[], statKey: string): number {
 		totalQty += stack.quantity
 	}
 	if (totalQty === 0) return 0
-	return Math.round(weightedSum / totalQty)
+	return Math.floor(weightedSum / totalQty)
 }
 
 export function computeComponentStats(
@@ -104,7 +105,7 @@ export function computeEntityStats(
 	entityRecipeId: string,
 	componentStacks: Record<number, {quantity: number; stats: Record<string, number>}[]>
 ): {key: string; value: number}[] {
-	const recipe = getEntityRecipe(entityRecipeId)
+	const recipe = getEntityRecipe(entityRecipeId) ?? getModuleRecipe(entityRecipeId)
 	if (!recipe) return []
 
 	const blendedByComponent: Record<number, Record<string, number>> = {}
@@ -118,3 +119,24 @@ export function computeEntityStats(
 		return {key: stat.key, value: Math.max(1, Math.min(999, value))}
 	})
 }
+
+function decodeStackStats(itemId: number, seed: UInt64): Record<string, number> {
+	if (itemId >= 10000) {
+		return decodeCraftedItemStats(itemId, BigInt(seed.toString()))
+	}
+	const raw = deriveResourceStats(BigInt(seed.toString()))
+	return {stat1: raw.stat1, stat2: raw.stat2, stat3: raw.stat3}
+}
+
+export function blendCargoStacks(
+	itemId: number,
+	stacks: {quantity: number; seed: UInt64}[]
+): UInt64 {
+	const decoded = stacks.map((s) => ({
+		quantity: s.quantity,
+		stats: decodeStackStats(itemId, s.seed),
+	}))
+	const allKeys = Object.keys(decoded[0]?.stats ?? {})
+	const blended = allKeys.map((key) => Math.max(1, Math.min(999, blendStacks(decoded, key))))
+	return UInt64.from(encodeStats(blended))
+}

package/src/entities/makers.ts

@@ -5,26 +5,27 @@ import {Warehouse, WarehouseStateInput} from './warehouse'
 import {Container, ContainerStateInput} from './container'
 
 export function makeShip(state: ShipStateInput): Ship {
-    const entityInfo = ServerContract.Types.entity_info.from({
+    const info: Record<string, unknown> = {
         type: Name.from('ship'),
         id: UInt64.from(state.id),
         owner: Name.from(state.owner),
         entity_name: state.name,
         coordinates: ServerContract.Types.coordinates.from(state.coordinates),
-        hullmass: UInt32.from(state.hullmass),
-        capacity: UInt32.from(state.capacity),
-        energy: UInt16.from(state.energy),
         cargomass: UInt32.from(0),
         cargo: state.cargo || [],
         is_idle: !state.schedule,
         current_task_elapsed: UInt32.from(0),
         current_task_remaining: UInt32.from(0),
         pending_tasks: [],
-        engines: state.engines,
-        generator: state.generator,
-        loaders: state.loaders,
-        schedule: state.schedule,
-    })
+    }
+    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
+    const entityInfo = ServerContract.Types.entity_info.from(info)
     return new Ship(entityInfo)
 }
 

package/src/entities/ship-deploy.ts

@@ -0,0 +1,89 @@
+export function computeShipHullCapabilities(stats: Record<string, number>): {
+    hullmass: number
+    capacity: number
+} {
+    const density = stats.density ?? 500
+    const strength = stats.strength ?? 500
+    const ductility = stats.ductility ?? 500
+    const purity = stats.purity ?? 500
+
+    const hullmass = 25000 + 75 * density
+    const statSum = strength + ductility + purity
+    const exponent = statSum / 2997.0
+    const capacity = Math.floor(1000000 * Math.pow(10, exponent))
+
+    return {hullmass, capacity}
+}
+
+export function computeEngineCapabilities(stats: Record<string, number>): {
+    thrust: number
+    drain: number
+} {
+    const vol = stats.volatility ?? 500
+    const thm = stats.thermal ?? 500
+
+    return {
+        thrust: 400 + Math.floor(vol * 3 / 4),
+        drain: Math.max(16, 30 - Math.floor(thm / 70)),
+    }
+}
+
+export function computeGeneratorCapabilities(stats: Record<string, number>): {
+    capacity: number
+    recharge: number
+} {
+    const res = stats.resonance ?? 500
+    const clr = stats.clarity ?? 500
+
+    return {
+        capacity: 300 + Math.floor(res / 6),
+        recharge: 5 + Math.floor(clr * 15 / 1000),
+    }
+}
+
+export function computeExtractorCapabilities(stats: Record<string, number>): {
+    rate: number
+    drain: number
+    depth: number
+    drill: number
+} {
+    const str = stats.strength ?? 500
+    const con = stats.conductivity ?? 500
+    const ref = stats.reflectivity ?? 500
+    const tol = stats.tolerance ?? 500
+
+    return {
+        rate: 200 + str,
+        drain: Math.max(10, 50 - Math.floor(con / 20)),
+        depth: 200 + Math.floor(tol * 3 / 2),
+        drill: 100 + Math.floor(ref * 4 / 5),
+    }
+}
+
+export function computeLoaderCapabilities(stats: Record<string, number>): {
+    mass: number
+    thrust: number
+    quantity: number
+} {
+    const duc = stats.ductility ?? 500
+    const pla = stats.plasticity ?? 500
+
+    return {
+        mass: Math.max(200, 2000 - Math.floor(duc * 2)),
+        thrust: 1 + Math.floor(pla / 500),
+        quantity: 1,
+    }
+}
+
+export function computeManufacturingCapabilities(stats: Record<string, number>): {
+    speed: number
+    drain: number
+} {
+    const rea = stats.reactivity ?? 500
+    const clr = stats.clarity ?? 500
+
+    return {
+        speed: 100 + Math.floor(rea * 4 / 5),
+        drain: Math.max(5, 30 - Math.floor(clr / 33)),
+    }
+}

package/src/entities/ship.ts

@@ -28,12 +28,12 @@ export interface ShipStateInput {
     owner: string
     name: string
     coordinates: CoordinatesType | {x: number; y: number; z?: number}
-    hullmass: number
-    capacity: number
-    energy: number
-    engines: ServerContract.Types.movement_stats
-    generator: ServerContract.Types.energy_stats
-    loaders: ServerContract.Types.loader_stats
+    hullmass?: number
+    capacity?: number
+    energy?: number
+    engines?: ServerContract.Types.movement_stats
+    generator?: ServerContract.Types.energy_stats
+    loaders?: ServerContract.Types.loader_stats
     schedule?: ServerContract.Types.schedule
     cargo?: ServerContract.Types.cargo_item[]
 }
@@ -108,6 +108,14 @@ export class Ship extends ServerContract.Types.entity_info {
         return schedule.isExtracting(this, now)
     }
 
+    get hasEngines(): boolean {
+        return this.engines !== undefined
+    }
+
+    get hasGenerator(): boolean {
+        return this.generator !== undefined
+    }
+
     get hasExtractor(): boolean {
         return this.extractor !== undefined
     }

package/src/index-module.ts

@@ -141,24 +141,43 @@ export * from './types/capabilities'
 export * from './types/entity'
 export * from './capabilities'
 
+export {categoryColors, tierColors, categoryIcons, componentIcon, moduleIcon} from './data/colors'
+
 export {
    components,
    entityRecipes,
+   moduleRecipes,
    getComponentById,
    getEntityRecipe,
    getEntityRecipeByItemId,
+   getModuleRecipe,
+   getModuleRecipeByItemId,
    getAllCraftableItems,
    getComponentsForCategory,
    getComponentsForStat,
    ITEM_HULL_PLATES,
    ITEM_CARGO_LINING,
    ITEM_CONTAINER_PACKED,
+   ITEM_THRUSTER_CORE,
+   ITEM_POWER_CELL,
+   ITEM_ENGINE_T1,
+   ITEM_GENERATOR_T1,
+   ITEM_SHIP_T1_PACKED,
+   ITEM_DRILL_SHAFT,
+   ITEM_EXTRACTION_PROBE,
+   ITEM_CARGO_ARM,
+   ITEM_TOOL_BIT,
+   ITEM_REACTION_CHAMBER,
+   ITEM_EXTRACTOR_T1,
+   ITEM_LOADER_T1,
+   ITEM_MANUFACTURING_T1,
 } from './data/recipes'
 export type {
    ComponentDefinition,
    ComponentStat,
    RecipeInput,
    EntityRecipe,
+   ModuleRecipe,
    CraftableItem,
 } from './data/recipes'
 
@@ -170,7 +189,20 @@ export {
    computeComponentStats,
    blendComponentStacks,
    computeEntityStats,
+   blendCargoStacks,
 } from './derivation/crafting'
 export type {StackInput, CategoryStacks} from './derivation/crafting'
 
 export {computeContainerCapabilities} from './entities/container'
+
+export {
+    computeShipHullCapabilities,
+    computeEngineCapabilities,
+    computeGeneratorCapabilities,
+    computeExtractorCapabilities,
+    computeLoaderCapabilities,
+    computeManufacturingCapabilities,
+} from './entities/ship-deploy'
+
+export {resolveItem} from './resolution/resolve-item'
+export type {ResolvedItem, ResolvedItemStat, ResolvedAttributeGroup, ResolvedItemType} from './resolution/resolve-item'

package/src/managers/actions.ts

@@ -120,14 +120,10 @@ export class ActionsManager extends BaseManager {
         entityId: UInt64Type,
         recipeId: number,
         quantity: number,
-        inputs: {itemId: number; quantity: number; seed?: bigint}[]
+        inputs: ServerContract.ActionParams.Type.cargo_item[]
     ): Action {
         const cargoInputs = inputs.map((i) =>
-            ServerContract.Types.cargo_item.from({
-                item_id: UInt16.from(i.itemId),
-                quantity: UInt32.from(i.quantity),
-                seed: i.seed !== undefined ? UInt64.from(i.seed) : null,
-            })
+            ServerContract.Types.cargo_item.from(i)
         )
         return this.server.action('craft', {
             entity_type: entityType,
@@ -138,6 +134,21 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    blend(
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        inputs: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action {
+        const cargoInputs = inputs.map((i) =>
+            ServerContract.Types.cargo_item.from(i)
+        )
+        return this.server.action('blend', {
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+            inputs: cargoInputs,
+        })
+    }
+
     deploy(
         entityType: EntityTypeName,
         entityId: UInt64Type,
@@ -154,6 +165,36 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    addmodule(
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        moduleIndex: number,
+        moduleCargoId: UInt64Type,
+        targetCargoId: UInt64Type = UInt64.from(0)
+    ): Action {
+        return this.server.action('addmodule', {
+            entity_type: entityType,
+            entity_id: UInt64.from(entityId),
+            module_index: moduleIndex,
+            module_cargo_id: UInt64.from(moduleCargoId),
+            target_cargo_id: UInt64.from(targetCargoId),
+        })
+    }
+
+    rmmodule(
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        moduleIndex: number,
+        targetCargoId: UInt64Type = UInt64.from(0)
+    ): Action {
+        return this.server.action('rmmodule', {
+            entity_type: entityType,
+            entity_id: UInt64.from(entityId),
+            module_index: moduleIndex,
+            target_cargo_id: UInt64.from(targetCargoId),
+        })
+    }
+
     joinGame(account: NameType, companyName: string): Action[] {
         return [this.foundCompany(account, companyName), this.join(account)]
     }