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

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},
+        ])
+    })
+})

package/src/influence/ballot.ts

@@ -0,0 +1,98 @@
+import {CHARTER_REGISTRY, charterEligibleChained, type CharterWorld} from './charters'
+import {CHARTER_NONE} from './constants'
+
+export interface BallotVoter {
+    account: string
+    weight: bigint
+    picks: number[]
+}
+
+/** Projects a full settlement from scratch; it does not resume an in-flight partial round. */
+export interface BallotInput {
+    world: CharterWorld
+    seats: number
+    voters: BallotVoter[]
+    picks?: number[]
+}
+
+export interface ProjectedSeat {
+    nodeId: number
+    weight: bigint
+}
+
+export interface ProjectedOption {
+    nodeId: number
+    cost: bigint
+    seat: number
+    weight: bigint
+    rank: number
+}
+
+export interface BallotProjection {
+    seats: ProjectedSeat[]
+    options: ProjectedOption[]
+}
+
+function tallyRound(input: BallotInput, seated: number[]): Map<number, bigint> {
+    const tallies = new Map<number, bigint>()
+    for (const voter of input.voters) {
+        for (const pick of voter.picks) {
+            const node = CHARTER_REGISTRY.find((n) => n.nodeId === pick)
+            if (!node || !charterEligibleChained(input.world, node, seated)) continue
+            if (voter.weight > 0n) tallies.set(pick, (tallies.get(pick) ?? 0n) + voter.weight)
+            break
+        }
+    }
+    return tallies
+}
+
+function leader(tallies: Map<number, bigint>): ProjectedSeat | undefined {
+    let winner = CHARTER_NONE
+    let best = 0n
+    for (const [option, weight] of tallies) {
+        if (weight === 0n) continue
+        if (winner === CHARTER_NONE || weight > best || (weight === best && option < winner)) {
+            best = weight
+            winner = option
+        }
+    }
+    return winner === CHARTER_NONE ? undefined : {nodeId: winner, weight: best}
+}
+
+export function projectBallot(input: BallotInput): BallotProjection {
+    const seats: ProjectedSeat[] = []
+    while (seats.length < input.seats) {
+        const seat = leader(
+            tallyRound(
+                input,
+                seats.map((s) => s.nodeId)
+            )
+        )
+        if (!seat) break
+        seats.push(seat)
+    }
+
+    const projected = seats.map((s) => s.nodeId)
+    const next = tallyRound(input, projected)
+    const picks = input.picks ?? []
+
+    const options: ProjectedOption[] = []
+    for (const node of CHARTER_REGISTRY) {
+        const seatIndex = projected.indexOf(node.nodeId)
+        const option: ProjectedOption = {
+            nodeId: node.nodeId,
+            cost: node.cost,
+            seat: seatIndex + 1,
+            weight: 0n,
+            rank: picks.indexOf(node.nodeId) + 1,
+        }
+        if (seatIndex >= 0) {
+            option.weight = seats[seatIndex].weight
+        } else {
+            if (!charterEligibleChained(input.world, node, projected)) continue
+            option.weight = next.get(node.nodeId) ?? 0n
+        }
+        options.push(option)
+    }
+    return {seats, options}
+}