@shipload/sdk 1.0.0-next.5 → 1.0.0-next.50

package/src/derivation/crafting.ts

@@ -1,6 +1,6 @@
 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'
@@ -58,11 +58,8 @@ 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] ?? ''
 }
@@ -117,10 +114,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 +141,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))}
     })
 }
 
@@ -185,12 +187,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 +297,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 +319,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 +343,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

@@ -7,6 +7,7 @@ export {
     getEligibleResources,
     getResourceWeight,
     getLocationCandidates,
+    getLocationProfile,
     getDepthThreshold,
     getResourceTier,
     DEPTH_THRESHOLD_T1,
@@ -16,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,
@@ -25,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,81 @@
+import {expect, test} from 'bun:test'
+import {
+    getAllRecipes,
+    getRecipeConsumers,
+    getComponentDemand,
+    getResourceDemand,
+} from './recipe-usage'
+import {
+    ITEM_SENSOR,
+    ITEM_SENSOR_T2,
+    ITEM_RESIN,
+    ITEM_FRAME,
+    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_CRAFTER_T1, ITEM_SHIP_T1_PACKED, ITEM_EXTRACTOR_T1_PACKED, ITEM_SENSOR_T2].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 three recipes', () => {
+    const demand = getComponentDemand()
+    const resin = demand.find((d) => d.itemId === ITEM_RESIN)
+    expect(resin).toBeDefined()
+    expect(resin?.consumerCount).toBe(3)
+})

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

@@ -1,4 +1,5 @@
 import {getItem} from '../data/catalog'
+import {LocationType} from '../types'
 
 export const DEPTH_THRESHOLD_T1 = 0
 export const DEPTH_THRESHOLD_T2 = 1500
@@ -14,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
@@ -75,37 +84,107 @@ export function getResourceWeight(itemId: number, stratum: number): number {
     }
 }
 
-const ASTEROID_RESOURCES = [101, 102, 103, 201, 202]
-const NEBULA_RESOURCES = [202, 203, 301, 302, 303]
-const GAS_GIANT_RESOURCES = [301, 302, 303, 401, 501]
-const ROCKY_RESOURCES = [101, 102, 103, 401, 402, 403, 503]
-const TERRESTRIAL_RESOURCES = [201, 202, 401, 402, 501, 502, 503]
-const ICY_RESOURCES = [101, 301, 302, 401, 403, 501, 502]
-const OCEAN_RESOURCES = [201, 203, 301, 303, 501, 502, 503]
-const INDUSTRIAL_RESOURCES = [101, 102, 103, 201, 203, 402, 403]
+const RESOURCE_ORE = 0
+const RESOURCE_GAS = 1
+const RESOURCE_REGOLITH = 2
+const RESOURCE_BIOMASS = 3
+const RESOURCE_CRYSTAL = 4
 
