@shipload/sdk 2.0.0-rc2 → 2.0.0-rc4

package/src/derivation/index.ts

@@ -0,0 +1,25 @@
+export {deriveStratum, deriveResourceStats} from './stratum'
+export type {StratumInfo, ResourceStats} from './stratum'
+export {deriveLocationSize} from './location-size'
+export {
+    getEligibleResources,
+    getResourceWeight,
+    getLocationCandidates,
+    getDepthThreshold,
+    getResourceRarity,
+    depthScaleFactor,
+    DEPTH_THRESHOLD_COMMON,
+    DEPTH_THRESHOLD_UNCOMMON,
+    DEPTH_THRESHOLD_RARE,
+    DEPTH_THRESHOLD_EPIC,
+    DEPTH_THRESHOLD_LEGENDARY,
+    LOCATION_MIN_DEPTH,
+    LOCATION_MAX_DEPTH,
+    YIELD_THRESHOLD,
+    PLANET_SUBTYPE_GAS_GIANT,
+    PLANET_SUBTYPE_ROCKY,
+    PLANET_SUBTYPE_TERRESTRIAL,
+    PLANET_SUBTYPE_ICY,
+    PLANET_SUBTYPE_OCEAN,
+    PLANET_SUBTYPE_INDUSTRIAL,
+} from './resources'

package/src/derivation/location-size.ts

@@ -0,0 +1,15 @@
+import {ServerContract} from '../contracts'
+import {LocationType} from '../types'
+import {LOCATION_MAX_DEPTH, LOCATION_MIN_DEPTH} from './resources'
+
+export function deriveLocationSize(loc: ServerContract.Types.location_static): number {
+    if (loc.type.toNumber() === LocationType.EMPTY) return 0
+
+    const raw = (loc.seed0.toNumber() << 8) | loc.seed1.toNumber()
+    const normalized = raw / 65535
+
+    const curved = Math.pow(normalized, 3.0)
+
+    const range = LOCATION_MAX_DEPTH - LOCATION_MIN_DEPTH
+    return Math.floor(LOCATION_MIN_DEPTH + curved * range)
+}

package/src/derivation/resources.ts

