@shipload/sdk 2.0.0-rc20 → 2.0.0-rc21

package/src/derivation/crafting.ts

@@ -1,13 +1,7 @@
 import {UInt64} from '@wharfkit/antelope'
 import type {ResourceCategory} from '../types'
-import {
-    entityRecipes,
-    getComponentById,
-    getEntityRecipe,
-    getEntityRecipeByItemId,
-    getModuleRecipe,
-    moduleRecipes,
-} from '../data/recipes'
+import {findItemByCategoryAndTier, getRecipe, Recipe} from '../data/recipes-runtime'
+import {getItem} from '../market/items'
 import {getStatDefinitions} from './stats'
 import {deriveResourceStats} from './stratum'
 
@@ -41,26 +35,45 @@ export function decodeStats(stats: bigint, count: number): number[] {
     return result
 }
 
-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]
+function getItemStatKeys(itemId: number): string[] {
+    const item = getItem(itemId)
+    if (item.type === 'resource') {
+        if (!item.category) return []
+        return getStatDefinitions(item.category).map((d) => d.key)
     }
-    return result
+    const recipe = getRecipe(itemId)
+    if (!recipe) return []
+    return recipe.statSlots.map((slot) => keyForStatSlot(recipe, slot))
 }
 
-export function decodeCraftedItemStats(itemId: number, stats: bigint): Record<string, number> {
-    const comp = getComponentById(itemId)
-    if (comp) return mapStatsToKeys(stats, comp.stats)
-
-    const entityRecipe = entityRecipes.find((r) => r.packedItemId === itemId)
-    if (entityRecipe) return mapStatsToKeys(stats, entityRecipe.stats)
+function keyForStatSlot(
+    recipe: Recipe,
+    slot: {sources: {inputIndex: number; statIndex: number}[]}
+): string {
+    const src = slot.sources[0]
+    if (!src) return ''
+    return keyForRecipeInputStat(recipe, src.inputIndex, src.statIndex)
+}
 
-    const moduleRecipe = moduleRecipes.find((r) => r.itemId === itemId)
-    if (moduleRecipe) return mapStatsToKeys(stats, moduleRecipe.stats)
+function keyForRecipeInputStat(recipe: Recipe, inputIndex: number, statIndex: number): string {
+    const input = recipe.inputs[inputIndex]
+    if (!input) return ''
+    if ('category' in input) {
+        const defs = getStatDefinitions(input.category)
+        return defs[statIndex]?.key ?? ''
+    }
+    // itemId-typed input — its stats follow that item's own statSlots layout.
+    const innerKeys = getItemStatKeys(input.itemId)
+    return innerKeys[statIndex] ?? ''
+}
 
-    return {}
+export function decodeCraftedItemStats(itemId: number, stats: bigint): Record<string, number> {
+    const keys = getItemStatKeys(itemId)
+    const result: Record<string, number> = {}
+    for (let i = 0; i < keys.length; i++) {
+        if (keys[i]) result[keys[i]] = decodeStat(stats, i)
+    }
+    return result
 }
 
 export function blendStacks(stacks: StackInput[], statKey: string): number {
@@ -75,20 +88,6 @@ export function blendStacks(stacks: StackInput[], statKey: string): number {
     return Math.floor(weightedSum / totalQty)
 }
 
-export function computeComponentStats(
-    componentId: number,
-    categoryStacks: CategoryStacks[]
-): {key: string; value: number}[] {
-    const comp = getComponentById(componentId)
-    if (!comp) return []
-
-    return comp.stats.map((statDef) => {
-        const matching = categoryStacks.find((cs) => cs.category === statDef.source)
-        const value = matching ? blendStacks(matching.stacks, statDef.key) : 0
-        return {key: statDef.key, value: Math.max(1, Math.min(999, value))}
-    })
-}
-
 export function blendComponentStacks(
     stacks: {quantity: number; stats: Record<string, number>}[]
 ): Record<string, number> {
@@ -107,11 +106,35 @@ export function blendComponentStacks(
     return result
 }
 
+export function computeComponentStats(
+    componentId: number,
+    categoryStacks: CategoryStacks[]
+): {key: string; value: number}[] {
+    const recipe = getRecipe(componentId)
+    if (!recipe) return []
+
+    return recipe.statSlots.map((slot) => {
+        const src = slot.sources[0]
+        const key = keyForStatSlot(recipe, slot)
+        const input = src ? recipe.inputs[src.inputIndex] : undefined
+        if (!input || !('category' in input)) {
+            return {key, value: Math.max(1, Math.min(999, 0))}
+        }
+        const matching = categoryStacks.find((cs) => cs.category === input.category)
+        const value = matching ? blendStacks(matching.stacks, key) : 0
+        return {key, value: Math.max(1, Math.min(999, value))}
+    })
+}
+
 export function computeEntityStats(
-    entityRecipeId: string,
+    entityItemIdOrLegacyId: number | string,
     componentStacks: Record<number, {quantity: number; stats: Record<string, number>}[]>
 ): {key: string; value: number}[] {
-    const recipe = getEntityRecipe(entityRecipeId) ?? getModuleRecipe(entityRecipeId)
+    const itemId =
+        typeof entityItemIdOrLegacyId === 'number'
+            ? entityItemIdOrLegacyId
+            : legacyEntityIdToItemId(entityItemIdOrLegacyId)
+    const recipe = getRecipe(itemId)
     if (!recipe) return []
 
     const blendedByComponent: Record<number, Record<string, number>> = {}
@@ -119,13 +142,35 @@ export function computeEntityStats(
         blendedByComponent[Number(compId)] = blendComponentStacks(stacks)
     }
 
-    return recipe.stats.map((stat) => {
-        const blended = blendedByComponent[stat.sourceComponentId] ?? {}
-        const value = blended[stat.sourceStatKey] ?? 0
-        return {key: stat.key, value: Math.max(1, Math.min(999, value))}
+    return recipe.statSlots.map((slot) => {
+        const src = slot.sources[0]
+        const key = keyForStatSlot(recipe, slot)
+        if (!src) return {key, value: 1}
+        const input = recipe.inputs[src.inputIndex]
+        if (!input || 'category' in input) {
+            return {key, value: 1}
+        }
+        const blended = blendedByComponent[input.itemId] ?? {}
+        const value = blended[key] ?? 0
+        return {key, value: Math.max(1, Math.min(999, value))}
     })
 }
 
+function legacyEntityIdToItemId(id: string): number {
+    switch (id) {
+        case 'container':
+            return 10200
+        case 'ship-t1':
+            return 10201
+        case 'warehouse-t1':
+            return 10202
+        case 'container-t2':
+            return 20200
+        default:
+            return 0
+    }
+}
+
 function decodeStackStats(itemId: number, stats: UInt64): Record<string, number> {
     if (itemId >= 10000) {
         return decodeCraftedItemStats(itemId, BigInt(stats.toString()))
@@ -134,43 +179,20 @@ function decodeStackStats(itemId: number, stats: UInt64): Record<string, number>
     return {stat1: decodeStat(s, 0), stat2: decodeStat(s, 1), stat3: decodeStat(s, 2)}
 }
 
-export const categoryItemMass: Record<string, number> = {
-    ore: 30000,
-    crystal: 40000,
-    gas: 15000,
-    regolith: 22000,
-    biomass: 15000,
-}
+export function computeInputMass(itemId: number): number {
+    const recipe = getRecipe(itemId)
+    if (!recipe) throw new Error(`computeInputMass: no recipe found for itemId=${itemId}`)
 
-export function computeInputMass(
-    itemId: string | number,
-    itemType: 'component' | 'module' | 'entity'
-): number {
-    if (itemType === 'component') {
-        const comp = getComponentById(itemId as number)
-        if (!comp) return 0
-        return comp.recipe.reduce((sum, input) => {
-            const mass = input.category ? categoryItemMass[input.category] ?? 0 : 0
-            return sum + mass * input.quantity
-        }, 0)
-    }
-    if (itemType === 'module') {
-        const mod = getModuleRecipe(itemId as string)
-        if (!mod) return 0
-        return mod.recipe.reduce((sum, input) => {
-            const comp = input.itemId ? getComponentById(input.itemId) : undefined
-            return sum + (comp?.mass ?? 0) * input.quantity
-        }, 0)
-    }
-    if (itemType === 'entity') {
-        const ent = getEntityRecipe(itemId as string)
-        if (!ent) return 0
-        return ent.recipe.reduce((sum, input) => {
-            const comp = input.itemId ? getComponentById(input.itemId) : undefined
-            return sum + (comp?.mass ?? 0) * input.quantity
-        }, 0)
+    let total = 0
+    for (const input of recipe.inputs) {
+        if ('itemId' in input) {
+            total += getItem(input.itemId).mass * input.quantity
+        } else {
+            const item = findItemByCategoryAndTier(input.category, input.tier)
+            total += item.mass * input.quantity
+        }
     }
-    return 0
+    return total
 }
 
 export function blendCrossGroup(sources: {value: number; weight: number}[]): number {
@@ -220,39 +242,41 @@ export function computeCraftedOutputStats(
     outputItemId: number,
     slotInputs: RecipeSlotInput[]
 ): UInt64 {
-    const component = getComponentById(outputItemId)
-    if (component) {
-        const categoryStacks: CategoryStacks[] = []
-        for (const slot of slotInputs) {
-            if (!slot.category) continue
-            const slotIsComponent = getComponentById(slot.itemId) !== undefined
-            const stacks: StackInput[] = slot.stacks.map((s) => ({
-                quantity: s.quantity,
-                stats: slotIsComponent
-                    ? decodeCraftedItemStats(slot.itemId, s.stats)
-                    : decodeRawStackToCategoryStats(s.stats, slot.category!),
-            }))
-            categoryStacks.push({category: slot.category, stacks})
-        }
-        const stats = computeComponentStats(outputItemId, categoryStacks)
-        const ordered = component.stats.map((statDef) => {
-            const found = stats.find((s) => s.key === statDef.key)
-            return found ? found.value : 0
-        })
-        return UInt64.from(encodeStats(ordered))
+    const recipe = getRecipe(outputItemId)
+    if (!recipe) {
+        throw new Error(
+            `computeCraftedOutputStats: no recipe found for outputItemId=${outputItemId}`
+        )
     }
 
-    const entityRecipe = getEntityRecipeByItemId(outputItemId)
-    if (entityRecipe) {
-        const componentStacks: Record<number, {quantity: number; stats: Record<string, number>}[]> =
-            {}
+    const outputItem = getItem(outputItemId)
+
+    if (outputItem.type === 'entity') {
         for (const slot of slotInputs) {
             if (slot.category !== undefined) {
                 throw new Error(
-                    `entity recipe ${entityRecipe.id} expects component inputs but slot itemId=${slot.itemId} has category=${slot.category}`
+                    `entity recipe ${outputItemId} expects component inputs but slot itemId=${slot.itemId} has category=${slot.category}`
                 )
             }
-            const list = (componentStacks[slot.itemId] ??= [])
+        }
+    }
+
+    // Decode each slot's stacks into key→value maps using the slot item's
+    // own stat layout, so blending works regardless of recipe shape.
+    const decodedByItem: Record<number, {quantity: number; stats: Record<string, number>}[]> = {}
+    const decodedByCategory: Partial<Record<ResourceCategory, StackInput[]>> = {}
+
+    for (const slot of slotInputs) {
+        if (slot.category !== undefined) {
+            const list = (decodedByCategory[slot.category] ??= [])
+            for (const s of slot.stacks) {
+                list.push({
+                    quantity: s.quantity,
+                    stats: decodeRawStackToCategoryStats(s.stats, slot.category),
+                })
+            }
+        } else {
+            const list = (decodedByItem[slot.itemId] ??= [])
             for (const s of slot.stacks) {
                 list.push({
                     quantity: s.quantity,
@@ -260,15 +284,52 @@ export function computeCraftedOutputStats(
                 })
             }
         }
-        const stats = computeEntityStats(entityRecipe.id, componentStacks)
-        const ordered = entityRecipe.stats.map((statDef) => {
-            const found = stats.find((s) => s.key === statDef.key)
-            return found ? found.value : 0
-        })
-        return UInt64.from(encodeStats(ordered))
     }
 
-    throw new Error(`computeCraftedOutputStats: no recipe found for outputItemId=${outputItemId}`)
+    // Pre-blend itemId inputs once per item id.
+    const blendedByItem: Record<number, Record<string, number>> = {}
+    for (const [id, stacks] of Object.entries(decodedByItem)) {
+        blendedByItem[Number(id)] = blendComponentStacks(stacks)
+    }
+
+    const out: number[] = []
+    for (const slot of recipe.statSlots) {
+        if (slot.sources.length === 0) {
+            out.push(0)
+            continue
+        }
+        if (slot.sources.length === 1 || recipe.blendWeights.length === 0) {
+            const src = slot.sources[0]
+            const key = keyForRecipeInputStat(recipe, src.inputIndex, src.statIndex)
+            const input = recipe.inputs[src.inputIndex]
+            let value = 0
+            if (input && 'category' in input) {
+                value = blendStacks(decodedByCategory[input.category] ?? [], key)
+            } else if (input) {
+                value = blendedByItem[input.itemId]?.[key] ?? 0
+            }
+            out.push(Math.max(1, Math.min(999, value)))
+        } else {
+            let weightedSum = 0
+            let totalWeight = 0
+            for (const src of slot.sources) {
+                const key = keyForRecipeInputStat(recipe, src.inputIndex, src.statIndex)
+                const input = recipe.inputs[src.inputIndex]
+                const weight = recipe.blendWeights[src.inputIndex] ?? 1
+                let value = 0
+                if (input && 'category' in input) {
+                    value = blendStacks(decodedByCategory[input.category] ?? [], key)
+                } else if (input) {
+                    value = blendedByItem[input.itemId]?.[key] ?? 0
+                }
+                weightedSum += value * weight
+                totalWeight += weight
+            }
+            const blended = totalWeight > 0 ? Math.floor(weightedSum / totalWeight) : 0
+            out.push(Math.max(1, Math.min(999, blended)))
+        }
+    }
+    return UInt64.from(encodeStats(out))
 }
 
 /**

package/src/derivation/resources.ts

@@ -1,4 +1,4 @@
-import {ResourceTier} from '../types'
+import {getItem} from '../market/items'
 
 export const DEPTH_THRESHOLD_T1 = 0
 export const DEPTH_THRESHOLD_T2 = 2000
@@ -18,47 +18,23 @@ export const PLANET_SUBTYPE_ICY = 3
 export const PLANET_SUBTYPE_OCEAN = 4
 export const PLANET_SUBTYPE_INDUSTRIAL = 5
 
-interface ResourceEntry {
-    id: number
-    tier: ResourceTier
-}
-
-const RESOURCE_CATALOG: ResourceEntry[] = [
-    {id: 101, tier: 't1'},
-    {id: 102, tier: 't2'},
-    {id: 103, tier: 't3'},
-    {id: 201, tier: 't1'},
-    {id: 202, tier: 't2'},
-    {id: 203, tier: 't3'},
-    {id: 301, tier: 't1'},
-    {id: 302, tier: 't2'},
-    {id: 303, tier: 't3'},
-    {id: 401, tier: 't1'},
-    {id: 402, tier: 't2'},
-    {id: 403, tier: 't3'},
-    {id: 501, tier: 't1'},
-    {id: 502, tier: 't2'},
-    {id: 503, tier: 't3'},
-]
-
-export function getDepthThreshold(tier: ResourceTier): number {
+export function getDepthThreshold(tier: number): number {
     switch (tier) {
-        case 't1':
+        case 1:
             return DEPTH_THRESHOLD_T1
-        case 't2':
+        case 2:
             return DEPTH_THRESHOLD_T2
-        case 't3':
+        case 3:
             return DEPTH_THRESHOLD_T3
-        case 't4':
+        case 4:
             return DEPTH_THRESHOLD_T4
-        case 't5':
+        default:
             return DEPTH_THRESHOLD_T5
     }
 }
 
-export function getResourceTier(itemId: number): ResourceTier {
-    const entry = RESOURCE_CATALOG.find((r) => r.id === itemId)
-    return entry ? entry.tier : 't5'
+export function getResourceTier(itemId: number): number {
+    return getItem(itemId).tier
 }
 
 export function getResourceWeight(itemId: number, stratum: number): number {
@@ -69,24 +45,24 @@ export function getResourceWeight(itemId: number, stratum: number): number {
     const depthAbove = stratum - threshold
 
     switch (tier) {
-        case 't1':
+        case 1:
             if (stratum < 2000) return 100
             if (stratum < 10000) return 80
             if (stratum < 30000) return 50
             return 30
-        case 't2':
+        case 2:
             if (depthAbove < 3000) return 40
             if (depthAbove < 8000) return 60
             return 50
-        case 't3':
+        case 3:
             if (depthAbove < 5000) return 20
             if (depthAbove < 15000) return 35
             return 40
-        case 't4':
+        case 4:
             if (depthAbove < 10000) return 10
             if (depthAbove < 25000) return 20
             return 30
-        case 't5':
+        default:
             return 10
     }
 }

package/src/entities/container.ts

@@ -76,12 +76,12 @@ export function computeContainerCapabilities(stats: Record<string, number>): {
 } {
     const density = stats['density'] ?? 500
     const strength = stats['strength'] ?? 500
-    const fineness = stats['fineness'] ?? 500
+    const hardness = stats['hardness'] ?? 500
     const saturation = stats['saturation'] ?? 500
 
     const hullmass = 25000 + 75 * density
 
-    const statSum = strength + fineness + saturation
+    const statSum = strength + hardness + saturation
     const exponent = statSum / 2997
     const capacity = Math.floor(1000000 * Math.pow(10, exponent))
 
@@ -94,12 +94,12 @@ export function computeContainerT2Capabilities(stats: Record<string, number>): {
 } {
     const strength = stats['strength'] ?? 0
     const density = stats['density'] ?? 0
-    const fineness = stats['fineness'] ?? 0
+    const hardness = stats['hardness'] ?? 0
     const saturation = stats['saturation'] ?? 0
 
     const hullmass = 20000 + 50 * density
 
-    const statSum = strength + fineness + saturation
+    const statSum = strength + hardness + saturation
     const exponent = statSum / 2500
     const capacity = Math.floor(1500000 * Math.pow(10, exponent))
 

package/src/entities/entity-inventory.ts

@@ -18,11 +18,11 @@ export class EntityInventory extends ServerContract.Types.cargo_item {
     }
 
     get name(): string {
-        return this.item.displayName
+        return this.item.name
     }
 
     get unitMass(): UInt32 {
-        return this.item.mass
+        return UInt32.from(this.item.mass)
     }
 
     get totalMass(): UInt64 {

package/src/entities/makers.ts

@@ -3,13 +3,16 @@ import {ServerContract} from '../contracts'
 import {PackedModuleInput, Ship, ShipStateInput} from './ship'
 import {computeWarehouseCapabilities, Warehouse, WarehouseStateInput} from './warehouse'
 import {Container, ContainerStateInput} from './container'
+import {ITEM_SHIP_T1_PACKED, ITEM_WAREHOUSE_T1_PACKED} from '../data/item-ids'
+import {getEntityLayout} from '../data/recipes-runtime'
+import {itemMetadata} from '../data/metadata'
+import {getItem} from '../market/items'
 import {
-    getEntitySlotLayout,
-    getModuleRecipeByItemId,
-    ITEM_SHIP_T1_PACKED,
-    ITEM_WAREHOUSE_T1_PACKED,
-} from '../data/recipes'
-import {getModuleCapabilityType, MODULE_STORAGE, moduleAccepts} from '../capabilities/modules'
+    getModuleCapabilityType,
+    MODULE_STORAGE,
+    moduleAccepts,
+    moduleSlotTypeToCode,
+} from '../capabilities/modules'
 import {computeShipCapabilities, computeStorageCapabilities} from './ship-deploy'
 import {decodeCraftedItemStats} from '../derivation/crafting'
 
@@ -18,9 +21,10 @@ function assignModulesToSlots(
     modules: PackedModuleInput[],
     entityLabel: string
 ): ServerContract.Types.module_entry[] {
-    const slots = getEntitySlotLayout(packedEntityItemId)
+    const layout = getEntityLayout(packedEntityItemId)
+    const slots = layout?.slots ?? []
     const result: Array<{type: number; installed?: ServerContract.Types.packed_module}> = slots.map(
-        (s) => ({type: s.type, installed: undefined})
+        (s) => ({type: moduleSlotTypeToCode(s.type), installed: undefined})
     )
 
     for (const mod of modules) {
@@ -28,8 +32,12 @@ function assignModulesToSlots(
         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}`
+            let modName: string
+            try {
+                modName = getItem(itemId).name
+            } catch {
+                modName = itemMetadata[itemId]?.name ?? `item ${itemId}`
+            }
             throw new Error(
                 `No compatible slot for module ${modName} (type ${modType}) on ${entityLabel}`
             )

package/src/entities/ship-deploy.ts

@@ -15,11 +15,11 @@ export function computeShipHullCapabilities(stats: Record<string, number>): {
 } {
     const density = stats.density ?? 500
     const strength = stats.strength ?? 500
-    const fineness = stats.fineness ?? 500
+    const hardness = stats.hardness ?? 500
     const saturation = stats.saturation ?? 500
 
     const hullmass = 25000 + 75 * density
-    const statSum = strength + fineness + saturation
+    const statSum = strength + hardness + saturation
     const exponent = statSum / 2997.0
     const capacity = Math.floor(1000000 * Math.pow(10, exponent))
 
@@ -76,11 +76,11 @@ export function computeLoaderCapabilities(stats: Record<string, number>): {
     thrust: number
     quantity: number
 } {
-    const fin = stats.fineness ?? 500
+    const hrd = stats.hardness ?? 500
     const pla = stats.plasticity ?? 500
 
     return {
-        mass: Math.max(200, 2000 - Math.floor(fin * 2)),
+        mass: Math.max(200, 2000 - Math.floor(hrd * 2)),
         thrust: 1 + Math.floor(pla / 500),
         quantity: 1,
     }
@@ -122,10 +122,10 @@ export function computeStorageCapabilities(
     capacityBonus: number
 } {
     const strength = stats.strength ?? 500
-    const fineness = stats.fineness ?? 500
+    const hardness = stats.hardness ?? 500
     const saturation = stats.saturation ?? 500
 
-    const statSum = strength + fineness + saturation
+    const statSum = strength + hardness + saturation
     const capacityBonus = Math.floor(
         (baseCapacity * (10 + Math.floor((statSum * 10) / 2997))) / 100
     )
@@ -139,11 +139,11 @@ export function computeWarehouseHullCapabilities(stats: Record<string, number>):
 } {
     const density = stats.density ?? 500
     const strength = stats.strength ?? 500
-    const fineness = stats.fineness ?? 500
+    const hardness = stats.hardness ?? 500
     const saturation = stats.saturation ?? 500
 
     const hullmass = 25000 + 75 * density
-    const statSum = strength + fineness + saturation
+    const statSum = strength + hardness + saturation
     const exponent = statSum / 2997.0
     const capacity = Math.floor(20000000 * Math.pow(10, exponent))
 

package/src/index-module.ts

@@ -1,6 +1,8 @@
 export * from './contracts'
 export * from './errors'
 export * from './types'
+export * from './data/item-ids'
+export * from './data/recipes-runtime'
 
 import {ServerContract} from './contracts'
 
@@ -182,51 +184,6 @@ export {
 } from './data/capabilities'
 export type {CapabilityAttribute, StatMapping} from './data/capabilities'
 
-export {
-    components,
-    entityRecipes,
-    moduleRecipes,
-    getComponentById,
-    getEntityRecipe,
-    getEntityRecipeByItemId,
-    getModuleRecipe,
-    getModuleRecipeByItemId,
-    getAllCraftableItems,
-    getComponentsForCategory,
-    getComponentsForStat,
-    ITEM_HULL_PLATES,
-    ITEM_CARGO_LINING,
-    ITEM_CONTAINER_T1_PACKED,
-    ITEM_THRUSTER_CORE,
-    ITEM_POWER_CELL,
-    ITEM_ENGINE_T1,
-    ITEM_GENERATOR_T1,
-    ITEM_SHIP_T1_PACKED,
-    ITEM_WAREHOUSE_T1_PACKED,
-    ITEM_MATTER_CONDUIT,
-    ITEM_SURVEY_PROBE,
-    ITEM_CARGO_ARM,
-    ITEM_TOOL_BIT,
-    ITEM_REACTION_CHAMBER,
-    ITEM_GATHERER_T1,
-    ITEM_LOADER_T1,
-    ITEM_CRAFTER_T1,
-    ITEM_STORAGE_T1,
-    ITEM_HULL_PLATES_T2,
-    ITEM_CARGO_LINING_T2,
-    ITEM_CONTAINER_T2_PACKED,
-    ITEM_FOCUSING_ARRAY,
-} from './data/recipes'
-export type {
-    ComponentDefinition,
-    ComponentStat,
-    RecipeInput,
-    EntityRecipe,
-    ModuleRecipe,
-    ModuleSlot,
-    CraftableItem,
-} from './data/recipes'
-
 export {
     encodeStats,
     encodeGatheredCargoStats,
@@ -239,7 +196,6 @@ export {
     computeEntityStats,
     blendCargoStacks,
     blendCrossGroup,
-    categoryItemMass,
     computeInputMass,
     computeCraftedOutputStats,
 } from './derivation/crafting'
@@ -321,7 +277,6 @@ export {
     computeCrafterDrain,
 } from './nft/description'
 
-export {getEntitySlotLayout} from './data/recipes'
 export {
     ITEM_TYPE_RESOURCE,
     ITEM_TYPE_COMPONENT,