@shipload/sdk 1.0.0-next.73 → 1.0.0-next.74

package/src/data/entities.json

@@ -108,12 +108,12 @@
     "slots": [
       {
         "type": "builder",
-        "outputPct": 200,
+        "outputPct": 75,
         "maxTier": 1
       },
       {
         "type": "builder",
-        "outputPct": 200,
+        "outputPct": 75,
         "maxTier": 1
       }
     ],

package/src/index-module.ts

@@ -62,6 +62,22 @@ export {
     JobsManager,
     InfluenceManager,
 } from './managers'
+export {
+    ShuttleManager,
+    rankShuttleOptions,
+    shuttleReasonCode,
+    shuttleCandidates,
+    BOOKING_LEVEL_CODES,
+    OMITTED_REASONS,
+} from './managers/shuttle'
+export type {
+    ShuttleMode,
+    ShuttleOption,
+    ShuttleOptions,
+    ShuttleReason,
+    ShuttleReasonCode,
+    CandidateEntity,
+} from './managers/shuttle'
 export type {GridCell, ClusterCell, Cluster} from './managers'
 export type {
     CharterProgress,
@@ -341,6 +357,7 @@ export {
     jobDropoffTask,
     jobCancelRoute,
     buildJobCancelRoute,
+    hostedDropoff,
     jobCancellable,
     jobCancellationBlockReason,
     jobDeposited,
@@ -356,7 +373,10 @@ export type {
     JobStatusInput,
     JobCancelRoute,
     JobCancellationBlockReason,
+    JobRouteOptions,
+    HostedLeg,
     OwnedJob,
+    BuildJob,
     PickupInFlight,
 } from './scheduling/jobs'
 
@@ -400,6 +420,7 @@ export {
     cargoInputKey,
     hasSourceCoupling,
     hasIncomingCoupling,
+    isHostedCivicLeg,
 } from './scheduling/availability'
 export type {CargoInput, IncomingHoldEntity, IncomingSource} from './scheduling/availability'
 
@@ -409,7 +430,7 @@ export {calcClusterIntake, calcClustercraftDuration, INTAKE_RATE} from './capabi
 
 export {maxCraftable} from './capabilities/craftable'
 
-export {energyAtTime} from './scheduling/energy'
+export {energyAtTime, energyDrawsFunded} from './scheduling/energy'
 
 export * from './types/capabilities'
 export * from './types/entity'

package/src/influence/civic-shuttle.test.ts

@@ -12,6 +12,7 @@ import {
     pendingCivicTransfers,
     selectCivicShuttleBay,
     CIVIC_TRANSFER_PER_PLAYER_CAP,
+    type CivicShuttleBay,
 } from './civic-shuttle'
 
 type Lane = ServerContract.Types.lane
@@ -63,6 +64,32 @@ function shuttleTask(senderId: number, receiverId: number, group?: number): Task
     } as unknown as Task
 }
 
+function civicTask(type: number, couplings: unknown[]): Task {
+    return {
+        type: UInt8.from(type),
+        duration: UInt32.from(60),
+        cancelable: UInt8.from(2),
+        cargo: [],
+        couplings,
+    } as unknown as Task
+}
+
+function pullCoupling(id: number) {
+    return {
+        counterpart: {entity_id: UInt64.from(id), entity_type: UInt8.from(1)},
+        hold: UInt64.from(1),
+        kind: UInt8.from(HoldKind.PULL),
+    }
+}
+
+function pushCoupling(id: number) {
+    return {
+        counterpart: {entity_id: UInt64.from(id), entity_type: UInt8.from(1)},
+        hold: UInt64.from(1),
+        kind: UInt8.from(HoldKind.PUSH),
+    }
+}
+
 function makeLane(laneKey: number, tasks: Task[]): Lane {
     return {
         lane_key: UInt8.from(laneKey),
@@ -142,6 +169,13 @@ test('selectCivicShuttleBay takes the first free bay, then the lowest occupied o
     expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, bothBusy, T0)?.laneKey).toBe(1)
 })
 