-export function getLocationCandidates(locationType: number, subtype: number): number[] {
-    if (locationType === 2) return ASTEROID_RESOURCES
-    if (locationType === 3) return NEBULA_RESOURCES
-    if (locationType === 1) {
+interface LocationProfileEntry {
+    category: number
+    maxTier: number
+}
+
+function categoryBaseId(category: number): number {
+    switch (category) {
+        case RESOURCE_ORE:
+            return 100
+        case RESOURCE_CRYSTAL:
+            return 200
+        case RESOURCE_GAS:
+            return 300
+        case RESOURCE_REGOLITH:
+            return 400
+        case RESOURCE_BIOMASS:
+            return 500
+        default:
+            return 0
+    }
+}
+
+function resourceId(category: number, tier: number): number {
+    return categoryBaseId(category) + tier
+}
+
+export function getLocationProfile(locationType: number, subtype: number): LocationProfileEntry[] {
+    if (locationType === LocationType.ASTEROID) {
+        return [
+            {category: RESOURCE_ORE, maxTier: 5},
+            {category: RESOURCE_CRYSTAL, maxTier: 5},
+        ]
+    }
+    if (locationType === LocationType.NEBULA) {
+        return [
+            {category: RESOURCE_GAS, maxTier: 5},
+            {category: RESOURCE_REGOLITH, maxTier: 5},
+        ]
+    }
+    if (locationType === LocationType.ICE_FIELD) {
+        return [
+            {category: RESOURCE_GAS, maxTier: 5},
+            {category: RESOURCE_BIOMASS, maxTier: 5},
+        ]
+    }
+    if (locationType === LocationType.PLANET) {
         switch (subtype) {
             case PLANET_SUBTYPE_GAS_GIANT:
-                return GAS_GIANT_RESOURCES
+                return [
+                    {category: RESOURCE_GAS, maxTier: 10},
+                    {category: RESOURCE_CRYSTAL, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_ROCKY:
-                return ROCKY_RESOURCES
+                return [
+                    {category: RESOURCE_REGOLITH, maxTier: 10},
+                    {category: RESOURCE_ORE, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_TERRESTRIAL:
-                return TERRESTRIAL_RESOURCES
+                return [
+                    {category: RESOURCE_ORE, maxTier: 10},
+                    {category: RESOURCE_BIOMASS, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_ICY:
-                return ICY_RESOURCES
+                return [
+                    {category: RESOURCE_CRYSTAL, maxTier: 10},
+                    {category: RESOURCE_REGOLITH, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_OCEAN:
-                return OCEAN_RESOURCES
+                return [
+                    {category: RESOURCE_BIOMASS, maxTier: 10},
+                    {category: RESOURCE_GAS, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_INDUSTRIAL:
-                return INDUSTRIAL_RESOURCES
+                return [
+                    {category: RESOURCE_ORE, maxTier: 3},
+                    {category: RESOURCE_CRYSTAL, maxTier: 3},
+                    {category: RESOURCE_REGOLITH, maxTier: 3},
+                    {category: RESOURCE_BIOMASS, maxTier: 3},
+                ]
         }
     }
     return []
 }
 
+export function getLocationCandidates(locationType: number, subtype: number): number[] {
+    const profile = getLocationProfile(locationType, subtype)
+    const ids: number[] = []
+    for (const {category, maxTier} of profile) {
+        for (let tier = 1; tier <= maxTier; tier++) {
+            ids.push(resourceId(category, tier))
+        }
+    }
+    return ids
+}
+
 export function getEligibleResources(
     locationType: number,
     subtype: number,

package/src/derivation/rollups.test.ts

@@ -0,0 +1,55 @@
+import {describe, expect, test} from 'bun:test'
+import {ServerContract} from '../contracts'
+import {rollupGatherer, rollupCrafter, rollupLoaders} from './rollups'
+
+const gLane = (slot: number, y: number, d: number, depth: number) =>
+    ServerContract.Types.gatherer_lane.from({
+        slot_index: slot,
+        yield: y,
+        drain: d,
+        depth,
+        output_pct: 100,
+    })
+const cLane = (slot: number, s: number, d: number) =>
+    ServerContract.Types.crafter_lane.from({slot_index: slot, speed: s, drain: d, output_pct: 100})
+const lLane = (slot: number, m: number, t: number) =>
+    ServerContract.Types.loader_lane.from({slot_index: slot, mass: m, thrust: t, output_pct: 100})
+
+describe('rollupGatherer', () => {
+    test('empty → undefined', () => {
+        expect(rollupGatherer([])).toBeUndefined()
+    })
+    test('sums yield/drain, takes MAX depth', () => {
+        const r = rollupGatherer([gLane(2, 300, 1250, 500), gLane(3, 250, 1000, 5495)])!
+        expect(r.yield.toNumber()).toBe(550)
+        expect(r.drain.toNumber()).toBe(2250)
+        expect(r.depth.toNumber()).toBe(5495)
+    })
+    test('clamps summed yield to uint16', () => {
+        const r = rollupGatherer([gLane(2, 60000, 0, 1), gLane(3, 60000, 0, 1)])!
+        expect(r.yield.toNumber()).toBe(65535)
+    })
+})
+
+describe('rollupCrafter', () => {
+    test('empty → undefined', () => {
+        expect(rollupCrafter([])).toBeUndefined()
+    })
+    test('sums speed/drain', () => {
+        const r = rollupCrafter([cLane(2, 100, 30), cLane(3, 140, 25)])!
+        expect(r.speed.toNumber()).toBe(240)
+        expect(r.drain.toNumber()).toBe(55)
+    })
+})
+
+describe('rollupLoaders', () => {
+    test('empty → undefined', () => {
+        expect(rollupLoaders([])).toBeUndefined()
+    })
+    test('integer-averages mass, sums thrust, counts quantity', () => {
+        const r = rollupLoaders([lLane(2, 200, 5), lLane(3, 201, 7)])!
+        expect(r.mass.toNumber()).toBe(200) // floor(401/2)
+        expect(r.thrust.toNumber()).toBe(12)
+        expect(r.quantity.toNumber()).toBe(2)
+    })
+})