@shipload/sdk 1.0.0-next.39 → 1.0.0-next.40

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@shipload/sdk",
     "description": "SDKs for Shipload",
-    "version": "1.0.0-next.39",
+    "version": "1.0.0-next.40",
     "homepage": "https://github.com/shipload/toolkit/tree/master/packages/sdk",
     "repository": {
         "type": "git",

package/src/derivation/index.ts

@@ -28,7 +28,15 @@ export {
     PLANET_SUBTYPE_INDUSTRIAL,
 } from './resources'
 
-export {RESERVE_TIERS, TIER_ROLL_MAX, tierOfReserve, rollTier, rollWithinTier} from './tiers'
+export {
+    RESERVE_TIERS,
+    TIER_ROLL_MAX,
+    tierOfReserve,
+    rollTier,
+    rollWithinTier,
+    RESOURCE_TIER_MULT_TENTHS,
+    applyResourceTierMultiplier,
+} from './tiers'
 export type {ReserveTier, TierRange} from './tiers'
 
 export {getEffectiveReserve} from './reserve-regen'

package/src/derivation/recipe-usage.test.ts

@@ -0,0 +1,78 @@
+import {expect, test} from 'bun:test'
+import {
+    getAllRecipes,
+    getRecipeConsumers,
+    getComponentDemand,
+    getResourceDemand,
+} from './recipe-usage'
+import {
+    ITEM_SENSOR,
+    ITEM_RESIN,
+    ITEM_PLATE,
+    ITEM_BEAM,
+    ITEM_GATHERER_T1,
+    ITEM_CRAFTER_T1,
+    ITEM_EXTRACTOR_T1_PACKED,
+    ITEM_SHIP_T1_PACKED,
+} from '../data/item-ids'
+
+test('getAllRecipes returns the full catalog including the gatherer', () => {
+    const all = getAllRecipes()
+    expect(all.length).toBeGreaterThan(20)
+    expect(all.some((r) => r.outputItemId === ITEM_GATHERER_T1)).toBe(true)
+})
+
+test('getRecipeConsumers lists every recipe that consumes Sensor', () => {
+    const consumers = getRecipeConsumers(ITEM_SENSOR)
+    const ids = consumers.map((c) => c.outputItemId).sort((a, b) => a - b)
+    expect(ids).toEqual(
+        [ITEM_GATHERER_T1, ITEM_CRAFTER_T1, ITEM_SHIP_T1_PACKED, ITEM_EXTRACTOR_T1_PACKED].sort(
+            (a, b) => a - b
+        )
+    )
+})
+
+test('Sensor feeds the gatherer drain stat', () => {
+    const consumers = getRecipeConsumers(ITEM_SENSOR)
+    const gatherer = consumers.find((c) => c.outputItemId === ITEM_GATHERER_T1)
+    expect(gatherer).toBeDefined()
+    const drain = gatherer?.statFlows.find(
+        (f) => f.capability === 'Gathering' && f.attribute === 'drain'
+    )
+    expect(drain).toBeDefined()
+})
+
+test('Sensor is a mass-only sink in the Extractor recipe', () => {
+    const consumers = getRecipeConsumers(ITEM_SENSOR)
+    const extractor = consumers.find((c) => c.outputItemId === ITEM_EXTRACTOR_T1_PACKED)
+    expect(extractor).toBeDefined()
+    expect(extractor?.statFlows).toHaveLength(0)
+})
+
+test('getResourceDemand returns the resource tonnage for a single-resource component', () => {
+    expect(getResourceDemand(ITEM_PLATE)).toEqual({ore: 10})
+})
+
+test('getResourceDemand traces a dual-resource component to both resources', () => {
+    expect(getResourceDemand(ITEM_BEAM)).toEqual({ore: 5, gas: 5})
+})
+
+test('getResourceDemand recurses through a module to raw resources', () => {
+    // Gatherer = 300 Beam (5 ore + 5 gas each) + 300 Sensor (10 crystal each)
+    expect(getResourceDemand(ITEM_GATHERER_T1)).toEqual({
+        ore: 1500,
+        gas: 1500,
+        crystal: 3000,
+    })
+})
+
+test('getResourceDemand scales by quantity', () => {
+    expect(getResourceDemand(ITEM_PLATE, 3)).toEqual({ore: 30})
+})
+
+test('getComponentDemand reports Resin as consumed by exactly one recipe', () => {
+    const demand = getComponentDemand()
+    const resin = demand.find((d) => d.itemId === ITEM_RESIN)
+    expect(resin).toBeDefined()
+    expect(resin?.consumerCount).toBe(1)
+})

package/src/derivation/recipe-usage.ts

@@ -0,0 +1,141 @@
+import recipes from '../data/recipes.json'
+import {getRecipe, type Recipe} from '../data/recipes-runtime'
+import {getItem} from '../data/catalog'
+import {getStatDefinitions} from './stats'
+import {SLOT_FORMULAS, type SlotConsumerKind} from '../data/capability-formulas'
+import {KIND_TO_ITEM_ID} from './capability-mappings'
+import type {ResourceCategory} from '../types'
+
+export function getAllRecipes(): Recipe[] {
+    return recipes as unknown as Recipe[]
+}
+
+export type ResourceDemand = Partial<Record<ResourceCategory, number>>
+
+function accumulateResourceDemand(itemId: number, quantity: number, out: ResourceDemand): void {
+    const item = getItem(itemId)
+    if (item.type === 'resource' && item.category) {
+        out[item.category] = (out[item.category] ?? 0) + quantity
+        return
+    }
+    const recipe = getRecipe(itemId)
+    if (!recipe) return
+    for (const input of recipe.inputs) {
+        accumulateResourceDemand(input.itemId, input.quantity * quantity, out)
+    }
+}
+
+// Raw-resource tonnage to craft `quantity` of an item, tracing recipes to the resource leaves.
+export function getResourceDemand(itemId: number, quantity = 1): ResourceDemand {
+    const out: ResourceDemand = {}
+    accumulateResourceDemand(itemId, quantity, out)
+    return out
+}
+
+const ITEM_ID_TO_KIND = new Map<number, SlotConsumerKind>()
+for (const [kind, itemId] of Object.entries(KIND_TO_ITEM_ID) as [SlotConsumerKind, number][]) {
+    ITEM_ID_TO_KIND.set(itemId, kind)
+}
+
+// Traces a stat index down to the raw category stat label it carries (Sensor stat 0 → "Conductivity").
+function resolveComponentStatLabel(itemId: number, statIndex: number): string | undefined {
+    let item: ReturnType<typeof getItem>
+    try {
+        item = getItem(itemId)
+    } catch {
+        return undefined
+    }
+    if (item.type === 'resource' && item.category) {
+        return getStatDefinitions(item.category)[statIndex]?.label
+    }
+    const recipe = getRecipe(itemId)
+    const slot = recipe?.statSlots[statIndex]
+    const source = slot?.sources[0]
+    if (!recipe || !source) return undefined
+    const input = recipe.inputs[source.inputIndex]
+    if (!input) return undefined
+    return resolveComponentStatLabel(input.itemId, source.statIndex)
+}
+
+export interface StatFlow {
+    slotIndex: number
+    capability?: string
+    attribute?: string
+    sourceStatIndex: number
+    sourceStatLabel?: string
+}
+
+export interface RecipeConsumer {
+    outputItemId: number
+    quantity: number
+    statFlows: StatFlow[]
+}
+
+/** Every recipe that consumes `componentItemId`, with how its stats flow through. */
+export function getRecipeConsumers(componentItemId: number): RecipeConsumer[] {
+    const out: RecipeConsumer[] = []
+    for (const recipe of getAllRecipes()) {
+        for (let inputIndex = 0; inputIndex < recipe.inputs.length; inputIndex++) {
+            if (recipe.inputs[inputIndex].itemId !== componentItemId) continue
+            const kind = ITEM_ID_TO_KIND.get(recipe.outputItemId)
+            const formulas = kind ? SLOT_FORMULAS[kind] : undefined
+            const statFlows: StatFlow[] = []
+            for (let slotIndex = 0; slotIndex < recipe.statSlots.length; slotIndex++) {
+                for (const source of recipe.statSlots[slotIndex].sources) {
+                    if (source.inputIndex !== inputIndex) continue
+                    const consumer = formulas?.[slotIndex]
+                    statFlows.push({
+                        slotIndex,
+                        capability: consumer?.capability,
+                        attribute: consumer?.attribute,
+                        sourceStatIndex: source.statIndex,
+                        sourceStatLabel: resolveComponentStatLabel(
+                            componentItemId,
+                            source.statIndex
+                        ),
+                    })
+                }
+            }
+            out.push({
+                outputItemId: recipe.outputItemId,
+                quantity: recipe.inputs[inputIndex].quantity,
+                statFlows,
+            })
+        }
+    }
+    return out
+}
+
+export interface DemandRow {
+    itemId: number
+    consumerCount: number
+    statSourceCount: number
+    sinkOnlyCount: number
+    consumers: number[]
+}
+
+/** Demand tally for every item consumed as a recipe input, ascending by usage. */
+export function getComponentDemand(): DemandRow[] {
+    const inputIds = new Set<number>()
+    for (const recipe of getAllRecipes()) {
+        for (const input of recipe.inputs) inputIds.add(input.itemId)
+    }
+    const rows: DemandRow[] = []
+    for (const itemId of inputIds) {
+        const consumers = getRecipeConsumers(itemId)
+        let statSourceCount = 0
+        let sinkOnlyCount = 0
+        for (const c of consumers) {
+            if (c.statFlows.length > 0) statSourceCount++
+            else sinkOnlyCount++
+        }
+        rows.push({
+            itemId,
+            consumerCount: consumers.length,
+            statSourceCount,
+            sinkOnlyCount,
+            consumers: consumers.map((c) => c.outputItemId),
+        })
+    }
+    return rows.sort((a, b) => a.consumerCount - b.consumerCount || a.itemId - b.itemId)
+}

package/src/derivation/resources.ts

@@ -15,8 +15,8 @@ export const DEPTH_THRESHOLD_T10 = 63000
 export const LOCATION_MIN_DEPTH = 500
 export const LOCATION_MAX_DEPTH = 65535
 
-export const YIELD_FRACTION_SHALLOW = 0.0025
-export const YIELD_FRACTION_DEEP = 0.0005
+export const YIELD_FRACTION_SHALLOW = 0.005
+export const YIELD_FRACTION_DEEP = 0.001
 
 export function yieldThresholdAt(stratum: number): number {
     const clamped = stratum > 65535 ? 65535 : stratum

package/src/derivation/stratum.ts

@@ -3,7 +3,7 @@ import {hash512} from '../utils/hash'
 import {Coordinates, type CoordinatesType} from '../types'
 import {getItem} from '../data/catalog'
 import {getEligibleResources, getResourceWeight, yieldThresholdAt} from './resources'
-import {RESERVE_TIERS, rollTier, rollWithinTier} from './tiers'
+import {RESERVE_TIERS, rollTier, rollWithinTier, applyResourceTierMultiplier} from './tiers'
 
 export interface StratumInfo {
     itemId: number
@@ -63,8 +63,9 @@ export function deriveStratum(
     const tierRoll = ((bytes[18] << 8) | bytes[19]) >>> 0
     const withinRoll = ((bytes[20] << 8) | bytes[21]) >>> 0
     const tier = rollTier(tierRoll, stratum)
-    const unitMass = getItem(selectedItemId).mass
-    const reserve = rollWithinTier(withinRoll, RESERVE_TIERS[tier], unitMass)
+    const selected = getItem(selectedItemId)
+    const baseReserve = rollWithinTier(withinRoll, RESERVE_TIERS[tier], selected.mass)
+    const reserve = applyResourceTierMultiplier(baseReserve, selected.tier)
 
     const seedBigInt =
         (BigInt(bytes[8]) << 56n) |

package/src/derivation/tiers.ts

@@ -60,14 +60,26 @@ export function rollWithinTier(
     return Math.max(1, Math.floor(depositMass / resourceUnitMass))
 }
 
+// Must mirror the contract tier-multiplier table in tiers.hpp byte-for-byte; values are in tenths (T1..T10).
+export const RESOURCE_TIER_MULT_TENTHS = [200, 154, 118, 91, 70, 54, 41, 32, 24, 19] as const
+
+export function applyResourceTierMultiplier(units: number, resourceTier: number): number {
+    const idx = resourceTier < 1 ? 0 : resourceTier > 10 ? 9 : resourceTier - 1
+    const scaled = Math.floor((units * RESOURCE_TIER_MULT_TENTHS[idx]) / 10)
+    return scaled > 0 ? scaled : 1
+}
+
 const RESERVE_TIER_ENTRIES = Object.entries(RESERVE_TIERS) as Array<[ReserveTier, TierRange]>
 
 export function tierOfReserve(reserve: number, itemId: number): ReserveTier | null {
     if (reserve <= 0) return null
-    const unitMass = getItem(itemId).mass
-    if (unitMass <= 0) return null
-    const impliedMassLow = reserve * unitMass
-    const impliedMassHigh = impliedMassLow + unitMass
+    const item = getItem(itemId)
+    if (item.mass <= 0) return null
+    // Reverse the resource-tier multiplier so bands read relative to the resource tier.
+    const idx = item.tier < 1 ? 0 : item.tier > 10 ? 9 : item.tier - 1
+    const baseReserve = (reserve * 10) / RESOURCE_TIER_MULT_TENTHS[idx]
+    const impliedMassLow = baseReserve * item.mass
+    const impliedMassHigh = impliedMassLow + item.mass
     for (const [tier, range] of RESERVE_TIER_ENTRIES) {
         if (impliedMassHigh > range.min && impliedMassLow <= range.max) return tier
     }

package/src/derivation/wormhole.ts

@@ -103,6 +103,27 @@ export function wormholeAt(
     if (!w || w.A.x !== x || w.A.y !== y) return null
     return w.B
 }
+
+// Wormhole mouths (the local A endpoint) within reachTiles of (x,y); regions are RSIZE-wide so only a few overlap.
+export function nearbyWormholes(
+    seed: Checksum256Type,
+    x: number,
+    y: number,
+    reachTiles: number
+): {x: number; y: number}[] {
+    const min = regionOf(x - reachTiles, y - reachTiles)
+    const max = regionOf(x + reachTiles, y + reachTiles)
+    const out: {x: number; y: number}[] = []
+    for (let rx = min.rx; rx <= max.rx; rx++) {
+        for (let ry = min.ry; ry <= max.ry; ry++) {
+            const w = wormholeOfRegion(seed, {rx, ry})
+            if (!w) continue
+            if (w.A.x === x && w.A.y === y) continue
+            if (dist({x, y}, w.A) <= reachTiles) out.push(w.A)
+        }
+    }
+    return out
+}
 export function isValidWormholePair(
     seed: Checksum256Type,
     ax: number,

package/src/index-module.ts

@@ -132,7 +132,15 @@ export {
 
 export type {StratumInfo, ResourceStats, DerivedStratum} from './derivation'
 
-export {RESERVE_TIERS, TIER_ROLL_MAX, tierOfReserve, rollTier, rollWithinTier} from './derivation'
+export {
+    RESERVE_TIERS,
+    TIER_ROLL_MAX,
+    tierOfReserve,
+    rollTier,
+    rollWithinTier,
+    RESOURCE_TIER_MULT_TENTHS,
+    applyResourceTierMultiplier,
+} from './derivation'
 export type {ReserveTier, TierRange} from './derivation'
 
 export {getEffectiveReserve} from './derivation'
@@ -348,6 +356,13 @@ export {
 } from './derivation/capability-mappings'
 export {SLOT_FORMULAS} from './data/capability-formulas'
 export type {SlotConsumer, SlotConsumerKind} from './data/capability-formulas'
+export {
+    getAllRecipes,
+    getRecipeConsumers,
+    getComponentDemand,
+    getResourceDemand,
+} from './derivation/recipe-usage'
+export type {StatFlow, RecipeConsumer, DemandRow, ResourceDemand} from './derivation/recipe-usage'
 
 export {
     encodeStats,

package/src/travel/route-planner.ts

@@ -1,5 +1,6 @@
 import {distanceBetweenPoints, findNearbyPlanets} from './travel'
 import {hasSystem} from '../utils/system'
+import {nearbyWormholes, wormholeAt} from '../derivation/wormhole'
 import {PRECISION} from '../types'
 import {Checksum256, type Checksum256Type} from '@wharfkit/antelope'
 
@@ -170,14 +171,26 @@ function reconstruct(cameFrom: Map<string, Coord>, origin: Coord, dest: Coord):
 
 export function sdkSystemGraph(seed: Checksum256Type): SystemGraph {
     const s = Checksum256.from(seed)
+    // Travelable nodes mirror the contract's is_travelable: systems plus wormhole mouths.
     return {
-        hasSystem: (c) => hasSystem(s, {x: c.x, y: c.y}),
-        nearby: (c, reachTiles) =>
-            findNearbyPlanets(s, {x: c.x, y: c.y}, reachTiles * PRECISION)
-                .map((d) => ({
-                    coord: {x: Number(d.destination.x), y: Number(d.destination.y)},
-                    dist: Number(d.distance) / PRECISION,
-                }))
-                .filter((n) => !(n.coord.x === c.x && n.coord.y === c.y)),
+        hasSystem: (c) => hasSystem(s, {x: c.x, y: c.y}) || wormholeAt(s, c.x, c.y) !== null,
+        nearby: (c, reachTiles) => {
+            const seen = new Set<string>([`${c.x},${c.y}`])
+            const out: Neighbor[] = []
+            for (const d of findNearbyPlanets(s, {x: c.x, y: c.y}, reachTiles * PRECISION)) {
+                const coord = {x: Number(d.destination.x), y: Number(d.destination.y)}
+                const k = `${coord.x},${coord.y}`
+                if (seen.has(k)) continue
+                seen.add(k)
+                out.push({coord, dist: Number(d.distance) / PRECISION})
+            }
+            for (const coord of nearbyWormholes(s, c.x, c.y, reachTiles)) {
+                const k = `${coord.x},${coord.y}`
+                if (seen.has(k)) continue
+                seen.add(k)
+                out.push({coord, dist: Math.hypot(coord.x - c.x, coord.y - c.y)})
+            }
+            return out
+        },
     }
 }