@shipload/sdk 1.0.0-next.6 → 1.0.0-next.61

package/src/derivation/capability-mappings.ts

@@ -1,26 +1,26 @@
 import {SLOT_FORMULAS, type SlotConsumerKind} from '../data/capability-formulas'
 import {getStatDefinitions, type StatDefinition} from './stats'
-import {
-    getRecipe,
-    type Recipe,
-    type RecipeInput,
-    type RecipeInputCategory,
-} from '../data/recipes-runtime'
+import {getRecipe, type Recipe} from '../data/recipes-runtime'
+import {getItem} from '../data/catalog'
 import {
     ITEM_ENGINE_T1,
+    ITEM_EXTRACTOR_T1_PACKED,
     ITEM_GENERATOR_T1,
     ITEM_GATHERER_T1,
     ITEM_LOADER_T1,
     ITEM_CRAFTER_T1,
+    ITEM_BUILDER_T1,
     ITEM_STORAGE_T1,
     ITEM_HAULER_T1,
     ITEM_WARP_T1,
+    ITEM_BATTERY_T1,
     ITEM_SHIP_T1_PACKED,
     ITEM_CONTAINER_T1_PACKED,
     ITEM_WAREHOUSE_T1_PACKED,
     ITEM_CONTAINER_T2_PACKED,
 } from '../data/item-ids'