+test('selectCivicShuttleBay picks the earliest finish, not the first free bay', () => {
+    const modules = depotModules()
+    const lanes = [makeLane(1, [shuttleTask(20, 21)])]
+    const fast = (bay: CivicShuttleBay) => (bay.slotIndex === 0 ? 10 : 500)
+    expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, lanes, T0, fast)?.slotIndex).toBe(0)
+})
+
 test('selectCivicShuttleBay returns nothing when the building has no loaders', () => {
     const modules = [makeModuleEntry(ITEM_STORAGE_T1, storageStats)]
     expect(selectCivicShuttleBay(modules, ITEM_DEPOT_T1_PACKED, [], T0)).toBeUndefined()
@@ -190,6 +224,30 @@ test('civicTransfersFrom counts only the ships a player sends from', () => {
     expect(civicTransfersFrom(entity, [99], T0).length).toBe(0)
 })
 
+test('civic legs on bays count toward the player cap', () => {
+    const depot = {
+        lanes: [makeLane(1, [civicTask(TaskType.CIVIC_WITHDRAW, [pushCoupling(7)])])],
+    } as never
+    expect(civicTransfersFrom(depot, [7]).length).toBe(1)
+})
+
+test('a civic deposit leg reports the same player id as sender and receiver', () => {
+    const depot = {
+        lanes: [makeLane(1, [civicTask(TaskType.CIVIC_DEPOSIT, [pullCoupling(7)])])],
+    } as never
+    const [transfer] = pendingCivicTransfers(depot, T0)
+    expect(String(transfer.senderId)).toBe('7')
+    expect(String(transfer.receiverId)).toBe('7')
+})
+
+test('a civic pickup leg is not callable while CANCEL_NEVER', () => {
+    const task = civicTask(TaskType.CIVIC_WITHDRAW, [pushCoupling(7)])
+    ;(task as unknown as {cancelable: unknown}).cancelable = UInt8.from(0)
+    const depot = {lanes: [makeLane(1, [task])]} as never
+    const [transfer] = pendingCivicTransfers(depot, T0)
+    expect(transfer.callable).toBe(false)
+})
+
 test('civicTransfersAtCap trips at the per-player cap', () => {
     const mine = Array.from({length: CIVIC_TRANSFER_PER_PLAYER_CAP}, (_, i) =>
         shuttleTask(20 + i, 50)

package/src/influence/civic-shuttle.ts

@@ -4,7 +4,7 @@ import {getItem} from '../data/catalog'
 import {JOB_QUEUE_CAP} from '../scheduling/jobs'
 import {laneKeyForModule, resolveLaneLoader} from '../scheduling/lanes'
 import {orderedTasks, type ScheduleData} from '../scheduling/schedule'
-import {HoldKind, TaskType} from '../types'
+import {HoldKind, TaskCancelable, TaskType} from '../types'
 
 type CargoItem = ServerContract.Types.cargo_item
 type Lane = ServerContract.Types.lane
@@ -22,7 +22,6 @@ export interface CivicShuttleBay {
     full: boolean
 }
 
-// a landed booking clears during the next civicshuttle, so only unfinished tasks occupy a bay
 function unfinishedTasks(lane: Lane | undefined, now: Date): number {
     if (!lane) return 0
     const startedMs = lane.schedule.started.toDate().getTime()
@@ -64,15 +63,38 @@ export function civicShuttleBays(
     return bays
 }
 
-// Mirrors worker_lane_key_or_mobility for loaders: first free bay, else the lowest bay.
+function laneEndMs(lane: Lane | undefined, nowMs: number): number {
+    if (!lane) return nowMs
+    let endSec = 0
+    for (const task of lane.schedule.tasks) endSec += task.duration.toNumber()
+    return Math.max(nowMs, lane.schedule.started.toDate().getTime() + endSec * 1000)
+}
+
+// Mirrors cargo.cpp pick_civic_bay: earliest finish among bays below the queue cap.
 export function selectCivicShuttleBay(
     modules: ModuleEntry[],
     entityItemId: number,
     lanes: Lane[],
-    now: Date = new Date()
+    now: Date = new Date(),
+    durationFor: (bay: CivicShuttleBay) => number = () => 0,
+    minStart?: Date
 ): CivicShuttleBay | undefined {
     const bays = civicShuttleBays(modules, entityItemId, lanes, now)
-    return bays.find((bay) => bay.queued === 0) ?? bays[0]
+    const nowMs = now.getTime()
+    const floorMs = Math.max(nowMs, minStart?.getTime() ?? nowMs)
+    let best: CivicShuttleBay | undefined
+    let bestEnd = Infinity
+    for (const bay of bays) {
+        if (bay.full) continue
+        const lane = lanes.find((l) => l.lane_key.toNumber() === bay.laneKey)
+        const start = Math.max(laneEndMs(lane, nowMs), floorMs)
+        const end = start + durationFor(bay) * 1000
+        if (end < bestEnd) {
+            best = bay
+            bestEnd = end
+        }
+    }
+    return best ?? bays[0]
 }
 
 export interface PendingCivicTransfer {
@@ -98,7 +120,31 @@ export function pendingCivicTransfers(
     }
     const out: PendingCivicTransfer[] = []
     for (const entry of orderedTasks(entity)) {
-        if (entry.task.type.toNumber() !== TaskType.SHUTTLE) continue
+        const type = entry.task.type.toNumber()
+        if (type === TaskType.CIVIC_DEPOSIT || type === TaskType.CIVIC_WITHDRAW) {
+            const side = entry.task.couplings[0]
+            if (!side) continue
+            const isTail = tailIndex.get(entry.laneKey) === entry.taskIndex
+            const complete = entry.completesAt.getTime() <= now.getTime()
+            out.push({
+                laneKey: entry.laneKey,
+                taskIndex: entry.taskIndex,
+                senderId: side.counterpart.entity_id,
+                receiverId: side.counterpart.entity_id,
+                cargo: entry.task.cargo,
+                startsAt: entry.startsAt,
+                completesAt: entry.completesAt,
+                isTail,
+                complete,
+                callable:
+                    isTail &&
+                    !complete &&
+                    !entry.task.entitygroup &&
+                    entry.task.cancelable.toNumber() !== TaskCancelable.NEVER,
+            })
+            continue
+        }
+        if (type !== TaskType.SHUTTLE) continue
         const pull = entry.task.couplings.find((c) => c.kind.toNumber() === HoldKind.PULL)
         const push = entry.task.couplings.find((c) => c.kind.toNumber() === HoldKind.PUSH)
         if (!pull || !push) continue

package/src/influence/duration.ts

@@ -1,9 +1,4 @@
-import type {NameType} from '@wharfkit/antelope'
-import type {ServerContract} from '../contracts'
-import {getEntityClass} from '../data/kind-registry'
 import {computeLoaderMass, computeLoaderThrust} from '../nft/description'
-import {laneKeyForModule, resolveLaneLoader} from '../scheduling/lanes'
-import {calc_onesided_duration} from '../travel/travel'
 import {MASS_STAT_SCALE, MASS_UNITS_PER_TONNE, PRECISION} from '../types'
 import {CIVIC_LOADER_STAT, CIVIC_LOADER_TIER, DEFAULT_ORBITAL_Z} from './constants'
 
@@ -39,63 +34,3 @@ export function contributeDuration(totalMass: number, altitudeZ = 0): number {
 export function contributeDurationForTonnes(tonnes: number, altitudeZ = 0): number {
     return contributeDuration(Math.floor(tonnes * MASS_UNITS_PER_TONNE), altitudeZ)
 }
-
-export const DEPOT_LOADER_SLOT = 0
-
-export interface DepotTransferParams {
-    depotModules: ServerContract.Types.module_entry[]
-    depotItemId: number
-    depotKind: NameType
-    depotZ: number
-    shipKind: NameType
-    shipZ: number
-    cargoMass: number
-}
-
-// Mirrors depot.cpp: the depot's slot-0 loader drives the transfer; 0 when no loader is installed.
-export function depotTransferDuration(params: DepotTransferParams): number {
-    const loader = resolveLaneLoader(
-        params.depotModules,
-        params.depotItemId,
-        laneKeyForModule(DEPOT_LOADER_SLOT)
-    )
-    if (!loader.valid) return 0
-    return calc_onesided_duration(
-        loader.thrust,
-        loader.mass,
-        params.shipZ,
-        params.depotZ,
-        getEntityClass(params.shipKind),
-        getEntityClass(params.depotKind),
-        params.cargoMass
-    )
-}
-
-export interface CivicDropoffParams {
-    buildingModules: ServerContract.Types.module_entry[]
-    buildingItemId: number
-    buildingKind: NameType
-    buildingZ: number
-    shipKind: NameType
-    shipZ: number
-    cargoMass: number
-}
-
-// Mirrors jobs.cpp craftjob: the building's slot-0 loader when one is installed, the civic loader when none is.
-export function civicDropoffDuration(params: CivicDropoffParams): number {
-    const loader = resolveLaneLoader(
-        params.buildingModules,
-        params.buildingItemId,
-        laneKeyForModule(DEPOT_LOADER_SLOT)
-    )
-    if (!loader.valid) return contributeDuration(params.cargoMass, params.shipZ)
-    return calc_onesided_duration(
-        loader.thrust,
-        loader.mass,
-        params.shipZ,
-        params.buildingZ,
-        getEntityClass(params.shipKind),
-        getEntityClass(params.buildingKind),
-        params.cargoMass
-    )
-}

package/src/influence/index.ts

@@ -26,24 +26,23 @@ export {
 export {
     componentBaseAtomic,
     componentEffortAtomic,
+    explainCargoItem,
     pricingFromWeights,
     resourceValueAtomic,
     valueCargoItem,
     valueContribution,
     weightedQualityAtomic,
+    type CargoValuation,
+    type ComponentValuation,
     type InfluencePricing,
+    type ResourceValuation,
     type ValuedItem,
 } from './valuation'
 export {
-    civicDropoffDuration,
     civicLoader,
     contributeDuration,
     contributeDurationForTonnes,
-    depotTransferDuration,
-    DEPOT_LOADER_SLOT,
-    type CivicDropoffParams,
     type CivicLoaderStats,
-    type DepotTransferParams,
 } from './duration'
 export {
     civicShuttleBays,

package/src/influence/influence.test.ts

@@ -1,6 +1,5 @@
 import {describe, expect, test} from 'bun:test'
-import {Checksum256, UInt8, UInt16, UInt64} from '@wharfkit/antelope'
-import type {ServerContract} from '../contracts'
+import {Checksum256} from '@wharfkit/antelope'
 import {ITEM_ORE_T1, ITEM_PLATE, ITEM_CRYSTAL_T1} from '../data/item-ids'
 import {categoryIndex} from './categories'
 import {
@@ -20,9 +19,10 @@ import {
     popcount5,
 } from './demand'
 import {findDecomp, DECOMP_REGISTRY} from './decomp'
-import {civicDropoffDuration, depotTransferDuration, contributeDuration} from './duration'
+import {contributeDuration} from './duration'
 import {getStatCount, statsSumSq} from './quality'
-import {pricingFromWeights, valueCargoItem, valueContribution} from './valuation'
+import {explainCargoItem, pricingFromWeights, valueCargoItem, valueContribution} from './valuation'
+import {getItems} from '../data/catalog'
 import {citizenryName, citizenryPatternCount} from './citizenry'
 import citizenryAdjectives from '../data/citizenry-adjectives.json'
 import citizenryNouns from '../data/citizenry-nouns.json'
@@ -155,6 +155,53 @@ describe('decomposition', () => {
     })
 })
 
+describe('explainCargoItem', () => {
+    test('factors reproduce valueCargoItem for every valuable catalog item', () => {
+        const acute = buildDemand(0, categoryIndex('regolith'), DEMAND_TRIPLE_SEED)
+        for (const def of getItems()) {
+            if (def.type !== 'resource' && def.type !== 'component') continue
+            const item = {itemId: Number(def.id), quantity: 7, stats: packStats(363, 535, 246)}
+            const explained = explainCargoItem(item, acute, pricing)
+            expect(explained.totalAtomic).toBe(valueCargoItem(item, acute, pricing))
+        }
+    })
+
+    test('a resource explains mass, weight, quality and need', () => {
+        const acute = buildDemand(0, categoryIndex('crystal'), DEMAND_TRIPLE_SEED)
+        const explained = explainCargoItem(
+            {itemId: ITEM_CRYSTAL_T1, quantity: 5000, stats: packStats(PAR)},
+            acute,
+            pricing
+        )
+        if (explained.kind !== 'resource') throw new Error('expected resource')
+        expect(explained.mass).toBe(
+            BigInt(getItems().find((i) => Number(i.id) === ITEM_CRYSTAL_T1)!.mass) * 5000n
+        )
+        expect(explained.weight).toBe(1)
+        expect(explained.quality).toBeCloseTo(1, 6)
+        expect(explained.need).toBe(2)
+        expect(explained.points).toBeCloseTo(
+            (Number(explained.mass) / 10) * explained.weight * explained.quality * explained.need,
+            3
+        )
+    })
+
+    test('a component explains raw mass, material weight, quality and effort', () => {
+        const explained = explainCargoItem(
+            {itemId: ITEM_PLATE, quantity: 3, stats: packStats(PAR)},
+            baseDemand,
+            pricing
+        )
+        if (explained.kind !== 'component') throw new Error('expected component')
+        const entry = findDecomp(ITEM_PLATE)!
+        const raw = entry.buckets.reduce((sum, b) => sum + b.rawMass, 0)
+        expect(explained.rawMass).toBe(raw * 3)
+        expect(explained.processedMass).toBe(entry.processedMass * 3)
+        expect(explained.weight).toBeGreaterThanOrEqual(1)
+        expect(explained.baseAtomic + explained.effortAtomic).toBe(explained.totalAtomic)
+    })
+})
+
 describe('valuation', () => {
     test('a tonne of par T1 ore at base demand is worth exactly one point', () => {
         const value = valueCargoItem(
@@ -316,135 +363,3 @@ describe('scales', () => {
         expect(NEED_FP_SCALE % INFLUENCE_ATOMIC_PER_POINT).toBe(0)
     })
 })
-
-describe('depot transfer duration', () => {
-    type ModuleEntry = ServerContract.Types.module_entry
-    const DEPOT_ITEM = 10219
-    const LOADER_T1 = 10103
-
-    function makeModuleEntry(itemId: number, stats: bigint): ModuleEntry {
-        return {
-            type: UInt8.from(0),
-            installed: {item_id: UInt16.from(itemId), stats: UInt64.from(stats)},
-        } as unknown as ModuleEntry
-    }
-    function emptySlot(): ModuleEntry {
-        return {type: UInt8.from(0)} as unknown as ModuleEntry
-    }
-
-    // A spawned depot: loader in slot 0, four empty bays after it.
-    const depotWithLoader = (): ModuleEntry[] => [
-        makeModuleEntry(LOADER_T1, packStats(500)),
-        emptySlot(),
-        emptySlot(),
-        emptySlot(),
-        emptySlot(),
-    ]
-    const params = (overrides: Record<string, unknown> = {}) => ({
-        depotModules: depotWithLoader(),
-        depotItemId: DEPOT_ITEM,
-        depotKind: 'depot',
-        depotZ: 0,
-        shipKind: 'ship',
-        shipZ: 0,
-        cargoMass: 100,
-        ...overrides,
-    })
-
-    test('drives off the depot loader, not the ship', () => {
-        expect(depotTransferDuration(params())).toBeGreaterThan(0)
-    })
-
-    test('grows with cargo mass', () => {
-        expect(depotTransferDuration(params({cargoMass: 10_000}))).toBeGreaterThan(
-            depotTransferDuration(params({cargoMass: 100}))
-        )
-    })
-
-    test('empty cargo costs nothing', () => {
-        expect(depotTransferDuration(params({cargoMass: 0}))).toBe(0)
-    })
-
-    test('a depot with no loader installed cannot transfer', () => {
-        expect(depotTransferDuration(params({depotModules: [emptySlot()]}))).toBe(0)
-    })
-
-    test('co-located transfers are floored at the orbital minimum distance', () => {
-        // max(planetary 100, orbital 200) = 200, so anything under 200 reads as 200
-        const touching = depotTransferDuration(params({shipZ: 0, depotZ: 0}))
-        const under = depotTransferDuration(params({shipZ: 150, depotZ: 0}))
-        const over = depotTransferDuration(params({shipZ: 400, depotZ: 0}))
-        expect(under).toBe(touching)
-        expect(over).toBeGreaterThan(touching)
-    })
-
-    test('never reports zero for real cargo', () => {
-        expect(depotTransferDuration(params({cargoMass: 1}))).toBeGreaterThanOrEqual(1)
-    })
-})
-
-describe('civic drop-off duration', () => {
-    type ModuleEntry = ServerContract.Types.module_entry
-    const DEPOT_ITEM = 10219
-    const WORKSHOP_ITEM = 10208
-    const LOADER_T1 = 10103
-
-    function makeModuleEntry(itemId: number, stats: bigint): ModuleEntry {
-        return {
-            type: UInt8.from(0),
-            installed: {item_id: UInt16.from(itemId), stats: UInt64.from(stats)},
-        } as unknown as ModuleEntry
-    }
-    function emptySlot(): ModuleEntry {
-        return {type: UInt8.from(0)} as unknown as ModuleEntry
-    }
-
-    const withLoader = () => ({
-        buildingModules: [makeModuleEntry(LOADER_T1, packStats(500)), emptySlot()],
-        buildingItemId: DEPOT_ITEM,
-        buildingKind: 'depot',
-        buildingZ: 0,
-        shipKind: 'ship',
-        shipZ: 400,
-        cargoMass: 100,
-    })
-    const withoutLoader = () => ({
-        buildingModules: [] as ModuleEntry[],
-        buildingItemId: WORKSHOP_ITEM,
-        buildingKind: 'workshop',
-        buildingZ: 0,
-        shipKind: 'ship',
-        shipZ: 400,
-        cargoMass: 100,
-    })
-
-    test('a building with a slot-0 loader prices off that loader', () => {
-        const p = withLoader()
-        expect(civicDropoffDuration(p)).toBe(
-            depotTransferDuration({
-                depotModules: p.buildingModules,
-                depotItemId: p.buildingItemId,
-                depotKind: p.buildingKind,
-                depotZ: p.buildingZ,
-                shipKind: p.shipKind,
-                shipZ: p.shipZ,
-                cargoMass: p.cargoMass,
-            })
-        )
-    })
-
-    test('a building with no loader falls back to the civic loader', () => {
-        const p = withoutLoader()
-        expect(civicDropoffDuration(p)).toBe(contributeDuration(p.cargoMass, p.shipZ))
-        expect(civicDropoffDuration(p)).toBeGreaterThan(0)
-    })
-
-    test('grows with cargo mass on both paths', () => {
-        expect(civicDropoffDuration({...withLoader(), cargoMass: 10_000})).toBeGreaterThan(
-            civicDropoffDuration(withLoader())
-        )
-        expect(civicDropoffDuration({...withoutLoader(), cargoMass: 10_000})).toBeGreaterThan(
-            civicDropoffDuration(withoutLoader())
-        )
-    })
-})

package/src/influence/valuation.ts

@@ -126,6 +126,81 @@ export function valueCargoItem(
     return withEffort
 }
 
+export interface ResourceValuation {
+    kind: 'resource'
+    category: number
+    tier: number
+    mass: bigint
+    weight: number
+    quality: number
+    need: number
+    totalAtomic: bigint
+    points: number
+}
+
+export interface ComponentValuation {
+    kind: 'component'
+    rawMass: number
+    processedMass: number
+    weight: number
+    quality: number
+    baseAtomic: bigint
+    effortAtomic: bigint
+    totalAtomic: bigint
+    points: number
+}
+
+export type CargoValuation = ResourceValuation | ComponentValuation
+
+export function explainCargoItem(
+    item: ValuedItem,
+    demand: DemandView,
+    pricing: InfluencePricing
+): CargoValuation {
+    const def = getItem(item.itemId)
+    const totalAtomic = valueCargoItem(item, demand, pricing)
+    const points = Number(totalAtomic) / INFLUENCE_ATOMIC_PER_POINT
+    const nStats = getStatCount(item.itemId)
+    const quality = statsSumSq(item.stats, nStats) / (nStats * pricing.d1)
+
+    if (def.type === 'resource') {
+        if (def.category === undefined) throw new Error('resource has no category')
+        const category = categoryIndex(def.category)
+        return {
+            kind: 'resource',
+            category,
+            tier: def.tier,
+            mass: BigInt(def.mass) * BigInt(item.quantity),
+            weight: Number(pricing.weight(category, def.tier)) / WEIGHT_FP_SCALE,
+            quality,
+            need: Number(needForCategory(demand, category)) / NEED_FP_SCALE,
+            totalAtomic,
+            points,
+        }
+    }
+
+    const entry = findDecomp(item.itemId)
+    if (!entry) throw new Error('item has no decomposition')
+    let rawMass = 0
+    let weighted = 0n
+    for (const bucket of entry.buckets) {
+        rawMass += bucket.rawMass
+        weighted += BigInt(bucket.rawMass) * pricing.weight(bucket.category, bucket.tier)
+    }
+    const effortAtomic = componentEffortAtomic(entry.processedMass, item.quantity)
+    return {
+        kind: 'component',
+        rawMass: rawMass * item.quantity,
+        processedMass: entry.processedMass * item.quantity,
+        weight: rawMass === 0 ? 0 : Number(weighted) / (rawMass * WEIGHT_FP_SCALE),
+        quality,
+        baseAtomic: totalAtomic - effortAtomic,
+        effortAtomic,
+        totalAtomic,
+        points,
+    }
+}
+
 export function valueContribution(
     bundle: ValuedItem[],
     demand: DemandView,