@@ -0,0 +1,141 @@
+import {ResourceRarity} from '../types'
+
+export const DEPTH_THRESHOLD_COMMON = 0
+export const DEPTH_THRESHOLD_UNCOMMON = 2000
+export const DEPTH_THRESHOLD_RARE = 10000
+export const DEPTH_THRESHOLD_EPIC = 30000
+export const DEPTH_THRESHOLD_LEGENDARY = 55000
+
+export const LOCATION_MIN_DEPTH = 500
+export const LOCATION_MAX_DEPTH = 65535
+
+export const YIELD_THRESHOLD = Math.floor(0.003 * 0xffffffff)
+
+export const PLANET_SUBTYPE_GAS_GIANT = 0
+export const PLANET_SUBTYPE_ROCKY = 1
+export const PLANET_SUBTYPE_TERRESTRIAL = 2
+export const PLANET_SUBTYPE_ICY = 3
+export const PLANET_SUBTYPE_OCEAN = 4
+export const PLANET_SUBTYPE_INDUSTRIAL = 5
+
+interface ResourceEntry {
+    id: number
+    rarity: ResourceRarity
+}
+
+const RESOURCE_CATALOG: ResourceEntry[] = [
+    {id: 26, rarity: 'common'},
+    {id: 1, rarity: 'common'},
+    {id: 14, rarity: 'common'},
+    {id: 6, rarity: 'common'},
+    {id: 29, rarity: 'uncommon'},
+    {id: 2, rarity: 'uncommon'},
+    {id: 1000, rarity: 'uncommon'},
+    {id: 1003, rarity: 'uncommon'},
+    {id: 22, rarity: 'rare'},
+    {id: 18, rarity: 'rare'},
+    {id: 1001, rarity: 'rare'},
+    {id: 1002, rarity: 'rare'},
+    {id: 74, rarity: 'epic'},
+    {id: 54, rarity: 'epic'},
+]
+
+export function getDepthThreshold(rarity: ResourceRarity): number {
+    switch (rarity) {
+        case 'common':
+            return DEPTH_THRESHOLD_COMMON
+        case 'uncommon':
+            return DEPTH_THRESHOLD_UNCOMMON
+        case 'rare':
+            return DEPTH_THRESHOLD_RARE
+        case 'epic':
+            return DEPTH_THRESHOLD_EPIC
+        case 'legendary':
+            return DEPTH_THRESHOLD_LEGENDARY
+    }
+}
+
+export function getResourceRarity(itemId: number): ResourceRarity {
+    const entry = RESOURCE_CATALOG.find((r) => r.id === itemId)
+    return entry ? entry.rarity : 'legendary'
+}
+
+export function getResourceWeight(itemId: number, stratum: number): number {
+    const rarity = getResourceRarity(itemId)
+    const threshold = getDepthThreshold(rarity)
+    if (stratum < threshold) return 0
+
+    const depthAbove = stratum - threshold
+
+    switch (rarity) {
+        case 'common':
+            if (stratum < 2000) return 100
+            if (stratum < 10000) return 80
+            if (stratum < 30000) return 50
+            return 30
+        case 'uncommon':
+            if (depthAbove < 3000) return 40
+            if (depthAbove < 8000) return 60
+            return 50
+        case 'rare':
+            if (depthAbove < 5000) return 20
+            if (depthAbove < 15000) return 35
+            return 40
+        case 'epic':
+            if (depthAbove < 10000) return 10
+            if (depthAbove < 25000) return 20
+            return 30
+        case 'legendary':
+            return 10
+    }
+}
+
+const ASTEROID_RESOURCES = [26, 29, 22, 74, 14, 1000, 1001]
+const NEBULA_RESOURCES = [1, 2, 18, 54]
+const GAS_GIANT_RESOURCES = [1, 2, 18, 54]
+const ROCKY_RESOURCES = [26, 29, 22, 74, 6, 1003, 1002]
+const TERRESTRIAL_RESOURCES = [6, 1003, 1002, 1001]
+const ICY_RESOURCES = [6, 14, 1000, 1001, 18]
+const OCEAN_RESOURCES = [1, 2, 1003, 1002]
+const INDUSTRIAL_RESOURCES = [26, 29, 22, 74, 14, 1000, 54]
+
+export function getLocationCandidates(locationType: number, subtype: number): number[] {
+    if (locationType === 2) return ASTEROID_RESOURCES
+    if (locationType === 3) return NEBULA_RESOURCES
+    if (locationType === 1) {
+        switch (subtype) {
+            case PLANET_SUBTYPE_GAS_GIANT:
+                return GAS_GIANT_RESOURCES
+            case PLANET_SUBTYPE_ROCKY:
+                return ROCKY_RESOURCES
+            case PLANET_SUBTYPE_TERRESTRIAL:
+                return TERRESTRIAL_RESOURCES
+            case PLANET_SUBTYPE_ICY:
+                return ICY_RESOURCES
+            case PLANET_SUBTYPE_OCEAN:
+                return OCEAN_RESOURCES
+            case PLANET_SUBTYPE_INDUSTRIAL:
+                return INDUSTRIAL_RESOURCES
+        }
+    }
+    return []
+}
+
+export function getEligibleResources(
+    locationType: number,
+    subtype: number,
+    stratum: number
+): number[] {
+    const candidates = getLocationCandidates(locationType, subtype)
+    return candidates.filter((itemId) => {
+        const rarity = getResourceRarity(itemId)
+        const threshold = getDepthThreshold(rarity)
+        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

@@ -0,0 +1,118 @@
+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'
+
+export interface StratumInfo {
+    itemId: number
+    seed: bigint
+    richness: number
+    reserve: number
+}
+
+export interface ResourceStats {
+    purity: number
+    density: number
+    reactivity: number
+    resonance: number
+}
+
+export function deriveStratum(
+    epochSeed: Checksum256Type,
+    coords: CoordinatesType,
+    stratum: number,
+    locationType: number,
+    subtype: number,
+    _maxDepth: number
+): StratumInfo {
+    const seed = Checksum256.from(epochSeed)
+    const c = Coordinates.from(coords)
+    const input = `stratum-${c.x}-${c.y}-${stratum}`
+    const hashResult = hash512(seed, input)
+    const bytes = hashResult.array
+
+    const rawReserve = ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0
+
+    let reserve = 0
+    if (rawReserve <= YIELD_THRESHOLD) {
+        const baseReserve = (rawReserve % 333) + 1
+        const scale = depthScaleFactor(stratum)
+        reserve = Math.floor(baseReserve * scale)
+    }
+
+    if (reserve === 0) return {itemId: 0, seed: 0n, richness: 0, reserve: 0}
+
+    const eligible = getEligibleResources(locationType, subtype, stratum)
+    if (eligible.length === 0) return {itemId: 0, seed: 0n, richness: 0, reserve: 0}
+
+    const resourceRoll = ((bytes[4] << 24) | (bytes[5] << 16) | (bytes[6] << 8) | bytes[7]) >>> 0
+
+    let totalWeight = 0
+    for (const id of eligible) {
+        totalWeight += getResourceWeight(id, stratum)
+    }
+
+    let selectedItemId = eligible[0]
+    if (totalWeight > 0) {
+        const roll = resourceRoll % totalWeight
+        let cumulative = 0
+        for (const id of eligible) {
+            cumulative += getResourceWeight(id, stratum)
+            if (roll < cumulative) {
+                selectedItemId = id
+                break
+            }
+        }
+    }
+
+    const seedBigInt =
+        (BigInt(bytes[8]) << 56n) |
+        (BigInt(bytes[9]) << 48n) |
+        (BigInt(bytes[10]) << 40n) |
+        (BigInt(bytes[11]) << 32n) |
+        (BigInt(bytes[12]) << 24n) |
+        (BigInt(bytes[13]) << 16n) |
+        (BigInt(bytes[14]) << 8n) |
+        BigInt(bytes[15])
+
+    const rawRichness = (bytes[16] << 8) | bytes[17]
+    const normalized = rawRichness / 65535
+    const baseRichness = Math.floor(normalized * normalized * 999) + 1
+
+    let depthBonus = 0
+    if (stratum > 1) {
+        depthBonus = 50 * Math.log(stratum) / Math.log(65535)
+    }
+    const richness = Math.min(Math.floor(baseRichness + depthBonus), 1000)
+
+    return {itemId: selectedItemId, seed: seedBigInt, richness, reserve}
+}
+
+export function deriveResourceStats(seed: bigint): ResourceStats {
+    const seedStr = seed.toString()
+    const encoder = new TextEncoder()
+    const data = encoder.encode(seedStr)
+    const hashResult = Checksum256.hash(Bytes.from(data))
+    const hashBytes = hashResult.array
+
+    const extractU16 = (offset: number): number => (hashBytes[offset] << 8) | hashBytes[offset + 1]
+
+    const weibullStat = (raw: number): number => {
+        const u = raw / 65536
+        let x = 0.27 * Math.sqrt(-Math.log(1 - u))
+        if (x > 1) x = 1
+        return Math.floor(x * 999) + 1
+    }
+
+    return {
+        purity: weibullStat(extractU16(0)),
+        density: weibullStat(extractU16(2)),
+        reactivity: weibullStat(extractU16(4)),
+        resonance: weibullStat(extractU16(6)),
+    }
+}

package/src/entities/cargo-utils.ts

@@ -18,11 +18,11 @@ export function cargoValue(cargo: EntityInventory[]): UInt64 {
     }, UInt64.from(0))
 }
 
-export function getCargoForGood(
+export function getCargoForItem(
     cargo: EntityInventory[],
     goodId: UInt64Type
 ): EntityInventory | undefined {
-    return cargo.find((c) => c.good_id.equals(goodId))
+    return cargo.find((c) => c.item_id.equals(goodId))
 }
 
 export function hasSpace(
@@ -67,7 +67,7 @@ export function calculateSaleValue(
     for (const item of cargo) {
         if (UInt32.from(item.quantity).equals(UInt32.from(0))) continue
 
-        const goodId = Number(item.good_id)
+        const goodId = Number(item.item_id)
         const salePrice = prices.get(goodId)
 
         if (salePrice) {
@@ -97,7 +97,7 @@ export function calculateSaleValueFromArray(
     return calculateSaleValue(cargo, priceMap)
 }
 
-export function afterSellGoods(
+export function afterSellItems(
     cargo: ServerContract.Types.cargo_item[],
     goodsToSell: Array<{goodId: number; quantity: number}>
 ): EntityInventory[] {
@@ -106,7 +106,7 @@ export function afterSellGoods(
     }
 
     return cargo.map((item) => {
-        const saleItem = goodsToSell.find((s) => Number(item.good_id) === s.goodId)
+        const saleItem = goodsToSell.find((s) => Number(item.item_id) === s.goodId)
         if (!saleItem) {
             return new EntityInventory(item)
         }
@@ -116,7 +116,7 @@ export function afterSellGoods(
 
         return new EntityInventory(
             ServerContract.Types.cargo_item.from({
-                good_id: item.good_id,
+                item_id: item.item_id,
                 quantity: UInt32.from(newQty),
                 unit_cost: item.unit_cost,
             })
@@ -124,7 +124,7 @@ export function afterSellGoods(
     })
 }
 
-export function afterSellAllGoods(cargo: ServerContract.Types.cargo_item[]): EntityInventory[] {
+export function afterSellAllItems(cargo: ServerContract.Types.cargo_item[]): EntityInventory[] {
     if (cargo.length === 0) {
         return []
     }
@@ -133,7 +133,7 @@ export function afterSellAllGoods(cargo: ServerContract.Types.cargo_item[]): Ent
         (item) =>
             new EntityInventory(
                 ServerContract.Types.cargo_item.from({
-                    good_id: item.good_id,
+                    item_id: item.item_id,
                     quantity: UInt32.from(0),
                     unit_cost: item.unit_cost,
                 })

package/src/entities/entity-inventory.ts

@@ -1,24 +1,28 @@
 import {UInt32, UInt64} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
-import {getGood} from '../market/goods'
-import {Good} from '../types'
+import {getItem} from '../market/items'
+import {Item} from '../types'
 
 export class EntityInventory extends ServerContract.Types.cargo_item {
-    private _good?: Good
+    private _item?: Item
 
-    get good(): Good {
-        if (!this._good) {
-            this._good = getGood(this.good_id)
+    get item(): Item {
+        if (!this._item) {
+            this._item = getItem(this.item_id)
         }
-        return this._good
+        return this._item
+    }
+
+    get good(): Item {
+        return this.item
     }
 
     get name(): string {
-        return this.good.name
+        return this.item.name
     }
 
     get unitMass(): UInt32 {
-        return this.good.mass
+        return this.item.mass
     }
 
     get totalMass(): UInt64 {

package/src/entities/inventory-accessor.ts

@@ -24,8 +24,8 @@ export class InventoryAccessor {
         return this.items.reduce((sum, c) => sum.adding(c.totalCost), UInt64.from(0))
     }
 
-    forGood(goodId: UInt64Type): EntityInventory | undefined {
-        return this.items.find((c) => c.good_id.equals(goodId))
+    forItem(goodId: UInt64Type): EntityInventory | undefined {
+        return this.items.find((c) => c.item_id.equals(goodId))
     }
 
     get sellable(): EntityInventory[] {

package/src/entities/location.ts

@@ -1,6 +1,6 @@
 import {Checksum256, Checksum256Type, UInt16, UInt16Type, UInt64} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
-import {Coordinates, CoordinatesType, Distance, GoodPrice, LocationType} from '../types'
+import {Coordinates, CoordinatesType, Distance, ItemPrice, LocationType} from '../types'
 import {getLocationType, hasSystem, isExtractableLocation} from '../utils/system'
 import {findNearbyPlanets} from '../travel/travel'
 
@@ -10,7 +10,7 @@ import {findNearbyPlanets} from '../travel/travel'
  */
 export class Location {
     readonly coordinates: Coordinates
-    private _marketPrices?: GoodPrice[]
+    private _marketPrices?: ItemPrice[]
     private _gameSeed?: Checksum256
     private _hasSystem?: boolean
     private _locationRows?: ServerContract.Types.supply_row[]
@@ -56,21 +56,21 @@ export class Location {
     /**
      * Set cached market prices for this location
      */
-    setMarketPrices(prices: GoodPrice[]): void {
+    setMarketPrices(prices: ItemPrice[]): void {
         this._marketPrices = prices
     }
 
     /**
      * Get cached market prices (returns undefined if not cached)
      */
-    get marketPrices(): GoodPrice[] | undefined {
+    get marketPrices(): ItemPrice[] | undefined {
         return this._marketPrices
     }
 
     /**
      * Get price for a specific good (from cache)
      */
-    getPrice(goodId: UInt16Type): GoodPrice | undefined {
+    getPrice(goodId: UInt16Type): ItemPrice | undefined {
         if (!this._marketPrices) return undefined
         return this._marketPrices.find((p) => p.id.equals(goodId))
     }
@@ -112,7 +112,7 @@ export class Location {
     getSupply(goodId: UInt16Type): UInt16 | undefined {
         if (!this._locationRows) return undefined
         const row = this._locationRows.find(
-            (r) => r.good_id.equals(goodId) && this._epoch && r.epoch.equals(this._epoch)
+            (r) => r.item_id.equals(goodId) && this._epoch && r.epoch.equals(this._epoch)
         )
         return row ? row.supply : undefined
     }
@@ -199,9 +199,9 @@ export class Location {
                                 : UInt16.from(0)
                             : currentSupply.adding(quantityDelta)
 
-                    return GoodPrice.from({
+                    return ItemPrice.from({
                         id: price.id,
-                        good: price.good,
+                        item: price.item,
                         price: price.price,
                         supply: newSupply,
                     })
@@ -213,7 +213,7 @@ export class Location {
         // Copy location rows if cached
         if (this._locationRows && this._epoch) {
             newLocation._locationRows = this._locationRows.map((row) => {
-                if (row.good_id.equals(goodId) && row.epoch.equals(this._epoch!)) {
+                if (row.item_id.equals(goodId) && row.epoch.equals(this._epoch!)) {
                     const currentSupply = UInt16.from(row.supply)
                     const delta = UInt16.from(Math.abs(quantityDelta))
                     const newSupply =
@@ -227,7 +227,7 @@ export class Location {
                         id: row.id,
                         coordinates: row.coordinates,
                         epoch: row.epoch,
-                        good_id: row.good_id,
+                        item_id: row.item_id,
                         supply: newSupply,
                     })
                 }

package/src/entities/ship.ts

@@ -113,6 +113,10 @@ export class Ship extends ServerContract.Types.entity_info {
         return this.extractor !== undefined
     }
 
+    get hasWarp(): boolean {
+        return this.warp !== undefined
+    }
+
     project(): ProjectedEntity {
         return sharedProjectEntity(this)
     }
@@ -155,8 +159,8 @@ export class Ship extends ServerContract.Types.entity_info {
             : this.maxCapacity.subtracting(this.totalMass)
     }
 
-    getCargoForGood(goodId: UInt64Type): EntityInventory | undefined {
-        return this.inv.forGood(goodId)
+    getCargoForItem(goodId: UInt64Type): EntityInventory | undefined {
+        return this.inv.forItem(goodId)
     }
 
     get sellableCargo(): EntityInventory[] {
@@ -198,11 +202,11 @@ export class Ship extends ServerContract.Types.entity_info {
         return cargoUtils.calculateSaleValueFromArray(this.cargo, prices)
     }
 
-    afterSellGoods(goodsToSell: Array<{goodId: number; quantity: number}>): EntityInventory[] {
-        return cargoUtils.afterSellGoods(this.cargo, goodsToSell)
+    afterSellItems(goodsToSell: Array<{goodId: number; quantity: number}>): EntityInventory[] {
+        return cargoUtils.afterSellItems(this.cargo, goodsToSell)
     }
 
-    afterSellAllGoods(): EntityInventory[] {
-        return cargoUtils.afterSellAllGoods(this.cargo)
+    afterSellAllItems(): EntityInventory[] {
+        return cargoUtils.afterSellAllItems(this.cargo)
     }
 }

package/src/entities/warehouse.ts

@@ -79,8 +79,8 @@ export class Warehouse extends ServerContract.Types.entity_info {
         return this.totalCargoMass.gte(this.maxCapacity)
     }
 
-    getCargoForGood(goodId: UInt64Type): EntityInventory | undefined {
-        return this.inv.forGood(goodId)
+    getCargoForItem(goodId: UInt64Type): EntityInventory | undefined {
+        return this.inv.forItem(goodId)
     }
 
     get orbitalAltitude(): number {

package/src/errors.ts

@@ -9,11 +9,11 @@ export const ERROR_SYSTEM_DISABLED = 'This game is currently disabled.'
 export const ERROR_SYSTEM_NOT_INITIALIZED = 'This game has not been initialized.'
 export const GAME_NOT_FOUND = 'Cannot find game for given account name.'
 export const GAME_SEED_NOT_SET = 'This game has not initialized an epoch seed value.'
-export const GOOD_DOES_NOT_EXIST = 'Good does not exist.'
-export const GOOD_NOT_AVAILABLE_AT_LOCATION = 'Good is not tradeable at ship location.'
+export const ITEM_DOES_NOT_EXIST = 'Item does not exist.'
+export const ITEM_NOT_AVAILABLE_AT_LOCATION = 'Item is not tradeable at ship location.'
 export const INSUFFICIENT_BALANCE = 'Insufficient balance.'
-export const INSUFFICIENT_GOOD_QUANTITY = 'Insufficient quantity in cargo.'
-export const INSUFFICIENT_GOOD_SUPPLY = 'Insufficient supply of good at location.'
+export const INSUFFICIENT_ITEM_QUANTITY = 'Insufficient quantity in cargo.'
+export const INSUFFICIENT_ITEM_SUPPLY = 'Insufficient supply of item at location.'
 export const INVALID_AMOUNT = 'Invalid amount.'
 export const REQUIRES_MORE_THAN_ONE = 'A value greater than one is required.'
 export const REQUIRES_POSITIVE_VALUE = 'Value must be greater than zero.'

package/src/index-module.ts

@@ -22,8 +22,7 @@ export type cargo_item = ServerContract.Types.cargo_item
 export type warehouse_row = ServerContract.Types.warehouse_row
 export type container_row = ServerContract.Types.container_row
 export type extractor_stats = ServerContract.Types.extractor_stats
-export type mixture_info = ServerContract.Types.mixture_info
-export type mixture_component = ServerContract.Types.mixture_component
+
 export type location_static = ServerContract.Types.location_static
 export type location_epoch = ServerContract.Types.location_epoch
 export type location_derived = ServerContract.Types.location_derived
@@ -45,7 +44,7 @@ export {
 export type {EntityType} from './managers'
 export type {EntityRefInput} from './managers/actions'
 
-export {getGood, getGoods, goodIds} from './market/goods'
+export {getItem, getItems, itemIds} from './market/items'
 export {getCurrentEpoch, getEpochInfo} from './scheduling/epoch'
 export type {EpochInfo} from './scheduling/epoch'
 export {marketPrice, marketPrices, getRarity, Rarities} from './market/market'
@@ -58,9 +57,35 @@ export {
     deriveLocationStatic,
     deriveLocationEpoch,
     deriveLocation,
-    deriveLocationMixture,
 } from './utils/system'
 
+export {
+    deriveStratum,
+    deriveResourceStats,
+    deriveLocationSize,
+    getEligibleResources,
+    getResourceWeight,
+    getLocationCandidates,
+    getDepthThreshold,
+    getResourceRarity,
+    depthScaleFactor,
+    DEPTH_THRESHOLD_COMMON,
+    DEPTH_THRESHOLD_UNCOMMON,
+    DEPTH_THRESHOLD_RARE,
+    DEPTH_THRESHOLD_EPIC,
+    DEPTH_THRESHOLD_LEGENDARY,
+    LOCATION_MIN_DEPTH,
+    LOCATION_MAX_DEPTH,
+    PLANET_SUBTYPE_GAS_GIANT,
+    PLANET_SUBTYPE_ROCKY,
+    PLANET_SUBTYPE_TERRESTRIAL,
+    PLANET_SUBTYPE_ICY,
+    PLANET_SUBTYPE_OCEAN,
+    PLANET_SUBTYPE_INDUSTRIAL,
+} from './derivation'
+
+export type {StratumInfo, ResourceStats} from './derivation'
+
 export {hash, hash512} from './utils/hash'
 
 export type {Deal, FindDealsOptions} from './trading/deal'
@@ -74,7 +99,7 @@ export type {
     CollectAnalysisCallbacks,
     BetterSaleLocation,
     RepositionLocation,
-    DiscountedGoodInfo,
+    DiscountedItemInfo,
     PotentialDeal,
     CargoSaleItem,
 } from './trading/collect'
@@ -131,7 +156,7 @@ export {
     calculateTradeProfit,
     calculateProfitPerMass,
     calculateProfitPerSecond,
-    findBestGoodToTrade,
+    findBestItemToTrade,
     calculateBreakEvenPrice,
     isProfitable,
     calculateROI,