-import type {StatMapping} from '../data/capabilities'
+import type {StatMapping, CapabilityAttributeRow} from '../data/capabilities'
+import {capabilityAttributes} from '../data/capabilities'
 
 export const KIND_TO_ITEM_ID: Record<SlotConsumerKind, number> = {
     engine: ITEM_ENGINE_T1,
@@ -28,19 +28,18 @@ export const KIND_TO_ITEM_ID: Record<SlotConsumerKind, number> = {
     gatherer: ITEM_GATHERER_T1,
     loader: ITEM_LOADER_T1,
     crafter: ITEM_CRAFTER_T1,
+    builder: ITEM_BUILDER_T1,
     storage: ITEM_STORAGE_T1,
     hauler: ITEM_HAULER_T1,
     warp: ITEM_WARP_T1,
+    battery: ITEM_BATTERY_T1,
     'ship-t1': ITEM_SHIP_T1_PACKED,
     'container-t1': ITEM_CONTAINER_T1_PACKED,
     'warehouse-t1': ITEM_WAREHOUSE_T1_PACKED,
+    'extractor-t1': ITEM_EXTRACTOR_T1_PACKED,
     'container-t2': ITEM_CONTAINER_T2_PACKED,
 }
 
-function isCategoryInput(input: RecipeInput): input is RecipeInputCategory {
-    return 'category' in input
-}
-
 /**
  * Walk a recipe's slot source down to the raw category stat that ultimately
  * lands in that slot. Returns the StatDefinition or undefined if the trace
@@ -56,8 +55,9 @@ function traceToRawCategoryStat(
 ): StatDefinition | undefined {
     const input = recipe.inputs[source.inputIndex]
     if (!input) return undefined
-    if (isCategoryInput(input)) {
-        const defs = getStatDefinitions(input.category)
+    const inputItem = getItem(input.itemId)
+    if (inputItem.type === 'resource' && inputItem.category) {
+        const defs = getStatDefinitions(inputItem.category)
         return defs[source.statIndex]
     }
     if (visited.has(input.itemId)) return undefined
@@ -72,6 +72,12 @@ function traceToRawCategoryStat(
     return traceToRawCategoryStat(subRecipe, subSource, nextVisited)
 }
 
+// Producing role for a capability·attribute: entity hull slots all roll up to "Hull"; modules use their own name.
+export function sourceLabelForOutput(itemId: number): string {
+    const item = getItem(itemId)
+    return item.type === 'entity' ? 'Hull' : item.name
+}
+
 let cached: StatMapping[] | undefined
 
 export function deriveStatMappings(): StatMapping[] {
@@ -85,20 +91,22 @@ export function deriveStatMappings(): StatMapping[] {
         const itemId = KIND_TO_ITEM_ID[kind]
         const recipe = getRecipe(itemId)
         if (!recipe) continue
+        const source = sourceLabelForOutput(itemId)
         for (const [slotIdxStr, consumer] of Object.entries(slots)) {
             const slotIdx = Number(slotIdxStr)
             const slot = recipe.statSlots[slotIdx]
             if (!slot) continue
-            for (const source of slot.sources) {
-                const stat = traceToRawCategoryStat(recipe, source)
+            for (const src of slot.sources) {
+                const stat = traceToRawCategoryStat(recipe, src)
                 if (!stat) continue
-                const key = `${stat.label}|${consumer.capability}|${consumer.attribute}`
+                const key = `${stat.label}|${consumer.capability}|${consumer.attribute}|${source}`
                 if (seen.has(key)) continue
                 seen.add(key)
                 out.push({
                     stat: stat.label,
                     capability: consumer.capability,
                     attribute: consumer.attribute,
+                    source,
                 })
             }
         }
@@ -118,3 +126,39 @@ export function getStatMappingsForStat(stat: string): StatMapping[] {
 export function getStatMappingsForCapability(capability: string): StatMapping[] {
     return deriveStatMappings().filter((m) => m.capability === capability)
 }
+
+export function getProducersForAttribute(capability: string, attribute: string): string[] {
+    const seen = new Set<string>()
+    const out: string[] = []
+    for (const m of deriveStatMappings()) {
+        if (m.capability !== capability || m.attribute !== attribute) continue
+        if (seen.has(m.source)) continue
+        seen.add(m.source)
+        out.push(m.source)
+    }
+    return out
+}
+
+export function getCapabilityAttributeRows(): CapabilityAttributeRow[] {
+    const rows: CapabilityAttributeRow[] = []
+    for (const ca of capabilityAttributes) {
+        const producers = getProducersForAttribute(ca.capability, ca.attribute)
+        if (producers.length === 0) {
+            rows.push({
+                capability: ca.capability,
+                attribute: ca.attribute,
+                description: ca.description,
+            })
+            continue
+        }
+        for (const source of producers) {
+            rows.push({
+                capability: ca.capability,
+                attribute: ca.attribute,
+                description: ca.description,
+                source,
+            })
+        }
+    }
+    return rows
+}

package/src/derivation/crafting.test.ts

@@ -0,0 +1,17 @@
+import {describe, expect, test} from 'bun:test'
+import {usedInputStatKeys} from './crafting'
+import {ITEM_BUILDER_T1} from '../data/item-ids'
+
+describe('usedInputStatKeys', () => {
+    test('maps each input to the stat keys the blend actually consumes', () => {
+        // Ceramic.hardness feeds the output's resonance slot; a name match would miss it.
+        expect(usedInputStatKeys(ITEM_BUILDER_T1)).toEqual([
+            ['resonance'],
+            ['hardness', 'fineness'],
+        ])
+    })
+
+    test('returns an empty array for an unknown recipe', () => {
+        expect(usedInputStatKeys(999999)).toEqual([])
+    })
+})

package/src/derivation/crafting.ts

@@ -1,9 +1,10 @@
 import {UInt64} from '@wharfkit/antelope'
 import type {ResourceCategory} from '../types'
-import {findItemByCategoryAndTier, getRecipe, type Recipe} from '../data/recipes-runtime'
+import {getRecipe, type Recipe} from '../data/recipes-runtime'
 import {getItem} from '../data/catalog'
 import {getStatDefinitions} from './stats'
 import {deriveResourceStats} from './stratum'
+import {ITEM_SHIP_T1_PACKED} from '../data/item-ids'
 
 export interface StackInput {
     quantity: number
@@ -41,6 +42,7 @@ function getItemStatKeys(itemId: number): string[] {
         if (!item.category) return []
         return getStatDefinitions(item.category).map((d) => d.key)
     }
+    if (itemId === ITEM_SHIP_T1_PACKED) return ['strength', 'density', '', '']
     const recipe = getRecipe(itemId)
     if (!recipe) return []
     return recipe.statSlots.map((slot) => keyForStatSlot(recipe, slot))
@@ -58,15 +60,30 @@ function keyForStatSlot(
 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.
+    // Every input names an item by id; its stats follow that item's own layout
+    // (resource stat definitions for resources, statSlots for crafted items).
     const innerKeys = getItemStatKeys(input.itemId)
     return innerKeys[statIndex] ?? ''
 }
 
+export function usedInputStatKeys(outputItemId: number): string[][] {
+    const recipe = getRecipe(outputItemId)
+    if (!recipe) return []
+    const usedIdx = recipe.inputs.map(() => new Set<number>())
+    for (const slot of recipe.statSlots) {
+        for (const src of slot.sources) {
+            usedIdx[src.inputIndex]?.add(src.statIndex)
+        }
+    }
+    return recipe.inputs.map((input, i) => {
+        const keys = getItemStatKeys(input.itemId)
+        return [...usedIdx[i]]
+            .sort((a, b) => a - b)
+            .map((idx) => keys[idx] ?? '')
+            .filter(Boolean)
+    })
+}
+
 export function decodeCraftedItemStats(itemId: number, stats: bigint): Record<string, number> {
     const keys = getItemStatKeys(itemId)
     const result: Record<string, number> = {}
@@ -117,10 +134,11 @@ export function computeComponentStats(
         const src = slot.sources[0]
         const key = keyForStatSlot(recipe, slot)
         const input = src ? recipe.inputs[src.inputIndex] : undefined
-        if (!input || !('category' in input)) {
+        const inputItem = input ? getItem(input.itemId) : undefined
+        if (!inputItem || inputItem.type !== 'resource' || !inputItem.category) {
             return {key, value: Math.max(1, Math.min(999, 0))}
         }
-        const matching = categoryStacks.find((cs) => cs.category === input.category)
+        const matching = categoryStacks.find((cs) => cs.category === inputItem.category)
         const value = matching ? blendStacks(matching.stacks, key) : 0
         return {key, value: Math.max(1, Math.min(999, value))}
     })
@@ -143,16 +161,20 @@ export function computeEntityStats(
     }
 
     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 slotKey = keyForStatSlot(recipe, slot)
+        if (slot.sources.length === 0) return {key: slotKey, value: 1}
+        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]
+            if (!input) continue
+            const weight = recipe.blendWeights?.[src.inputIndex] ?? 1
+            weightedSum += (blendedByComponent[input.itemId]?.[key] ?? 0) * weight
+            totalWeight += weight
         }
-        const blended = blendedByComponent[input.itemId] ?? {}
-        const value = blended[key] ?? 0
-        return {key, value: Math.max(1, Math.min(999, value))}
+        const value = totalWeight > 0 ? Math.floor(weightedSum / totalWeight) : 0
+        return {key: slotKey, value: Math.max(1, Math.min(999, value))}
     })
 }
 
@@ -165,7 +187,7 @@ function legacyEntityIdToItemId(id: string): number {
         case 'warehouse-t1':
             return 10202
         case 'container-t2':
-            return 20200
+            return 11200
         default:
             return 0
     }
@@ -185,12 +207,7 @@ export function computeInputMass(itemId: number): number {
 
     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
-        }
+        total += getItem(input.itemId).mass * input.quantity
     }
     return total
 }
@@ -300,15 +317,18 @@ export function computeCraftedOutputStats(
             out.push(0)
             continue
         }
-        if (slot.sources.length === 1 || recipe.blendWeights.length === 0) {
+        if (slot.sources.length === 1) {
             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
+            if (input) {
+                const inputItem = getItem(input.itemId)
+                if (inputItem.type === 'resource' && inputItem.category) {
+                    value = blendStacks(decodedByCategory[inputItem.category] ?? [], key)
+                } else {
+                    value = blendedByItem[input.itemId]?.[key] ?? 0
+                }
             }
             out.push(Math.max(1, Math.min(999, value)))
         } else {
@@ -319,10 +339,13 @@ export function computeCraftedOutputStats(
                 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
+                if (input) {
+                    const inputItem = getItem(input.itemId)
+                    if (inputItem.type === 'resource' && inputItem.category) {
+                        value = blendStacks(decodedByCategory[inputItem.category] ?? [], key)
+                    } else {
+                        value = blendedByItem[input.itemId]?.[key] ?? 0
+                    }
                 }
                 weightedSum += value * weight
                 totalWeight += weight
@@ -340,7 +363,7 @@ export function computeCraftedOutputStats(
  * returns a UInt64 whose bit-packed form matches what the contract writes
  * to cargo_item.stats on gather.
  *
- * Use this whenever off-chain code simulates a gather (testmap, player
+ * Use this whenever off-chain code simulates a gather (webapp, player
  * scanners that project cargo outcomes) and needs a value that matches
  * what on-chain cargo would carry.
  */

package/src/derivation/index.ts

@@ -17,7 +17,9 @@ export {
     DEPTH_THRESHOLD_T5,
     LOCATION_MIN_DEPTH,
     LOCATION_MAX_DEPTH,
-    YIELD_THRESHOLD,
+    yieldThresholdAt,
+    YIELD_FRACTION_SHALLOW,
+    YIELD_FRACTION_DEEP,
     PLANET_SUBTYPE_GAS_GIANT,
     PLANET_SUBTYPE_ROCKY,
     PLANET_SUBTYPE_TERRESTRIAL,
@@ -26,8 +28,31 @@ export {
     PLANET_SUBTYPE_INDUSTRIAL,
 } from './resources'
 
-export {RESERVE_TIERS, TIER_ROLL_MAX, 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'
+export type {EffectiveReserveInput} from './reserve-regen'
+
 export * from './stats'
 export * from './crafting'
+export * from './upgrades'
+
+export {
+    STAR_STEP,
+    MAX_STARS_PER_STAT,
+    MAX_STAR_RATING,
+    starsForStat,
+    starRating,
+    statMagnitude,
+    compareByStars,
+} from './stars'
+export type {StarSortable} from './stars'

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

@@ -0,0 +1,90 @@
+import {expect, test} from 'bun:test'
+import {
+    getAllRecipes,
+    getRecipeConsumers,
+    getComponentDemand,
+    getResourceDemand,
+} from './recipe-usage'
+import {
+    ITEM_SENSOR,
+    ITEM_RESIN,
+    ITEM_FRAME,
+    ITEM_PLATE,
+    ITEM_BEAM,
+    ITEM_GATHERER_T1,
+    ITEM_CRAFTER_T1,
+    ITEM_BUILDER_T1,
+    ITEM_EXTRACTOR_T1_PACKED,
+    ITEM_WORKSHOP_T1_PACKED,
+    ITEM_ROUSTABOUT_T1A_PACKED,
+    ITEM_PROSPECTOR_T1A_PACKED,
+    ITEM_TENDER_T1A_PACKED,
+    ITEM_TUG_T1A_PACKED,
+    ITEM_PORTER_T1A_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_CRAFTER_T1,
+            ITEM_BUILDER_T1,
+            ITEM_EXTRACTOR_T1_PACKED,
+            ITEM_WORKSHOP_T1_PACKED,
+            ITEM_ROUSTABOUT_T1A_PACKED,
+        ].sort((a, b) => a - b)
+    )
+})
+
+test('Frame feeds the gatherer drain stat', () => {
+    const consumers = getRecipeConsumers(ITEM_FRAME)
+    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 Frame (5 regolith + 5 biomass each)
+    expect(getResourceDemand(ITEM_GATHERER_T1)).toEqual({
+        ore: 1500,
+        gas: 1500,
+        regolith: 1500,
+        biomass: 1500,
+    })
+})
+
+test('getResourceDemand scales by quantity', () => {
+    expect(getResourceDemand(ITEM_PLATE, 3)).toEqual({ore: 30})
+})
+
+test('getComponentDemand reports Resin as consumed by eight recipes', () => {
+    const demand = getComponentDemand()
+    const resin = demand.find((d) => d.itemId === ITEM_RESIN)
+    expect(resin).toBeDefined()
+    expect(resin?.consumerCount).toBe(8)
+})

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/reserve-regen.ts

