@shipload/sdk 2.0.0-rc10 → 2.0.0-rc12

package/src/data/capabilities.ts

@@ -17,7 +17,7 @@ export const capabilityNames: string[] = [
     'Movement',
     'Energy',
     'Loader',
-    'Extraction',
+    'Gathering',
     'Warp',
     'Manufacturing',
     'Launch',
@@ -33,10 +33,10 @@ export const capabilityAttributes: CapabilityAttribute[] = [
     {capability: 'Energy', attribute: 'recharge', description: 'Energy regeneration rate'},
     {capability: 'Loader', attribute: 'mass', description: 'Weight of the loader unit itself'},
     {capability: 'Loader', attribute: 'thrust', description: 'Loading speed/force'},
-    {capability: 'Extraction', attribute: 'rate', description: 'Mass extracted per second'},
-    {capability: 'Extraction', attribute: 'drain', description: 'Energy consumed per extraction'},
-    {capability: 'Extraction', attribute: 'depth', description: 'Maximum extraction depth'},
-    {capability: 'Extraction', attribute: 'drill', description: 'Drilling speed/penetration'},
+    {capability: 'Gathering', attribute: 'yield', description: 'Mass gathered per second'},
+    {capability: 'Gathering', attribute: 'drain', description: 'Energy consumed per gather'},
+    {capability: 'Gathering', attribute: 'depth', description: 'Maximum gather depth'},
+    {capability: 'Gathering', attribute: 'speed', description: 'Gathering speed/penetration'},
     {capability: 'Warp', attribute: 'range', description: 'Maximum warp distance'},
     {capability: 'Manufacturing', attribute: 'speed', description: 'Crafting time per item'},
     {
@@ -68,9 +68,9 @@ export const capabilityAttributes: CapabilityAttribute[] = [
 export const statMappings: StatMapping[] = [
     {
         stat: 'Strength',
-        capability: 'Extraction',
-        attribute: 'rate',
-        rationale: 'Raw mechanical force drives faster extraction',
+        capability: 'Gathering',
+        attribute: 'yield',
+        rationale: 'Raw mechanical force drives faster gathering',
     },
     {
         stat: 'Strength',
@@ -98,7 +98,7 @@ export const statMappings: StatMapping[] = [
     },
     {
         stat: 'Tolerance',
-        capability: 'Extraction',
+        capability: 'Gathering',
         attribute: 'depth',
         rationale: 'Housing withstands pressure/heat at extreme depths',
     },
@@ -134,9 +134,9 @@ export const statMappings: StatMapping[] = [
     },
     {
         stat: 'Conductivity',
-        capability: 'Extraction',
+        capability: 'Gathering',
         attribute: 'drain',
-        rationale: 'Efficient energy transfer reduces extraction energy cost',
+        rationale: 'Efficient energy transfer reduces gathering energy cost',
     },
     {
         stat: 'Conductivity',
@@ -158,9 +158,9 @@ export const statMappings: StatMapping[] = [
     },
     {
         stat: 'Ductility',
-        capability: 'Extraction',
-        attribute: 'rate',
-        rationale: 'Precisely shaped drill components extract faster',
+        capability: 'Gathering',
+        attribute: 'yield',
+        rationale: 'Precisely shaped conduit components gather faster',
     },
     {
         stat: 'Ductility',
@@ -176,7 +176,7 @@ export const statMappings: StatMapping[] = [
     },
     {
         stat: 'Reflectivity',
-        capability: 'Extraction',
+        capability: 'Gathering',
         attribute: 'depth',
         rationale: 'Reflective heat shielding protects equipment at depth',
     },
@@ -188,9 +188,9 @@ export const statMappings: StatMapping[] = [
     },
     {
         stat: 'Volatility',
-        capability: 'Extraction',
-        attribute: 'rate',
-        rationale: 'Energy release powers faster extraction',
+        capability: 'Gathering',
+        attribute: 'yield',
+        rationale: 'Energy release powers faster gathering',
     },
     {
         stat: 'Volatility',
@@ -218,9 +218,9 @@ export const statMappings: StatMapping[] = [
     },
     {
         stat: 'Reactivity',
-        capability: 'Extraction',
-        attribute: 'drill',
-        rationale: 'Reactive gases manage heat/friction during drilling',
+        capability: 'Gathering',
+        attribute: 'speed',
+        rationale: 'Reactive gases manage heat/friction during gathering',
     },
     {
         stat: 'Reactivity',
@@ -236,9 +236,9 @@ export const statMappings: StatMapping[] = [
     },
     {
         stat: 'Thermal',
-        capability: 'Extraction',
+        capability: 'Gathering',
         attribute: 'drain',
-        rationale: 'Thermal management reduces energy waste during extraction',
+        rationale: 'Thermal management reduces energy waste during gathering',
     },
     {
         stat: 'Thermal',
@@ -326,9 +326,9 @@ export const statMappings: StatMapping[] = [
     },
     {
         stat: 'Insulation',
-        capability: 'Extraction',
+        capability: 'Gathering',
         attribute: 'drain',
-        rationale: 'Better insulation reduces energy loss during extraction',
+        rationale: 'Better insulation reduces energy loss during gathering',
     },
     {
         stat: 'Insulation',
@@ -350,9 +350,9 @@ export const statMappings: StatMapping[] = [
     },
     {
         stat: 'Purity',
-        capability: 'Extraction',
-        attribute: 'drill',
-        rationale: 'Purer bio-lubricants reduce friction during drilling',
+        capability: 'Gathering',
+        attribute: 'speed',
+        rationale: 'Purer bio-lubricants reduce friction during gathering',
     },
     {
         stat: 'Purity',

package/src/data/categories.ts

@@ -20,7 +20,7 @@ const categories: CategoryInfo[] = [
     {
         id: 'precious',
         name: 'Precious Metals',
-        label: 'Precious',
+        label: 'Precious Metal',
         description:
             'Conductive, corrosion-resistant — electronics, energy systems, precision components',
         color: categoryColors.precious,

package/src/data/colors.ts

@@ -37,6 +37,7 @@ export const itemIcons: Record<number, string> = {
     10007: 'CA',
     10008: 'TB',
     10009: 'RC',
+    10010: 'FA',
     10100: 'EN',
     10101: 'GN',
     10102: 'EX',

package/src/data/recipes.ts

@@ -1,6 +1,6 @@
 import {
     ITEM_ENGINE_T1,
-    ITEM_EXTRACTOR_T1,
+    ITEM_GATHERER_T1,
     ITEM_GENERATOR_T1,
     ITEM_HAULER_T1,
     ITEM_LOADER_T1,
@@ -9,7 +9,7 @@ import {
     MODULE_ANY,
     MODULE_CRAFTER,
     MODULE_ENGINE,
-    MODULE_EXTRACTOR,
+    MODULE_GATHERER,
     MODULE_GENERATOR,
     MODULE_HAULER,
     MODULE_LOADER,
@@ -20,15 +20,15 @@ import type {ResourceCategory} from '../types'
 export {
     ITEM_ENGINE_T1,
     ITEM_GENERATOR_T1,
-    ITEM_EXTRACTOR_T1,
+    ITEM_GATHERER_T1,
     ITEM_LOADER_T1,
     ITEM_MANUFACTURING_T1,
     ITEM_STORAGE_T1,
     ITEM_HAULER_T1,
 }
 
-export const ITEM_DRILL_SHAFT = 10005
-export const ITEM_EXTRACTION_PROBE = 10006
+export const ITEM_MATTER_CONDUIT = 10005
+export const ITEM_SURVEY_PROBE = 10006
 export const ITEM_CARGO_ARM = 10007
 export const ITEM_TOOL_BIT = 10008
 export const ITEM_REACTION_CHAMBER = 10009
@@ -158,9 +158,9 @@ export const components: ComponentDefinition[] = [
         usedIn: [{type: 'module', name: 'Generator'}],
     },
     {
-        id: ITEM_DRILL_SHAFT,
-        name: 'Drill Shaft',
-        description: 'Heavy-duty metal shaft used in extraction equipment.',
+        id: ITEM_MATTER_CONDUIT,
+        name: 'Matter Conduit',
+        description: 'Heavy-duty metal shaft used in gathering equipment.',
         color: '#7B8D9E',
         mass: 50000,
         stats: [
@@ -168,11 +168,11 @@ export const components: ComponentDefinition[] = [
             {key: 'tolerance', source: 'metal'},
         ],
         recipe: [{category: 'metal' as ResourceCategory, quantity: 15}],
-        usedIn: [{type: 'module', name: 'Extractor'}],
+        usedIn: [{type: 'module', name: 'Gatherer'}],
     },
     {
-        id: ITEM_EXTRACTION_PROBE,
-        name: 'Extraction Probe',
+        id: ITEM_SURVEY_PROBE,
+        name: 'Survey Probe',
         description: 'Precious metal sensor array for deep resource detection.',
         color: '#D4A843',
         mass: 30000,
@@ -181,7 +181,7 @@ export const components: ComponentDefinition[] = [
             {key: 'reflectivity', source: 'precious'},
         ],
         recipe: [{category: 'precious' as ResourceCategory, quantity: 10}],
-        usedIn: [{type: 'module', name: 'Extractor'}],
+        usedIn: [{type: 'module', name: 'Gatherer'}],
     },
     {
         id: ITEM_CARGO_ARM,
@@ -395,32 +395,32 @@ export const moduleRecipes: ModuleRecipe[] = [
         ],
     },
     {
-        id: 'extractor-t1',
-        name: 'Extractor',
-        description: 'Basic extraction system. Drills and probes for raw resources.',
+        id: 'gatherer-t1',
+        name: 'Gatherer',
+        description: 'Basic gathering system. Probes and conduits for raw resources.',
         color: '#7B8D9E',
-        itemId: ITEM_EXTRACTOR_T1,
-        moduleType: MODULE_EXTRACTOR,
+        itemId: ITEM_GATHERER_T1,
+        moduleType: MODULE_GATHERER,
         recipe: [
-            {itemId: ITEM_DRILL_SHAFT, quantity: 4},
-            {itemId: ITEM_EXTRACTION_PROBE, quantity: 3},
+            {itemId: ITEM_MATTER_CONDUIT, quantity: 4},
+            {itemId: ITEM_SURVEY_PROBE, quantity: 3},
         ],
         stats: [
-            {key: 'strength', sourceComponentId: ITEM_DRILL_SHAFT, sourceStatKey: 'strength'},
-            {key: 'tolerance', sourceComponentId: ITEM_DRILL_SHAFT, sourceStatKey: 'tolerance'},
+            {key: 'strength', sourceComponentId: ITEM_MATTER_CONDUIT, sourceStatKey: 'strength'},
+            {key: 'tolerance', sourceComponentId: ITEM_MATTER_CONDUIT, sourceStatKey: 'tolerance'},
             {
                 key: 'reflectivity',
-                sourceComponentId: ITEM_EXTRACTION_PROBE,
+                sourceComponentId: ITEM_SURVEY_PROBE,
                 sourceStatKey: 'reflectivity',
             },
             {
                 key: 'conductivity',
-                sourceComponentId: ITEM_EXTRACTION_PROBE,
+                sourceComponentId: ITEM_SURVEY_PROBE,
                 sourceStatKey: 'conductivity',
             },
             {
-                key: 'reflectivity_drill',
-                sourceComponentId: ITEM_EXTRACTION_PROBE,
+                key: 'reflectivity_speed',
+                sourceComponentId: ITEM_SURVEY_PROBE,
                 sourceStatKey: 'reflectivity',
             },
         ],

package/src/derivation/crafting.ts

@@ -4,9 +4,11 @@ import {
     entityRecipes,
     getComponentById,
     getEntityRecipe,
+    getEntityRecipeByItemId,
     getModuleRecipe,
     moduleRecipes,
 } from '../data/recipes'
+import {getStatDefinitions} from './stats'
 import {deriveResourceStats} from './stratum'
 
 export interface StackInput {
@@ -195,3 +197,77 @@ export function blendCargoStacks(
     const blended = allKeys.map((key) => Math.max(1, Math.min(999, blendStacks(decoded, key))))
     return UInt64.from(encodeStats(blended))
 }
+
+export interface RecipeSlotInput {
+    itemId: number
+    category: ResourceCategory | undefined
+    stacks: {quantity: number; seed: bigint}[]
+}
+
+function decodeRawStackToCategoryStats(
+    seed: 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
+    return result
+}
+
+export function computeCraftedOutputSeed(
+    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.seed)
+                    : decodeRawStackToCategoryStats(s.seed, 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 entityRecipe = getEntityRecipeByItemId(outputItemId)
+    if (entityRecipe) {
+        const componentStacks: Record<number, {quantity: number; stats: Record<string, number>}[]> =
+            {}
+        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}`
+                )
+            }
+            const list = (componentStacks[slot.itemId] ??= [])
+            for (const s of slot.stacks) {
+                list.push({
+                    quantity: s.quantity,
+                    stats: decodeCraftedItemStats(slot.itemId, s.seed),
+                })
+            }
+        }
+        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(`computeCraftedOutputSeed: no recipe found for outputItemId=${outputItemId}`)
+}

package/src/derivation/index.ts

@@ -7,7 +7,6 @@ export {
     getLocationCandidates,
     getDepthThreshold,
     getResourceTier,
-    depthScaleFactor,
     DEPTH_THRESHOLD_T1,
     DEPTH_THRESHOLD_T2,
     DEPTH_THRESHOLD_T3,
@@ -24,5 +23,8 @@ export {
     PLANET_SUBTYPE_INDUSTRIAL,
 } from './resources'
 
+export {RESERVE_TIERS, TIER_ROLL_MAX, rollTier, rollWithinTier} from './tiers'
+export type {ReserveTier, TierRange} from './tiers'
+
 export * from './stats'
 export * from './crafting'

package/src/derivation/resources.ts

@@ -9,7 +9,7 @@ export const DEPTH_THRESHOLD_T5 = 55000
 export const LOCATION_MIN_DEPTH = 500
 export const LOCATION_MAX_DEPTH = 65535
 
-export const YIELD_THRESHOLD = Math.floor(0.003 * 0xffffffff)
+export const YIELD_THRESHOLD = Math.floor(0.001 * 0xffffffff)
 
 export const PLANET_SUBTYPE_GAS_GIANT = 0
 export const PLANET_SUBTYPE_ROCKY = 1
@@ -134,9 +134,3 @@ export function getEligibleResources(
         return stratum >= threshold
     })
 }
-
-export function depthScaleFactor(stratum: number): number {
-    if (stratum <= 1) return 1.0
-    const logScale = Math.log(stratum) / Math.log(65535)
-    return 1.0 + logScale * 2.0
-}

package/src/derivation/stratum.ts

@@ -1,12 +1,8 @@
 import {Bytes, Checksum256, Checksum256Type} from '@wharfkit/antelope'
 import {hash512} from '../utils/hash'
 import {Coordinates, CoordinatesType} from '../types'
-import {
-    depthScaleFactor,
-    getEligibleResources,
-    getResourceWeight,
-    YIELD_THRESHOLD,
-} from './resources'
+import {getEligibleResources, getResourceWeight, YIELD_THRESHOLD} from './resources'
+import {RESERVE_TIERS, rollTier, rollWithinTier} from './tiers'
 
 export interface StratumInfo {
     itemId: number
@@ -39,9 +35,10 @@ export function deriveStratum(
 
     let reserve = 0
     if (rawReserve <= YIELD_THRESHOLD) {
-        const baseReserve = (rawReserve % 333) + 1
-        const scale = depthScaleFactor(stratum)
-        reserve = Math.floor(baseReserve * scale)
+        const tierRoll = ((bytes[18] << 8) | bytes[19]) >>> 0
+        const withinRoll = ((bytes[20] << 8) | bytes[21]) >>> 0
+        const tier = rollTier(tierRoll, stratum)
+        reserve = rollWithinTier(withinRoll, RESERVE_TIERS[tier])
     }
 
     if (reserve === 0) return {itemId: 0, seed: 0n, richness: 0, reserve: 0}
@@ -94,25 +91,32 @@ export function deriveStratum(
 
 export function deriveResourceStats(seed: bigint): ResourceStats {
     const seedBytes = new Uint8Array(8)
-    for (let i = 7; i >= 0; i--) {
+    for (let i = 0; i < 8; i++) {
         seedBytes[i] = Number(seed & 0xffn)
         seed >>= 8n
     }
     const hashResult = Checksum256.hash(Bytes.from(seedBytes))
     const hashBytes = hashResult.array
 
-    const extractU16 = (offset: number): number => (hashBytes[offset] << 8) | hashBytes[offset + 1]
+    const extractU32 = (offset: number): number =>
+        (hashBytes[offset] * 0x1000000 +
+            (hashBytes[offset + 1] << 16) +
+            (hashBytes[offset + 2] << 8) +
+            hashBytes[offset + 3]) >>>
+        0
 
     const weibull = (raw: number): number => {
-        const u = raw / 65536
-        let x = 0.27 * Math.sqrt(-Math.log(1 - u))
+        const u = raw / 4294967296
+        let x = 0.24 * Math.sqrt(-Math.log(1 - u))
         if (x > 1) x = 1
-        return Math.floor(x * 999) + 1
+        let val = Math.floor(x * 999) + 1
+        if (val > 999) val = 999
+        return val
     }
 
     return {
-        stat1: weibull(extractU16(0)),
-        stat2: weibull(extractU16(2)),
-        stat3: weibull(extractU16(4)),
+        stat1: weibull(extractU32(0)),
+        stat2: weibull(extractU32(4)),
+        stat3: weibull(extractU32(8)),
     }
 }

package/src/derivation/tiers.ts

@@ -0,0 +1,54 @@
+export type ReserveTier = 'small' | 'medium' | 'large' | 'massive' | 'motherlode'
+
+export interface TierRange {
+    min: number
+    max: number
+}
+
+export const RESERVE_TIERS: Record<ReserveTier, TierRange> = {
+    small: {min: 15, max: 60},
+    medium: {min: 100, max: 200},
+    large: {min: 400, max: 700},
+    massive: {min: 1000, max: 2500},
+    motherlode: {min: 4000, max: 10000},
+}
+
+const SHALLOW_THRESHOLDS = {
+    small: 0.8,
+    medium: 0.991946,
+    large: 0.999946,
+    massive: 0.999996,
+}
+
+const DEEP_THRESHOLDS = {
+    small: 0.5,
+    medium: 0.95892,
+    large: 0.99892,
+    massive: 0.99992,
+}
+
+export const TIER_ROLL_MAX = 0x10000 // 65536
+
+function lerp(a: number, b: number, t: number): number {
+    return a + (b - a) * t
+}
+
+export function rollTier(tierRoll: number, stratum: number): ReserveTier {
+    const d = Math.min(stratum, 65535) / 65535
+    const smallMax = lerp(SHALLOW_THRESHOLDS.small, DEEP_THRESHOLDS.small, d) * TIER_ROLL_MAX
+    const mediumMax = lerp(SHALLOW_THRESHOLDS.medium, DEEP_THRESHOLDS.medium, d) * TIER_ROLL_MAX
+    const largeMax = lerp(SHALLOW_THRESHOLDS.large, DEEP_THRESHOLDS.large, d) * TIER_ROLL_MAX
+    const massiveMax = lerp(SHALLOW_THRESHOLDS.massive, DEEP_THRESHOLDS.massive, d) * TIER_ROLL_MAX
+
+    if (tierRoll < smallMax) return 'small'
+    if (tierRoll < mediumMax) return 'medium'
+    if (tierRoll < largeMax) return 'large'
+    if (tierRoll < massiveMax) return 'massive'
+    return 'motherlode'
+}
+
+export function rollWithinTier(withinRoll: number, range: TierRange): number {
+    const u = withinRoll / 65535
+    const skewed = u * u
+    return Math.floor(range.min + skewed * (range.max - range.min))
+}

package/src/entities/location.ts

@@ -1,6 +1,6 @@
 import {Checksum256, Checksum256Type, UInt16Type, UInt64} from '@wharfkit/antelope'
 import {Coordinates, CoordinatesType, Distance, LocationType} from '../types'
-import {getLocationType, hasSystem, isExtractableLocation} from '../utils/system'
+import {getLocationType, hasSystem, isGatherableLocation} from '../utils/system'
 import {findNearbyPlanets} from '../travel/travel'
 
 export class Location {
@@ -30,8 +30,8 @@ export class Location {
         return getLocationType(gameSeed, this.coordinates)
     }
 
-    isExtractableAt(gameSeed: Checksum256Type): boolean {
-        return isExtractableLocation(this.getLocationTypeAt(gameSeed))
+    isGatherableAt(gameSeed: Checksum256Type): boolean {
+        return isGatherableLocation(this.getLocationTypeAt(gameSeed))
     }
 
     findNearby(gameSeed: Checksum256Type, maxDistance: UInt16Type = 20): Distance[] {

package/src/entities/ship-deploy.ts

@@ -3,7 +3,7 @@ import {
     getModuleCapabilityType,
     MODULE_CRAFTER,
     MODULE_ENGINE,
-    MODULE_EXTRACTOR,
+    MODULE_GATHERER,
     MODULE_GENERATOR,
     MODULE_HAULER,
     MODULE_LOADER,
@@ -52,11 +52,11 @@ export function computeGeneratorCapabilities(stats: Record<string, number>): {
     }
 }
 
-export function computeExtractorCapabilities(stats: Record<string, number>): {
-    rate: number
+export function computeGathererCapabilities(stats: Record<string, number>): {
+    yield: number
     drain: number
     depth: number
-    drill: number
+    speed: number
 } {
     const str = stats.strength ?? 500
     const con = stats.conductivity ?? 500
@@ -64,10 +64,10 @@ export function computeExtractorCapabilities(stats: Record<string, number>): {
     const tol = stats.tolerance ?? 500
 
     return {
-        rate: 200 + str,
+        yield: 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),
+        speed: 100 + Math.floor((ref * 4) / 5),
     }
 }
 
@@ -153,7 +153,7 @@ export function computeWarehouseHullCapabilities(stats: Record<string, number>):
 export interface ShipCapabilities {
     engines?: {thrust: number; drain: number}
     generator?: {capacity: number; recharge: number}
-    extractor?: {rate: number; drain: number; depth: number; drill: number}
+    gatherer?: {yield: number; drain: number; depth: number; speed: number}
     hauler?: {capacity: number; efficiency: number; drain: number}
     loaders?: {mass: number; thrust: number; quantity: number}
     crafter?: {speed: number; drain: number}
@@ -190,22 +190,22 @@ export function computeShipCapabilities(
         ship.generator = {capacity: totalCapacity, recharge: totalRecharge}
     }
 
-    const extractorModules = modules.filter(
-        (m) => getModuleCapabilityType(m.itemId) === MODULE_EXTRACTOR
+    const gathererModules = modules.filter(
+        (m) => getModuleCapabilityType(m.itemId) === MODULE_GATHERER
     )
-    if (extractorModules.length > 0) {
-        let totalRate = 0
+    if (gathererModules.length > 0) {
+        let totalYield = 0
         let totalDrain = 0
         let totalDepth = 0
-        let totalDrill = 0
-        for (const m of extractorModules) {
-            const caps = computeExtractorCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
-            totalRate += caps.rate
+        let totalSpeed = 0
+        for (const m of gathererModules) {
+            const caps = computeGathererCapabilities(decodeCraftedItemStats(m.itemId, m.seed))
+            totalYield += caps.yield
             totalDrain += caps.drain
             totalDepth += caps.depth
-            totalDrill += caps.drill
+            totalSpeed += caps.speed
         }
-        ship.extractor = {rate: totalRate, drain: totalDrain, depth: totalDepth, drill: totalDrill}
+        ship.gatherer = {yield: totalYield, drain: totalDrain, depth: totalDepth, speed: totalSpeed}
     }
 
     const haulerModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_HAULER)

package/src/entities/ship.ts

@@ -104,8 +104,8 @@ export class Ship extends ServerContract.Types.entity_info {
         return schedule.isUnloading(this, now)
     }
 
-    isExtracting(now: Date): boolean {
-        return schedule.isExtracting(this, now)
+    isGathering(now: Date): boolean {
+        return schedule.isGathering(this, now)
     }
 
     get hasEngines(): boolean {
@@ -116,8 +116,8 @@ export class Ship extends ServerContract.Types.entity_info {
         return this.generator !== undefined
     }
 
-    get hasExtractor(): boolean {
-        return this.extractor !== undefined
+    get hasGatherer(): boolean {
+        return this.gatherer !== undefined
     }
 
     get hasWarp(): boolean {

package/src/errors.ts

@@ -44,3 +44,8 @@ export const SHIP_CARGO_NOT_LOADED = 'Cannot unload cargo that is not loaded.'
 export const WAREHOUSE_NOT_FOUND = 'Cannot find warehouse for given id.'
 export const WAREHOUSE_ALREADY_AT_LOCATION = 'Warehouse already exists at this location.'
 export const WAREHOUSE_CAPACITY_EXCEEDED = 'Warehouse capacity would be exceeded.'
+export const ENTITY_CAPACITY_EXCEEDED = 'Entity cargo capacity would be exceeded.'
+export const RECIPE_INPUTS_INSUFFICIENT = 'Insufficient inputs for recipe.'
+export const RECIPE_INPUTS_INVALID = 'Input cargo does not match recipe requirements.'
+export const RECIPE_INPUTS_EXCESS = 'Provided inputs exceed recipe requirements.'
+export const RECIPE_INPUTS_MIXED = 'All stacks for a recipe input must be the same resource.'