@shipload/sdk 1.0.0-next.65 → 1.0.0-next.67

package/src/derivation/capabilities.ts

@@ -2,7 +2,7 @@ import {getEntityLayout} from '../data/recipes-runtime'
 import {ENTITY_SHIP, getPackedEntityType} from '../data/kind-registry'
 import {computeEffectiveModuleStat} from './stat-scaling'
 
-export const DEFAULT_BASE_HULLMASS = 100_000
+export const DEFAULT_BASE_HULLMASS = 1_000
 
 export function getBaseHullmassFor(itemId: number): number {
     return getEntityLayout(itemId)?.baseHullmass ?? DEFAULT_BASE_HULLMASS
@@ -35,7 +35,7 @@ export function computeShipHullCapabilities(
     const exponent = statSum / 4995.0
     return {
         hullmass: computeBaseHullmass(itemId, stats),
-        capacity: Math.floor(5000000 * 6 ** exponent),
+        capacity: Math.floor(50000 * 6 ** exponent),
     }
 }
 
@@ -126,7 +126,7 @@ export function computeLoaderCapabilities(
     const insulation = stats.insulation
     const plasticity = stats.plasticity
     return {
-        mass: Math.max(200, 2000 - Math.floor(insulation * 2)),
+        mass: Math.max(2, 20 - Math.floor(insulation / 50)),
         thrust: Math.floor(
             ((1 + Math.floor((plasticity * plasticity) / 10000)) *
                 moduleTierPct(LOADER_THRUST_TIER_PCT, tier)) /
@@ -359,7 +359,7 @@ export function computeWarehouseHullCapabilities(stats: Record<string, number>):
     const exponent = statSum / 1998.0
     return {
         hullmass: computeBaseHullmass(ITEM_WAREHOUSE_T1_PACKED, stats),
-        capacity: Math.floor(100000000 * 6 ** exponent),
+        capacity: Math.floor(1000000 * 6 ** exponent),
     }
 }
 
@@ -371,7 +371,7 @@ export function computeDepotHullCapabilities(stats: Record<string, number>): {
     const exponent = statSum / 1998.0
     return {
         hullmass: computeBaseHullmass(ITEM_DEPOT_T1_PACKED, stats),
-        capacity: Math.floor(50000000 * 6 ** exponent),
+        capacity: Math.floor(500000 * 6 ** exponent),
     }
 }
 
@@ -383,7 +383,7 @@ export function computeWorkshopHullCapabilities(stats: Record<string, number>):
     const exponent = statSum / 1998.0
     return {
         hullmass: computeBaseHullmass(ITEM_WORKSHOP_T1_PACKED, stats),
-        capacity: Math.floor(5000000 * 6 ** exponent),
+        capacity: Math.floor(50000 * 6 ** exponent),
     }
 }
 
@@ -702,6 +702,6 @@ export function computeContainerCapabilities(stats: Record<string, number>): {
     const exponent = statSum / 1998.0
     return {
         hullmass: computeBaseHullmass(ITEM_CONTAINER_T1_PACKED, stats),
-        capacity: Math.floor(22000000 * 6 ** exponent),
+        capacity: Math.floor(220000 * 6 ** exponent),
     }
 }

package/src/derivation/strata.ts

@@ -1,5 +1,5 @@
-import type {Checksum256Type} from '@wharfkit/antelope'
-import type {CoordinatesType} from '../types'
+import {Checksum256, type Checksum256Type} from '@wharfkit/antelope'
+import {Coordinates, type CoordinatesType} from '../types'
 import {deriveLocationStatic} from '../utils/system'
 import {deriveLocationSize} from './location-size'
 import {deriveResourceStats, deriveStratum, type ResourceStats} from './stratum'
@@ -26,9 +26,11 @@ export function deriveStrata(
     if (size === 0) return []
 
     const subtype = Number(loc.subtype)
+    const seed = Checksum256.from(epochSeed)
+    const at = Coordinates.from(coords)
     const out: DerivedStratum[] = []
     for (let i = 0; i < size; i++) {
-        const s = deriveStratum(epochSeed, coords, i, locType, subtype, size)
+        const s = deriveStratum(seed, at, i, locType, subtype, size)
         if (s.reserve === 0) continue
         out.push({
             index: i,

package/src/derivation/tiers.ts

@@ -8,11 +8,11 @@ export interface TierRange {
 }
 
 export const RESERVE_TIERS: Record<ReserveTier, TierRange> = {
-    small: {min: 3_600_000, max: 14_400_000},
-    medium: {min: 24_000_000, max: 48_000_000},
-    large: {min: 96_000_000, max: 168_000_000},
-    massive: {min: 240_000_000, max: 600_000_000},
-    motherlode: {min: 960_000_000, max: 2_400_000_000},
+    small: {min: 36_000, max: 144_000},
+    medium: {min: 240_000, max: 480_000},
+    large: {min: 960_000, max: 1_680_000},
+    massive: {min: 2_400_000, max: 6_000_000},
+    motherlode: {min: 9_600_000, max: 24_000_000},
 }
 
 const SHALLOW_THRESHOLDS = {

package/src/entity/hydrate.test.ts

@@ -0,0 +1,156 @@
+import {UInt64} from '@wharfkit/antelope'
+import {describe, expect, test} from 'bun:test'
+import {entityToRouteMover, hydrateEntityLanes} from './hydrate'
+
+describe('hydrateEntityLanes', () => {
+    test('maps camelCase gathererLanes to gatherer_lane with snake_case fields', () => {
+        const lanes = hydrateEntityLanes({
+            gathererLanes: [
+                {slotIndex: 2, yield: 700, drain: 1_250_000, depth: 5000, outputPct: 100},
+            ],
+        })
+        expect(lanes).toHaveLength(1)
+        expect(lanes[0].slot_index.toNumber()).toBe(2)
+        expect(lanes[0].yield.toNumber()).toBe(700)
+        expect(lanes[0].drain.toNumber()).toBe(1_250_000)
+        expect(lanes[0].depth.toNumber()).toBe(5000)
+        expect(lanes[0].output_pct.toNumber()).toBe(100)
+    })
+
+    test('falls back to a single synthetic lane from caps.gatherer when gathererLanes is absent', () => {
+        const lanes = hydrateEntityLanes({gatherer: {yield: 300, drain: 50, depth: 1000}})
+        expect(lanes).toHaveLength(1)
+        expect(lanes[0].slot_index.toNumber()).toBe(0)
+        expect(lanes[0].yield.toNumber()).toBe(300)
+        expect(lanes[0].drain.toNumber()).toBe(50)
+        expect(lanes[0].depth.toNumber()).toBe(1000)
+        expect(lanes[0].output_pct.toNumber()).toBe(100)
+    })
+
+    test('prefers gathererLanes over the caps.gatherer fallback when both are present', () => {
+        const lanes = hydrateEntityLanes({
+            gathererLanes: [{slotIndex: 1, yield: 10, drain: 20, depth: 30, outputPct: 40}],
+            gatherer: {yield: 999, drain: 999, depth: 999},
+        })
+        expect(lanes).toHaveLength(1)
+        expect(lanes[0].slot_index.toNumber()).toBe(1)
+    })
+
+    test('returns an empty array when there is no gatherer capability at all', () => {
+        expect(hydrateEntityLanes({})).toEqual([])
+    })
+
+    test('clamps out-of-range and non-integer fields to the contract field bounds', () => {
+        const lanes = hydrateEntityLanes({
+            gathererLanes: [
+                {
+                    slotIndex: -5,
+                    yield: 999_999,
+                    drain: -1,
+                    depth: 70_000.7,
+                    outputPct: Number.NaN,
+                },
+            ],
+        })
+        expect(lanes[0].slot_index.toNumber()).toBe(0)
+        expect(lanes[0].yield.toNumber()).toBe(65_535)
+        expect(lanes[0].drain.toNumber()).toBe(0)
+        expect(lanes[0].depth.toNumber()).toBe(65_535)
+        expect(lanes[0].output_pct.toNumber()).toBe(0)
+    })
+
+    test('clamps a slot index above the uint8 ceiling', () => {
+        const lanes = hydrateEntityLanes({
+            gathererLanes: [{slotIndex: 300, yield: 0, drain: 0, depth: 0, outputPct: 0}],
+        })
+        expect(lanes[0].slot_index.toNumber()).toBe(255)
+    })
+
+    test('clamps drain above the uint32 ceiling', () => {
+        const lanes = hydrateEntityLanes({
+            gathererLanes: [{slotIndex: 0, yield: 0, drain: 5_000_000_000, depth: 0, outputPct: 0}],
+        })
+        expect(lanes[0].drain.toNumber()).toBe(4_294_967_295)
+    })
+})
+
+describe('entityToRouteMover', () => {
+    test('sums hullmass, cargomass, and loader lane mass into total mass', () => {
+        const mover = entityToRouteMover(
+            {id: UInt64.from(1), energy: 500, cargomass: 200},
+            {
+                hullmass: 1000,
+                loaderLanes: [
+                    {slotIndex: 0, mass: 50, thrust: 10, outputPct: 100},
+                    {slotIndex: 1, mass: 25, thrust: 10, outputPct: 100},
+                ],
+            }
+        )
+        expect(mover.mass).toBe(1000 + 200 + 50 + 25)
+        expect(mover.energy).toBe(500)
+        expect(mover.ref).toEqual({entityType: 'ship', entityId: UInt64.from(1)})
+    })
+
+    test('derives hasMovement from the presence of both engines and a generator', () => {
+        const withMovement = entityToRouteMover(
+            {id: UInt64.from(1)},
+            {
+                hullmass: 0,
+                engines: {thrust: 100, drain: 10},
+                generator: {capacity: 1000, recharge: 10},
+            }
+        )
+        expect(withMovement.hasMovement).toBe(true)
+
+        const withoutMovement = entityToRouteMover({id: UInt64.from(1)}, {hullmass: 0})
+        expect(withoutMovement.hasMovement).toBe(false)
+    })
+
+    test('an explicit hasMovement opt overrides the derived value', () => {
+        const mover = entityToRouteMover(
+            {id: UInt64.from(1)},
+            {
+                hullmass: 0,
+                engines: {thrust: 100, drain: 10},
+                generator: {capacity: 1000, recharge: 10},
+            },
+            {hasMovement: false}
+        )
+        expect(mover.hasMovement).toBe(false)
+    })
+
+    test('narrows hauler down to capacity and efficiency, dropping drain and capacityByTier', () => {
+        const mover = entityToRouteMover(
+            {id: UInt64.from(1)},
+            {
+                hullmass: 0,
+                hauler: {
+                    capacity: 500,
+                    efficiency: 80,
+                    drain: 10,
+                    capacityByTier: [{tier: 1, capacity: 500}],
+                },
+            }
+        )
+        expect(mover.hauler).toEqual({capacity: 500, efficiency: 80})
+    })
+
+    test('defaults energy, priorMobilityEnd, and narrowBarrierEnd to zero when unset', () => {
+        const mover = entityToRouteMover({id: UInt64.from(1)}, {hullmass: 0})
+        expect(mover.energy).toBe(0)
+        expect(mover.priorMobilityEnd).toBe(0)
+        expect(mover.narrowBarrierEnd).toBe(0)
+    })
+
+    test('opts override entityType and scheduling fields', () => {
+        const mover = entityToRouteMover(
+            {id: UInt64.from(7)},
+            {hullmass: 0},
+            {entityType: 'starbase', priorMobilityEnd: 30, narrowBarrierEnd: 15, allLanesEnd: 45}
+        )
+        expect(mover.ref).toEqual({entityType: 'starbase', entityId: UInt64.from(7)})
+        expect(mover.priorMobilityEnd).toBe(30)
+        expect(mover.narrowBarrierEnd).toBe(15)
+        expect(mover.allLanesEnd).toBe(45)
+    })
+})

package/src/entity/hydrate.ts

@@ -0,0 +1,86 @@
+import type {UInt32Type, UInt64Type} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import type {ComputedCapabilities} from '../derivation/capabilities'
+import type {RouteMoverInput} from '../travel/route-simulator'
+import type {GatherLane} from '../planner'
+
+const U8_MAX = 255
+const U16_MAX = 65_535
+const U32_MAX = 4_294_967_295
+
+function clampField(value: number, max: number): number {
+    return Math.min(max, Math.max(0, Math.floor(Number(value) || 0)))
+}
+
+export interface GathererLaneSource {
+    gathererLanes?: ComputedCapabilities['gathererLanes']
+    gatherer?: ComputedCapabilities['gatherer']
+}
+
+export function hydrateEntityLanes(caps: GathererLaneSource): GatherLane[] {
+    const lanes = caps.gathererLanes?.length
+        ? caps.gathererLanes
+        : caps.gatherer
+          ? [
+                {
+                    slotIndex: 0,
+                    yield: caps.gatherer.yield,
+                    drain: caps.gatherer.drain,
+                    depth: caps.gatherer.depth,
+                    outputPct: 100,
+                },
+            ]
+          : []
+    return lanes.map((lane) =>
+        ServerContract.Types.gatherer_lane.from({
+            slot_index: clampField(lane.slotIndex, U8_MAX),
+            yield: clampField(lane.yield, U16_MAX),
+            drain: clampField(lane.drain, U32_MAX),
+            depth: clampField(lane.depth, U16_MAX),
+            output_pct: clampField(lane.outputPct, U16_MAX),
+        })
+    )
+}
+
+export interface RouteMoverRow {
+    id: UInt64Type
+    energy?: UInt32Type | number
+    cargomass?: UInt32Type | number
+}
+
+export type RouteMoverCaps = Pick<
+    ComputedCapabilities,
+    'hullmass' | 'engines' | 'generator' | 'hauler' | 'loaderLanes'
+>
+
+export interface RouteMoverOpts {
+    entityType?: string
+    hasMovement?: boolean
+    priorMobilityEnd?: number
+    narrowBarrierEnd?: number
+    allLanesEnd?: number
+}
+
+export function entityToRouteMover(
+    row: RouteMoverRow,
+    caps: RouteMoverCaps,
+    opts: RouteMoverOpts = {}
+): RouteMoverInput {
+    const loaderMass = (caps.loaderLanes ?? []).reduce((sum, lane) => sum + Number(lane.mass), 0)
+    const mass = Number(row.cargomass ?? 0) + Number(caps.hullmass ?? 0) + loaderMass
+    return {
+        ref: {entityType: opts.entityType ?? 'ship', entityId: row.id},
+        hasMovement:
+            opts.hasMovement ?? (caps.engines !== undefined && caps.generator !== undefined),
+        engines: caps.engines,
+        generator: caps.generator,
+        hauler: caps.hauler
+            ? {capacity: caps.hauler.capacity, efficiency: caps.hauler.efficiency}
+            : undefined,
+        mass,
+        energy: Number(row.energy ?? 0),
+        priorMobilityEnd: opts.priorMobilityEnd ?? 0,
+        narrowBarrierEnd: opts.narrowBarrierEnd ?? 0,
+        allLanesEnd: opts.allLanesEnd,
+    }
+}

package/src/errors.ts

@@ -94,3 +94,12 @@ export const ITEM_NOT_AVAILABLE_AT_LOCATION = 'Item is not tradeable at ship loc
 export const INSUFFICIENT_BALANCE = 'Insufficient balance.'
 export const INSUFFICIENT_ITEM_QUANTITY = 'Insufficient quantity in cargo.'
 export const INSUFFICIENT_ITEM_SUPPLY = 'Insufficient supply of item at location.'
+
+export const VOTE_NOT_CITIZEN = 'player is not a citizen of this world'
+export const BALLOT_SETTLING = 'world is settling the last epoch'
+export const BALLOT_NOT_DUE = 'ballot is not due'
+export const BALLOT_NONE_DUE = 'no ballots are due'
+
+export function isSettling(error: unknown): boolean {
+    return error instanceof Error && error.message.includes(BALLOT_SETTLING)
+}

package/src/format.ts

@@ -1,7 +1,9 @@
-export function formatMass(kg: number): string {
-    if (kg === 0) return '0 t'
-    const sign = kg < 0 ? '-' : ''
-    const centitonnes = Math.round(Math.abs(kg) / 10)
+import {MASS_UNITS_PER_TONNE} from './types'
+
+export function formatMass(mass: number): string {
+    if (mass === 0) return '0 t'
+    const sign = mass < 0 ? '-' : ''
+    const centitonnes = Math.abs(mass) * 10
     const t = Math.floor(centitonnes / 100)
     const frac = centitonnes % 100
     if (frac === 0) return `${sign}${t} t`
@@ -9,10 +11,10 @@ export function formatMass(kg: number): string {
     return `${sign}${t}.${fracStr} t`
 }
 
-export function formatMassDelta(kg: number): string {
-    if (kg === 0) return '0 t'
-    const sign = kg > 0 ? '+' : '-'
-    return `${sign}${formatMass(Math.abs(kg))}`
+export function formatMassDelta(mass: number): string {
+    if (mass === 0) return '0 t'
+    const sign = mass > 0 ? '+' : '-'
+    return `${sign}${formatMass(Math.abs(mass))}`
 }
 
 export function formatLocation(loc: {x: number; y: number}): string {
@@ -23,14 +25,14 @@ function trim(n: number, digits = 1): string {
     return n.toFixed(digits).replace(/\.?0+$/, '')
 }
 
-export function formatMassScaled(kg: number): string {
-    if (kg === 0) return '0 t'
-    const sign = kg < 0 ? '-' : ''
-    const tonnes = Math.abs(kg) / 1000
+export function formatMassScaled(mass: number): string {
+    if (mass === 0) return '0 t'
+    const sign = mass < 0 ? '-' : ''
+    const tonnes = Math.abs(mass) / MASS_UNITS_PER_TONNE
     if (tonnes >= 1_000_000_000) return `${sign}${trim(tonnes / 1_000_000_000)}b t`
     if (tonnes >= 1_000_000) return `${sign}${trim(tonnes / 1_000_000)}m t`
     if (tonnes >= 1_000) return `${sign}${trim(tonnes / 1_000)}k t`
-    return formatMass(kg)
+    return formatMass(mass)
 }
 
 export function formatInfluence(atomic: bigint | number | string): string {

package/src/index-module.ts

@@ -8,6 +8,7 @@ export * from './data/recipes-runtime'
 // Preserves both value and type sides through rollup-plugin-dts bundling.
 export {Types as ServerTypes} from './contracts/server'
 export {Types as PlatformTypes} from './contracts/platform'
+export {Types as FundTypes} from './contracts/fund'
 
 import type {ServerContract} from './contracts'
 import type {Entity as EntityType} from './entities/entity'
@@ -63,8 +64,10 @@ export type {
     FoundedWorld,
     FoundedWorldRef,
     InfluenceStanding,
-    PendingBallot,
-    VoteCast,
+    Ballot,
+    BallotVote,
+    NodeProgress,
+    QueuedSeat,
     VoteOption,
     VoteStandings,
     PlayerRosterEntry,
@@ -99,6 +102,7 @@ export {resolveLockedAmount, wrapCostKey} from './managers/nft'
 export {
     getItem,
     getItems,
+    tryGetItem,
     itemIds,
     getResources,
     getComponents,
@@ -258,6 +262,12 @@ export type {ReachStats} from './travel/reach'
 export {simulateRoute} from './travel/route-simulator'
 export type {RouteMoverInput, RouteLegSim, RouteSim} from './travel/route-simulator'
 
+export {
+    planRouteWithRetry,
+    contractRouteLegCost,
+    contractRouteHeuristic,
+} from './travel/route-build'
+
 export * as schedule from './scheduling/schedule'
 export {LANE_MOBILITY, LANE_BARRIER} from './scheduling/schedule'
 export type {
@@ -304,8 +314,8 @@ export type {
     ProjectionOptions,
 } from './scheduling/projection'
 
-export {taskCargoChanges} from './scheduling/task-cargo'
-export type {TaskCargoChange, TaskCargoDirection} from './scheduling/task-cargo'
+export {taskCargoChanges, taskCargoChangesChecked} from './scheduling/task-cargo'
+export type {TaskCargoChange, TaskCargoDirection, TaskCargoResult} from './scheduling/task-cargo'
 
 export {
     jobsToLanes,
@@ -346,12 +356,13 @@ export {
     cargoReadyAt,
     taskCargoEffect,
     calcCounterpartDelivery,
+    incomingSources,
     cargoKey,
     cargoInputKey,
     hasSourceCoupling,
     hasIncomingCoupling,
 } from './scheduling/availability'
-export type {CargoInput, IncomingSource} from './scheduling/availability'
+export type {CargoInput, IncomingHoldEntity, IncomingSource} from './scheduling/availability'
 
 export {clusterStockAvailable} from './scheduling/cluster-stock'
 
@@ -385,6 +396,10 @@ export {
     CAP_UNDEPLOY,
     CAP_DEMOLISH,
     CAP_MODULES,
+    CAP_CATCH,
+    CAP_STORE_CARGO,
+    canCatch,
+    canStoreCargo,
     isShip,
     isWarehouse,
     isExtractor,
@@ -656,17 +671,29 @@ export {
     gatherEnergyCost,
     maxQtyForCharge,
     planParallelTransfer,
+    planSingleGather,
     splitCost,
 } from './planner'
 export type {
     BuildGatherPlanOpts,
     FillCap,
     GatherCycle,
+    GatherLane,
     GatherLimpet,
     GatherPlan,
     GatherPlanEntity,
     LanePlanEntry,
     PlanTarget,
+    SingleGatherInput,
+    SingleGatherPlan,
 } from './planner'
 
+export {entityToRouteMover, hydrateEntityLanes} from './entity/hydrate'
+export type {
+    GathererLaneSource,
+    RouteMoverCaps,
+    RouteMoverOpts,
+    RouteMoverRow,
+} from './entity/hydrate'
+
 export * from './influence'

package/src/influence/ballot.test.ts

@@ -0,0 +1,103 @@
+import {describe, expect, test} from 'bun:test'
+import {
+    charterEligible,
+    charterEligibleChained,
+    CHARTER_REGISTRY,
+    type CharterWorld,
+} from './charters'
+import {projectBallot} from './ballot'
+
+const NEXUS = 20001
+const DOCK = 30100001
+const WORKSHOP_TUNEUP = 10100201
+const DOCK_TUNEUP = 30100301
+const DEPOT = 40100001
+
+const world: CharterWorld = {built: [{nodeId: 10001, repeats: 0}]}
+
+describe('charterEligibleChained', () => {
+    test('with nothing seated it equals charterEligible', () => {
+        for (const node of CHARTER_REGISTRY) {
+            expect(charterEligibleChained(world, node, [])).toBe(charterEligible(world, node))
+        }
+    })
+
+    test('a seated prerequisite opens a dependent, a seated node closes itself', () => {
+        const tuneup = CHARTER_REGISTRY.find((n) => n.nodeId === DOCK_TUNEUP)!
+        expect(charterEligibleChained(world, tuneup, [])).toBe(false)
+        expect(charterEligibleChained(world, tuneup, [DOCK])).toBe(true)
+        const dock = CHARTER_REGISTRY.find((n) => n.nodeId === DOCK)!
+        expect(charterEligibleChained(world, dock, [DOCK])).toBe(false)
+    })
+})
+
+describe('projectBallot', () => {
+    const voters = [
+        {account: 'carol', weight: 9_000n, picks: [DOCK, DOCK_TUNEUP]},
+        {account: 'dave', weight: 5_000n, picks: [NEXUS, DOCK_TUNEUP]},
+        {account: 'erin', weight: 0n, picks: [NEXUS]},
+    ]
+
+    test('one seat: the heavier pick wins and the frontier carries round weights', () => {
+        const result = projectBallot({world, seats: 1, voters})
+        expect(result.seats).toEqual([{nodeId: DOCK, weight: 9_000n}])
+        const nexus = result.options.find((o) => o.nodeId === NEXUS)!
+        expect(nexus.seat).toBe(0)
+        expect(nexus.weight).toBe(5_000n)
+        const tuneup = result.options.find((o) => o.nodeId === DOCK_TUNEUP)!
+        expect(tuneup.seat).toBe(0)
+        expect(tuneup.weight).toBe(9_000n)
+        expect(result.options.find((o) => o.nodeId === 10001)).toBeUndefined()
+    })
+
+    test('two seats: the dock tune-up chains behind the dock', () => {
+        const result = projectBallot({world, seats: 2, voters})
+        expect(result.seats.map((s) => s.nodeId)).toEqual([DOCK, DOCK_TUNEUP])
+        expect(result.seats[1].weight).toBe(9_000n)
+    })
+
+    test('a tie goes to the lower option id', () => {
+        const tied = [
+            {account: 'a', weight: 100n, picks: [DOCK]},
+            {account: 'b', weight: 100n, picks: [NEXUS]},
+        ]
+        expect(projectBallot({world, seats: 1, voters: tied}).seats[0].nodeId).toBe(NEXUS)
+    })
+
+    test('a zero round ends early and an empty queue stays empty, even with one node left', () => {
+        expect(projectBallot({world, seats: 4, voters}).seats.length).toBe(3)
+        expect(projectBallot({world, seats: 1, voters: []}).seats).toEqual([])
+        const almostDone: CharterWorld = {
+            built: CHARTER_REGISTRY.filter((n) => n.nodeId !== 40100404).map((n) => ({
+                nodeId: n.nodeId,
+                repeats: 0,
+            })),
+        }
+        expect(projectBallot({world: almostDone, seats: 1, voters: []}).seats).toEqual([])
+        expect(
+            projectBallot({
+                world: almostDone,
+                seats: 1,
+                voters: [{account: 'a', weight: 5n, picks: [40100404]}],
+            }).seats
+        ).toEqual([{nodeId: 40100404, weight: 5n}])
+    })
+
+    test('the caller picks are ranked on the options', () => {
+        const result = projectBallot({world, seats: 1, voters, picks: [NEXUS, DOCK]})
+        expect(result.options.find((o) => o.nodeId === NEXUS)!.rank).toBe(1)
+        expect(result.options.find((o) => o.nodeId === DOCK)!.rank).toBe(2)
+        expect(result.options.find((o) => o.nodeId === WORKSHOP_TUNEUP)!.rank).toBe(0)
+    })
+
+    test('a pick slot is consumed by the first eligible option regardless of the voter weight behind it', () => {
+        const scenario = [
+            {account: 'grace', weight: 50n, picks: [NEXUS, DEPOT]},
+            {account: 'frank', weight: 45n, picks: [DEPOT]},
+            {account: 'erin', weight: 0n, picks: [NEXUS, DEPOT]},
+        ]
+        expect(projectBallot({world, seats: 1, voters: scenario}).seats).toEqual([
+            {nodeId: NEXUS, weight: 50n},
+        ])
+    })
+})