@@ -0,0 +1,34 @@
+import type {BlockTimestamp, UInt32} from '@wharfkit/antelope'
+
+export interface EffectiveReserveInput {
+    remaining: UInt32 | number
+    max_reserve: UInt32 | number
+    last_block: BlockTimestamp
+}
+
+function toNumber(value: UInt32 | number): number {
+    return typeof value === 'number' ? value : Number(value)
+}
+
+function slotsBetween(now: BlockTimestamp, last: BlockTimestamp): number {
+    const nowMs = now.toMilliseconds()
+    const lastMs = last.toMilliseconds()
+    if (nowMs <= lastMs) return 0
+    return Math.floor((nowMs - lastMs) / 500)
+}
+
+export function getEffectiveReserve(
+    row: EffectiveReserveInput,
+    now: BlockTimestamp,
+    epochSeconds: number
+): number {
+    const remaining = toNumber(row.remaining)
+    const max = toNumber(row.max_reserve)
+    if (remaining >= max) return max
+    const epochSlots = epochSeconds * 2
+    if (epochSlots === 0) return remaining
+    const elapsed = slotsBetween(now, row.last_block)
+    const regen = Math.floor((max * elapsed) / epochSlots)
+    const effective = remaining + regen
+    return effective >= max ? max : effective
+}

package/src/derivation/resources.ts

@@ -15,7 +15,15 @@ export const DEPTH_THRESHOLD_T10 = 63000
 export const LOCATION_MIN_DEPTH = 500
 export const LOCATION_MAX_DEPTH = 65535
 
-export const YIELD_THRESHOLD = Math.floor(0.001 * 0xffffffff)
+export const YIELD_FRACTION_SHALLOW = 0.002
+export const YIELD_FRACTION_DEEP = 0.0004
+
+export function yieldThresholdAt(stratum: number): number {
+    const clamped = stratum > 65535 ? 65535 : stratum
+    const t = clamped / 65535
+    const fraction = YIELD_FRACTION_SHALLOW + (YIELD_FRACTION_DEEP - YIELD_FRACTION_SHALLOW) * t
+    return Math.floor(fraction * 0xffffffff)
+}
 
 export const PLANET_SUBTYPE_GAS_GIANT = 0
 export const PLANET_SUBTYPE_ROCKY = 1