@shipload/sdk 2.0.0-rc1 → 2.0.0-rc3

package/src/trading/collect.ts

@@ -1,7 +1,7 @@
 import {Checksum256Type, Int64, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
 import {Ship} from '../entities/ship'
 import {Location} from '../entities/location'
-import {Coordinates, GoodPrice, ShipLike} from '../types'
+import {Coordinates, ItemPrice, ShipLike} from '../types'
 import {Deal, findDealsForShip} from './deal'
 
 import {EntityInventory} from '../entities/entity-inventory'
@@ -10,9 +10,8 @@ import {
     distanceBetweenCoordinates,
     EstimatedTravelTime,
     estimateTravelTime,
-    hasEnergyForDistance,
 } from '../travel/travel'
-import {getGood, getGoods} from '../market/goods'
+import {getItem, getItems} from '../market/items'
 import {getRarity, Rarities} from '../market/market'
 import {ServerContract} from '../contracts'
 
@@ -24,7 +23,7 @@ function calculateCargoMass(cargo: EntityInventory[]): UInt32 {
     let mass = UInt32.from(0)
     for (const c of cargo) {
         if (UInt64.from(c.quantity).gt(UInt64.zero)) {
-            const goodMass = getGood(c.good_id).mass
+            const goodMass = getItem(c.item_id).mass
             mass = mass.adding(goodMass.multiplying(c.quantity))
         }
     }
@@ -103,7 +102,7 @@ export interface CollectOption {
     /** Detailed breakdown of travel time components */
     travelTimeBreakdown?: EstimatedTravelTime
     /** Info about a discounted good at the destination (for explore options) */
-    discountedGood?: DiscountedGoodInfo
+    discountedGood?: DiscountedItemInfo
     /** Top potential deals available at destination (for explore options) */
     potentialDeals?: PotentialDeal[]
     /** Details of cargo being sold (if selling cargo) */
@@ -191,7 +190,7 @@ export function analyzeCargoSale(
     for (const c of cargo) {
         if (UInt64.from(c.quantity).equals(UInt64.zero)) continue
 
-        const goodId = Number(c.good_id)
+        const goodId = Number(c.item_id)
         const salePrice = prices.get(goodId)
 
         if (salePrice) {
@@ -220,7 +219,7 @@ export function buildCargoSaleItems(
     for (const c of cargo) {
         if (UInt64.from(c.quantity).equals(UInt64.zero)) continue
 
-        const goodId = Number(c.good_id)
+        const goodId = Number(c.item_id)
         const salePrice = prices.get(goodId)
         const pricePerUnit = salePrice ? UInt32.from(salePrice) : UInt32.zero
         const revenue = UInt64.from(pricePerUnit).multiplying(c.quantity)
@@ -228,8 +227,8 @@ export function buildCargoSaleItems(
         const profit = Int64.from(revenue).subtracting(cost)
 
         items.push({
-            goodId: c.good_id,
-            goodName: c.good?.name ?? `Good #${goodId}`,
+            goodId: c.item_id,
+            goodName: c.item?.name ?? `Item #${goodId}`,
             quantity: UInt32.from(c.quantity),
             pricePerUnit,
             revenue,
@@ -272,10 +271,10 @@ export function createSellAndTradeOption(
         : undefined
 
     return {
-        id: `sell-trade-${deal.destination.coordinates.x}-${deal.destination.coordinates.y}-${deal.good.id}`,
+        id: `sell-trade-${deal.destination.coordinates.x}-${deal.destination.coordinates.y}-${deal.item.id}`,
         type: 'sell-and-trade',
-        title: `Trade ${deal.good.good.name}`,
-        description: `Sell cargo, buy ${deal.maxQuantity} ${deal.good.good.name}, deliver to (${deal.destination.coordinates.x}, ${deal.destination.coordinates.y})`,
+        title: `Trade ${deal.item.item.name}`,
+        description: `Sell cargo, buy ${deal.maxQuantity} ${deal.item.item.name}, deliver to (${deal.destination.coordinates.x}, ${deal.destination.coordinates.y})`,
         reason: `${deal.marginPercent.toFixed(0)}% margin, ${deal.profitPerSecond.toFixed(
             1
         )}/s profit rate`,
@@ -364,7 +363,7 @@ export function createSellAndRepositionOption(
         id: `sell-reposition-${reposition.location.coordinates.x}-${reposition.location.coordinates.y}`,
         type: 'sell-and-reposition',
         title: 'Sell & Move',
-        description: `Sell cargo here, travel empty to buy ${deal.good.good.name}`,
+        description: `Sell cargo here, travel empty to buy ${deal.item.item.name}`,
         reason: `No good trades here — ${deal.marginPercent.toFixed(
             0
         )}% margin trade available at destination`,
@@ -456,7 +455,7 @@ export interface CargoSaleItem {
 /**
  * Info about a discounted good for explore options
  */
-export interface DiscountedGoodInfo {
+export interface DiscountedItemInfo {
     goodId: number
     name: string
     rarity: string
@@ -480,7 +479,7 @@ export interface PotentialDeal {
 export function createExploreOption(
     destination: Location,
     travelTime?: UInt32,
-    discountedGood?: DiscountedGoodInfo,
+    discountedGood?: DiscountedItemInfo,
     travelTimeBreakdown?: EstimatedTravelTime,
     potentialDeals?: PotentialDeal[]
 ): CollectOption {
@@ -537,7 +536,7 @@ export function createExploreOption(
  */
 export interface CollectAnalysisCallbacks {
     getNearbyLocations: (origin: Coordinates, maxDistance: number) => Promise<Location[]>
-    getMarketPrices: (location: Coordinates) => Promise<GoodPrice[]>
+    getMarketPrices: (location: Coordinates) => Promise<ItemPrice[]>
     getGameSeed?: () => Checksum256Type
     getState?: () => ServerContract.Types.state_row
 }
@@ -583,10 +582,10 @@ export async function analyzeCollectOptions(
     )
 
     if (hasCargo && dealsAtOrigin.length > 0) {
-        const cargoGoodIds = new Set(cargo.map((c) => Number(c.good_id)))
+        const cargoGoodIds = new Set(cargo.map((c) => Number(c.item_id)))
 
         for (const deal of dealsAtOrigin.slice(0, 3)) {
-            const dealGoodId = Number(deal.good.id)
+            const dealGoodId = Number(deal.item.id)
             if (cargoGoodIds.has(dealGoodId)) {
                 continue
             }
@@ -768,10 +767,10 @@ export async function analyzeCollectOptions(
     if (!hasCargo && dealsAtOrigin.length > 0) {
         for (const deal of dealsAtOrigin.slice(0, 3)) {
             const option: CollectOption = {
-                id: `trade-${deal.destination.coordinates.x}-${deal.destination.coordinates.y}-${deal.good.id}`,
+                id: `trade-${deal.destination.coordinates.x}-${deal.destination.coordinates.y}-${deal.item.id}`,
                 type: 'sell-and-trade',
-                title: `Trade ${deal.good.good.name}`,
-                description: `Buy ${deal.maxQuantity} ${deal.good.good.name}, deliver to (${deal.destination.coordinates.x}, ${deal.destination.coordinates.y})`,
+                title: `Trade ${deal.item.item.name}`,
+                description: `Buy ${deal.maxQuantity} ${deal.item.item.name}, deliver to (${deal.destination.coordinates.x}, ${deal.destination.coordinates.y})`,
                 reason: `${deal.marginPercent.toFixed(0)}% margin, ${deal.profitPerSecond.toFixed(
                     1
                 )}/s profit rate`,
@@ -805,7 +804,7 @@ export async function analyzeCollectOptions(
             dest: Location
             travelTime: UInt32
             travelTimeBreakdown: EstimatedTravelTime
-            discountedGood?: DiscountedGoodInfo
+            discountedGood?: DiscountedItemInfo
             bestDiscount: number
             potentialDeals?: PotentialDeal[]
             score: number
@@ -822,11 +821,11 @@ export async function analyzeCollectOptions(
                 unloadMass,
             })
 
-            let discountedGood: DiscountedGoodInfo | undefined
+            let discountedGood: DiscountedItemInfo | undefined
             let bestDiscount = 0
 
             if (gameSeed && state) {
-                const allGoods = getGoods()
+                const allGoods = getItems()
                 for (const good of allGoods) {
                     const rarity = getRarity(gameSeed, state.seed, dest.coordinates, good.id)
                     if (rarity.minMultiplier < 1.0) {
@@ -863,8 +862,8 @@ export async function analyzeCollectOptions(
             )
 
             const potentialDeals: PotentialDeal[] = destDeals.map((d) => ({
-                goodId: Number(d.good.id),
-                goodName: d.good.good.name,
+                goodId: Number(d.item.id),
+                goodName: d.item.item.name,
                 destinationCoords: d.destination.coordinates,
                 marginPercent: d.marginPercent,
                 profitPerSecond: d.profitPerSecond,

package/src/trading/deal.ts

@@ -1,12 +1,11 @@
 import {Int64, UInt16, UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
-import {Coordinates, GoodPrice, PRECISION, ShipLike} from '../types'
+import {Coordinates, ItemPrice, PRECISION, ShipLike} from '../types'
 import {Location} from '../entities/location'
 import {Ship} from '../entities/ship'
 import {
     distanceBetweenCoordinates,
     type EstimatedTravelTime,
     estimateTravelTime,
-    hasEnergyForDistance,
 } from '../travel/travel'
 import {calculateProfitPerSecond, calculateTradeProfit, isProfitable} from './trade'
 
@@ -18,8 +17,8 @@ export interface Deal {
     origin: Location
     /** Destination location */
     destination: Location
-    /** Good to trade */
-    good: GoodPrice
+    /** Item to trade */
+    item: ItemPrice
     /** Distance between origin and destination */
     distance: UInt64
     /** Available supply at origin */
@@ -69,7 +68,7 @@ export async function findDealsForShip(
     ship: Ship,
     originLocation: Coordinates,
     getNearbyLocations: (origin: Coordinates, maxDistance: number) => Promise<Location[]>,
-    getMarketPrices: (location: Coordinates) => Promise<GoodPrice[]>,
+    getMarketPrices: (location: Coordinates) => Promise<ItemPrice[]>,
     options: FindDealsOptions = {}
 ): Promise<Deal[]> {
     const {
@@ -124,7 +123,7 @@ export async function findDealsForShip(
                 balance !== undefined
                     ? balance.dividing(originGood.price)
                     : UInt64.from(Number.MAX_SAFE_INTEGER)
-            const canHaul = effectiveAvailableMass.dividing(originGood.good.mass)
+            const canHaul = effectiveAvailableMass.dividing(originGood.item.mass)
             const supplyLimit = UInt64.from(originGood.supply)
 
             // Find minimum of canAfford, canHaul, supplyLimit
@@ -135,7 +134,7 @@ export async function findDealsForShip(
             if (maxQuantity.equals(UInt64.zero)) continue
 
             // Calculate travel time with cargo (includes recharge + load time)
-            const cargoMass = originGood.good.mass.multiplying(maxQuantity)
+            const cargoMass = originGood.item.mass.multiplying(maxQuantity)
             const availableSpaceUInt = UInt64.from(availableSpace)
             const baseMass =
                 availableSpace !== undefined
@@ -162,7 +161,7 @@ export async function findDealsForShip(
             deals.push({
                 origin,
                 destination: destLocation,
-                good: originGood,
+                item: originGood,
                 distance,
                 supply: originGood.supply,
                 buyPrice: originGood.price,
@@ -191,7 +190,7 @@ export async function findBestDeal(
     ship: Ship,
     originLocation: Coordinates,
     getNearbyLocations: (origin: Coordinates, maxDistance: number) => Promise<Location[]>,
-    getMarketPrices: (location: Coordinates) => Promise<GoodPrice[]>,
+    getMarketPrices: (location: Coordinates) => Promise<ItemPrice[]>,
     options: FindDealsOptions = {}
 ): Promise<Deal | undefined> {
     const deals = await findDealsForShip(

package/src/trading/trade.ts

@@ -1,7 +1,7 @@
 import {Int64, Int64Type, UInt32, UInt32Type, UInt64} from '@wharfkit/antelope'
 import {Ship} from '../entities/ship'
 import {Player} from '../entities/player'
-import {GoodPrice} from '../types'
+import {ItemPrice} from '../types'
 
 /**
  * Trade calculation result
@@ -53,10 +53,10 @@ export function calculateUpdatedCargoCost(
 export function calculateMaxTradeQuantity(
     ship: Ship,
     player: Player,
-    goodPrice: GoodPrice
+    goodPrice: ItemPrice
 ): TradeCalculation {
     const pricePerUnit = UInt32.from(goodPrice.price)
-    const massPerUnit = UInt32.from(goodPrice.good.mass)
+    const massPerUnit = UInt32.from(goodPrice.item.mass)
 
     const spaceForQuantity = ship.availableCapacity.dividing(massPerUnit)
     const affordableQuantity = player.balance.dividing(pricePerUnit)
@@ -128,21 +128,21 @@ export function calculateProfitPerSecond(profit: Int64Type, travelTimeSeconds: U
 /**
  * Find the best good to trade between two locations
  */
-export function findBestGoodToTrade(
+export function findBestItemToTrade(
     ship: Ship,
     player: Player,
-    originPrices: GoodPrice[],
-    destPrices: GoodPrice[],
+    originPrices: ItemPrice[],
+    destPrices: ItemPrice[],
     travelTimeSeconds: UInt32Type
 ): {
-    good: GoodPrice
+    item: ItemPrice
     quantity: number
     profit: number
     profitPerSecond: number
     margin: number
 } | null {
     let bestTrade: {
-        good: GoodPrice
+        item: ItemPrice
         quantity: number
         profit: number
         profitPerSecond: number
@@ -169,7 +169,7 @@ export function findBestGoodToTrade(
         if (profitPerSecond > bestProfitPerSecond) {
             bestProfitPerSecond = profitPerSecond
             bestTrade = {
-                good: originPrice,
+                item: originPrice,
                 quantity: calc.maxQuantity,
                 profit: Number(tradeResult.profit),
                 profitPerSecond,

package/src/travel/travel.ts

@@ -29,8 +29,9 @@ import {
     MIN_ORBITAL_ALTITUDE,
     PRECISION,
     ShipLike,
+    TaskType,
 } from '../types'
-import {getGood} from '../market/goods'
+import {getItem} from '../market/items'
 import {hasSystem} from '../utils/system'
 
 export function calc_orbital_altitude(mass: number): number {
@@ -133,7 +134,7 @@ export function calc_flighttime(distance: UInt64Type, acceleration: number): UIn
 }
 
 export function calc_loader_flighttime(ship: ShipLike, mass: UInt64, altitude?: number): UInt32 {
-    const z = altitude ?? ship.location.z?.toNumber() ?? calc_orbital_altitude(Number(mass))
+    const z = altitude ?? ship.coordinates.z?.toNumber() ?? calc_orbital_altitude(Number(mass))
     return calc_flighttime(z, calc_loader_acceleration(ship, mass))
 }
 
@@ -157,14 +158,14 @@ export function calc_acceleration(thrust: number, mass: number): number {
 export function calc_ship_mass(ship: ShipLike, cargos: CargoMassInfo[]): UInt64 {
     const mass = UInt64.from(0)
 
-    mass.add(ship.mass)
+    mass.add(ship.hullmass)
 
     if (ship.loaders.quantity.gt(UInt32.zero)) {
         mass.add(ship.loaders.mass.multiplying(ship.loaders.quantity))
     }
 
     for (const cargo of cargos) {
-        mass.add(getGood(cargo.good_id).mass.multiplying(cargo.quantity))
+        mass.add(getItem(cargo.item_id).mass.multiplying(cargo.quantity))
     }
 
     return mass
@@ -182,9 +183,9 @@ export function calculateTransferTime(
     let mass = UInt64.from(0)
 
     for (const cargo of cargos) {
-        const qty = quantities?.get(Number(cargo.good_id)) ?? 0
+        const qty = quantities?.get(Number(cargo.item_id)) ?? 0
         if (qty > 0) {
-            const good_mass = getGood(cargo.good_id).mass
+            const good_mass = getItem(cargo.item_id).mass
             const cargo_mass = good_mass.multiplying(qty)
             mass = UInt64.from(mass).adding(cargo_mass)
         }
@@ -230,12 +231,12 @@ export function calculateLoadTimeBreakdown(
     let mass_load = UInt64.from(0)
 
     for (const cargo of cargos) {
-        const goodId = Number(cargo.good_id)
+        const goodId = Number(cargo.item_id)
         const loadQty = loadQuantities?.get(goodId) ?? 0
         const unloadQty = unloadQuantities?.get(goodId) ?? 0
 
         if (loadQty > 0 || unloadQty > 0) {
-            const good = getGood(cargo.good_id)
+            const good = getItem(cargo.item_id)
 
             if (loadQty > 0) {
                 const cargo_mass = good.mass.multiplying(loadQty)
@@ -358,6 +359,66 @@ export interface TransferEntity {
     }
 }
 
+export interface HasScheduleAndLocation {
+    coordinates: ServerContract.ActionParams.Type.coordinates
+    schedule?: ServerContract.Types.schedule
+}
+
+export function getFlightOrigin(
+    entity: HasScheduleAndLocation,
+    flightTaskIndex: number
+): ServerContract.ActionParams.Type.coordinates {
+    if (!entity.schedule) return entity.coordinates
+
+    let origin = entity.coordinates
+    for (let i = 0; i < flightTaskIndex && i < entity.schedule.tasks.length; i++) {
+        const task = entity.schedule.tasks[i]
+        if (task.type.equals(TaskType.TRAVEL) && task.coordinates) {
+            origin = task.coordinates
+        }
+    }
+    return origin
+}
+
+export function getDestinationLocation(
+    entity: HasScheduleAndLocation
+): ServerContract.ActionParams.Type.coordinates | undefined {
+    if (!entity.schedule) return undefined
+
+    for (let i = entity.schedule.tasks.length - 1; i >= 0; i--) {
+        const task = entity.schedule.tasks[i]
+        if (task.type.equals(TaskType.TRAVEL) && task.coordinates) {
+            return task.coordinates
+        }
+    }
+    return undefined
+}
+
+export function getPositionAt(
+    entity: HasScheduleAndLocation,
+    taskIndex: number,
+    taskProgress: number
+): ServerContract.ActionParams.Type.coordinates {
+    if (!entity.schedule || entity.schedule.tasks.length === 0 || taskIndex < 0) {
+        return entity.coordinates
+    }
+
+    const task = entity.schedule.tasks[taskIndex]
+
+    if (!task.type.equals(TaskType.TRAVEL) || !task.coordinates) {
+        return getFlightOrigin(entity, taskIndex)
+    }
+
+    const origin = getFlightOrigin(entity, taskIndex)
+    const destination = task.coordinates
+
+    const interpolated = lerp(origin, destination, taskProgress)
+    return {
+        x: Math.round(interpolated.x),
+        y: Math.round(interpolated.y),
+    }
+}
+
 export function calc_transfer_duration(
     source: TransferEntity,
     dest: TransferEntity,

package/src/types/capabilities.ts

@@ -0,0 +1,79 @@
+import {Name, UInt16, UInt32} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+
+export interface MovementCapability {
+    engines: ServerContract.Types.movement_stats
+    generator: ServerContract.Types.energy_stats
+}
+
+export interface EnergyCapability {
+    energy: UInt16
+}
+
+export interface StorageCapability {
+    capacity: UInt32
+    cargomass: UInt32
+    cargo: ServerContract.Types.cargo_item[]
+}
+
+export interface LoaderCapability {
+    loaders: ServerContract.Types.loader_stats
+}
+
+export interface TradeCapability {
+    trade: ServerContract.Types.trade_stats
+}
+
+export interface ExtractorCapability {
+    extractor: ServerContract.Types.extractor_stats
+}
+
+export interface MassCapability {
+    hullmass: UInt32
+}
+
+export interface ScheduleCapability {
+    schedule?: ServerContract.Types.schedule
+}
+
+export interface EntityCapabilities {
+    hullmass?: UInt32
+    capacity?: UInt32
+    engines?: ServerContract.Types.movement_stats
+    generator?: ServerContract.Types.energy_stats
+    loaders?: ServerContract.Types.loader_stats
+    trade?: ServerContract.Types.trade_stats
+    extractor?: ServerContract.Types.extractor_stats
+}
+
+export interface EntityState {
+    owner: Name
+    location: ServerContract.Types.coordinates
+    energy?: UInt16
+    cargomass: UInt32
+    cargo: ServerContract.Types.cargo_item[]
+}
+
+export function capsHasMovement(caps: EntityCapabilities): boolean {
+    return caps.engines !== undefined && caps.generator !== undefined
+}
+
+export function capsHasStorage(caps: EntityCapabilities): boolean {
+    return caps.capacity !== undefined
+}
+
+export function capsHasLoaders(caps: EntityCapabilities): boolean {
+    return caps.loaders !== undefined
+}
+
+export function capsHasTrade(caps: EntityCapabilities): boolean {
+    return caps.trade !== undefined
+}
+
+export function capsHasExtractor(caps: EntityCapabilities): boolean {
+    return caps.extractor !== undefined
+}
+
+export function capsHasMass(caps: EntityCapabilities): boolean {
+    return caps.hullmass !== undefined
+}

package/src/types/entity-traits.ts

@@ -0,0 +1,70 @@
+import {Name} from '@wharfkit/antelope'
+
+export const ENTITY_SHIP = Name.from('ship')
+export const ENTITY_WAREHOUSE = Name.from('warehouse')
+export const ENTITY_CONTAINER = Name.from('container')
+
+export type EntityTypeName = 'ship' | 'warehouse' | 'container'
+
+export interface EntityTraits {
+    typeName: Name
+    isMovable: boolean
+    hasEnergy: boolean
+    hasLoaders: boolean
+    hasTrade: boolean
+    notFoundError: string
+}
+
+export const shipTraits: EntityTraits = {
+    typeName: ENTITY_SHIP,
+    isMovable: true,
+    hasEnergy: true,
+    hasLoaders: true,
+    hasTrade: true,
+    notFoundError: 'ship not found',
+}
+
+export const warehouseTraits: EntityTraits = {
+    typeName: ENTITY_WAREHOUSE,
+    isMovable: false,
+    hasEnergy: false,
+    hasLoaders: true,
+    hasTrade: false,
+    notFoundError: 'warehouse not found',
+}
+
+export const containerTraits: EntityTraits = {
+    typeName: ENTITY_CONTAINER,
+    isMovable: true,
+    hasEnergy: false,
+    hasLoaders: false,
+    hasTrade: false,
+    notFoundError: 'container not found',
+}
+
+export function getEntityTraits(entityType: Name | EntityTypeName): EntityTraits {
+    const typeName = typeof entityType === 'string' ? entityType : entityType.toString()
+
+    switch (typeName) {
+        case 'ship':
+            return shipTraits
+        case 'warehouse':
+            return warehouseTraits
+        case 'container':
+            return containerTraits
+        default:
+            throw new Error(`Unknown entity type: ${typeName}`)
+    }
+}
+
+export function isShip(entity: {type?: Name}): boolean {
+    return entity.type?.equals(ENTITY_SHIP) ?? false
+}
+
+export function isWarehouse(entity: {type?: Name}): boolean {
+    return entity.type?.equals(ENTITY_WAREHOUSE) ?? false
+}
+
+export function isContainer(entity: {type?: Name}): boolean {
+    return entity.type?.equals(ENTITY_CONTAINER) ?? false
+}

package/src/types/entity.ts

@@ -0,0 +1,36 @@
+import {Name, UInt64} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import {Coordinates} from '../types'
+import {
+    EnergyCapability,
+    LoaderCapability,
+    MassCapability,
+    MovementCapability,
+    ScheduleCapability,
+    StorageCapability,
+} from './capabilities'
+
+export interface Entity {
+    id: UInt64
+    type: Name
+    owner: Name
+    entity_name: string
+    location: Coordinates | ServerContract.Types.coordinates
+}
+
+export type ShipEntity = Entity &
+    MovementCapability &
+    EnergyCapability &
+    StorageCapability &
+    LoaderCapability &
+    MassCapability &
+    ScheduleCapability & {
+        trade?: ServerContract.Types.trade_stats
+        extractor?: ServerContract.Types.extractor_stats
+    }
+
+export type WarehouseEntity = Entity & StorageCapability & LoaderCapability & ScheduleCapability
+
+export type ContainerEntity = Entity & StorageCapability & MassCapability & ScheduleCapability
+
+export type AnyEntity = ShipEntity | WarehouseEntity | ContainerEntity

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from './capabilities'
+export * from './entity'
+export * from './entity-traits'