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

package/src/managers/influence.ts

@@ -4,6 +4,7 @@ import type {ServerContract} from '../contracts'
 import {coordsToLocationId, locationIdToCoords, type CoordinatesType} from '../types'
 import {
     type BuiltCharter,
+    type WorldBuilding,
     citizenryName,
     contributeDuration,
     decayActive,
@@ -12,19 +13,20 @@ import {
     valueCargoItem,
     type DemandTriple,
     type DemandView,
+    isCivicEntity,
     type ValuedItem,
 } from '../influence'
 import {getItem} from '../data/catalog'
 
 export interface InfluenceStanding {
     epoch: number
-    playerLifetime: bigint
-    playerActive: bigint
     standingLifetime: bigint
     standingActive: bigint
+    citizenshipLifetime: bigint
+    citizenshipActive: bigint
     locationLifetime: bigint
     locationActive: bigint
-    watermark: bigint
+    spent: bigint
     mandate: number
     founder: Name
     founded: number
@@ -33,14 +35,23 @@ export interface InfluenceStanding {
 export interface CharterProgress {
     locationId: bigint
     lifetime: bigint
-    watermark: bigint
-    surplus: bigint
+    spent: bigint
+    unassigned: bigint
     mandate: number
     nextCost: bigint
     prereqsMet: boolean
     buildable: boolean
     epoch: number
-    built: {nodeId: number; completedEpoch: number; entityId: bigint}[]
+    built: BuiltCharter[]
+    ballotId: bigint
+    settling: boolean
+    queue: QueuedSeat[]
+    progress: NodeProgress[]
+}
+
+export interface NodeProgress {
+    nodeId: number
+    amount: bigint
 }
 
 export interface ContributePreviewRow {
@@ -48,13 +59,13 @@ export interface ContributePreviewRow {
     quantity: number
     stats: bigint
     valueAtomic: bigint
-    massKg: number
+    mass: number
 }
 
 export interface ContributePreview {
     rows: ContributePreviewRow[]
     totalAtomic: bigint
-    totalMassKg: number
+    totalMass: number
     durationSeconds: number
     demand: DemandView
 }
@@ -65,44 +76,59 @@ export interface FoundedWorld {
     y: number
     lifetime: bigint
     active: bigint
-    watermark: bigint
-    chosen: number
-    chosenEpoch: number
+    spent: bigint
+    ballotId: bigint
     mandate: number | undefined
     founder: Name
     founded: number
 }
 
+export interface FoundedWorldRef {
+    x: number
+    y: number
+    mandate: number
+}
+
 export interface VoteOption {
     nodeId: number
     cost: bigint
-    eligible: boolean
-    total: bigint | undefined
+    seat: number
+    weight: bigint
+    rank: number
 }
 
 export interface VoteStandings {
     locationId: bigint
+    ballotId: bigint
     epoch: number
-    chosen: number
-    chosenEpoch: number
-    mandate: number
-    ballotEpoch: number | undefined
-    talliesSuppressed: boolean
+    settledEpoch: number
+    seats: number
+    settling: boolean
+    queue: number[]
     options: VoteOption[]
+    picks: number[]
 }
 
-export interface VoteCast {
+export interface BallotVote {
     account: Name
-    epoch: number
-    nodeId: number
-    weight: bigint
+    picks: number[]
 }
 
-export interface PendingBallot {
-    locationId: bigint
-    x: number
-    y: number
-    epoch: number
+export interface Ballot {
+    ballotId: bigint
+    kind: number
+    subject: bigint
+    seats: number
+    settledEpoch: number
+    queue: number[]
+    settling: boolean
+}
+
+export interface QueuedSeat {
+    nodeId: number
+    cost: bigint
+    progress: bigint
+    gap: bigint
 }
 
 function big(value: unknown): bigint {
@@ -119,13 +145,13 @@ export class InfluenceManager extends BaseManager {
 
         return {
             epoch: Number(result.epoch),
-            playerLifetime: big(result.player_lifetime),
-            playerActive: big(result.player_active),
             standingLifetime: big(result.standing_lifetime),
             standingActive: big(result.standing_active),
+            citizenshipLifetime: big(result.citizenship_lifetime),
+            citizenshipActive: big(result.citizenship_active),
             locationLifetime: big(result.location_lifetime),
             locationActive: big(result.location_active),
-            watermark: big(result.watermark),
+            spent: big(result.spent),
             mandate: Number(result.mandate),
             founder: Name.from(result.founder),
             founded: Number(result.founded),
@@ -164,6 +190,17 @@ export class InfluenceManager extends BaseManager {
         })
     }
 
+    async getCivicOwner(): Promise<Name> {
+        const row = (await this.server.table('civicconfig').get()) as
+            | ServerContract.Types.civicconfig_row
+            | undefined
+        return row ? Name.from(row.civic_owner) : Name.from(this.server.account)
+    }
+
+    async isCivic(entity: {owner: NameType}): Promise<boolean> {
+        return isCivicEntity(entity, await this.getCivicOwner())
+    }
+
     async getCitizenryName(location: CoordinatesType): Promise<string | undefined> {
         const game = await this.getGame()
         return citizenryName(game.config.seed, location)
@@ -189,20 +226,20 @@ export class InfluenceManager extends BaseManager {
         )
 
         let totalAtomic = 0n
-        let totalMassKg = 0
+        let totalMass = 0
         const rows = bundle.map((item) => {
             const valueAtomic = valueCargoItem(item, demand, pricing)
-            const massKg = getItem(item.itemId).mass * item.quantity
+            const mass = getItem(item.itemId).mass * item.quantity
             totalAtomic += valueAtomic
-            totalMassKg += massKg
-            return {...item, valueAtomic, massKg}
+            totalMass += mass
+            return {...item, valueAtomic, mass}
         })
 
         return {
             rows,
             totalAtomic,
-            totalMassKg,
-            durationSeconds: contributeDuration(totalMassKg, opts.altitudeZ ?? 0),
+            totalMass,
+            durationSeconds: contributeDuration(totalMass, opts.altitudeZ ?? 0),
             demand,
         }
     }
@@ -216,8 +253,8 @@ export class InfluenceManager extends BaseManager {
         return {
             locationId: big(result.location_id),
             lifetime: big(result.lifetime),
-            watermark: big(result.watermark),
-            surplus: big(result.surplus),
+            spent: big(result.spent),
+            unassigned: big(result.unassigned),
             mandate: Number(result.mandate),
             nextCost: big(result.next_cost),
             prereqsMet: Boolean(result.prereqs_met),
@@ -225,8 +262,19 @@ export class InfluenceManager extends BaseManager {
             epoch: Number(result.epoch),
             built: result.built.map((b) => ({
                 nodeId: Number(b.node_id),
-                completedEpoch: Number(b.completed_epoch),
-                entityId: big(b.entity_id),
+                repeats: Number(b.repeats),
+            })),
+            ballotId: big(result.ballot_id),
+            settling: Boolean(result.settling),
+            queue: result.queue.map((seat) => ({
+                nodeId: Number(seat.node_id),
+                cost: big(seat.cost),
+                progress: big(seat.progress),
+                gap: big(seat.gap),
+            })),
+            progress: result.progress.map((p) => ({
+                nodeId: Number(p.node_id),
+                amount: big(p.amount),
             })),
         }
     }
@@ -247,73 +295,104 @@ export class InfluenceManager extends BaseManager {
         return (await this.server.readonly('getmintcfg')) as ServerContract.Types.mintcfg_result
     }
 
-    async getVotes(location: CoordinatesType): Promise<VoteStandings> {
+    async getMintReady(): Promise<number> {
+        return Number(await this.server.readonly('getmintready'))
+    }
+
+    async getVoteReady(): Promise<number> {
+        return Number(await this.server.readonly('getvoteready'))
+    }
+
+    async getCharterReady(): Promise<FoundedWorldRef[]> {
+        const result = (await this.server.readonly(
+            'getchrtready'
+        )) as ServerContract.Types.charterready_result
+        return result.worlds.map((w) => ({
+            x: Number(w.x),
+            y: Number(w.y),
+            mandate: Number(w.mandate),
+        }))
+    }
+
+    async getVotes(location: CoordinatesType, player?: NameType): Promise<VoteStandings> {
         const result = (await this.server.readonly('getvotes', {
             x: Int64.from(location.x),
             y: Int64.from(location.y),
+            player: Name.from(player ?? ''),
         })) as ServerContract.Types.vote_result
 
-        const epoch = Number(result.epoch)
-        const rawBallotEpoch = Number(result.ballot_epoch)
-        const ballotEpoch = rawBallotEpoch === 0 ? undefined : rawBallotEpoch
-        const talliesSuppressed = ballotEpoch !== undefined && ballotEpoch < epoch
-
         return {
             locationId: big(result.location_id),
-            epoch,
-            chosen: Number(result.chosen),
-            chosenEpoch: Number(result.chosen_epoch),
-            mandate: Number(result.effective),
-            ballotEpoch,
-            talliesSuppressed,
+            ballotId: big(result.ballot_id),
+            epoch: Number(result.epoch),
+            settledEpoch: Number(result.settled_epoch),
+            seats: Number(result.seats),
+            settling: Boolean(result.settling),
+            queue: result.queue.map((n) => Number(n)),
             options: result.options.map((option) => ({
                 nodeId: Number(option.node_id),
                 cost: big(option.cost),
-                eligible: Boolean(option.eligible),
-                total: talliesSuppressed ? undefined : big(option.total),
+                seat: Number(option.seat),
+                weight: big(option.weight),
+                rank: Number(option.rank),
             })),
+            picks: result.picks.map((n) => Number(n)),
+        }
+    }
+
+    async getBallotId(location: CoordinatesType): Promise<bigint | undefined> {
+        const row = (await this.server
+            .table('worlds')
+            .get(UInt64.from(coordsToLocationId(location)))) as
+            | ServerContract.Types.worlds_row
+            | undefined
+        return row ? big(row.ballot_id) : undefined
+    }
+
+    async getBallot(ballotId: bigint): Promise<Ballot | undefined> {
+        const row = (await this.server.table('ballot').get(UInt64.from(ballotId))) as
+            | ServerContract.Types.ballot_row
+            | undefined
+        if (!row) return undefined
+        const epoch = Number((await this.getState()).epoch)
+        const settledEpoch = Number(row.settled_epoch)
+        return {
+            ballotId: big(row.ballot_id),
+            kind: Number(row.kind),
+            subject: big(row.subject),
+            seats: Number(row.seats),
+            settledEpoch,
+            queue: row.queue.map((n) => Number(n)),
+            settling: settledEpoch < epoch,
         }
     }
 
-    async getVoteCasts(location: CoordinatesType): Promise<VoteCast[]> {
+    async getBallotVotes(ballotId: bigint): Promise<BallotVote[]> {
         const rows = (await this.server
-            .table('infvote', coordsToLocationId(location))
-            .all()) as ServerContract.Types.infvote_row[]
+            .table('ballotpicks', UInt64.from(ballotId))
+            .all()) as ServerContract.Types.ballotpicks_row[]
         return rows.map((row) => ({
             account: Name.from(row.account),
-            epoch: Number(row.epoch),
-            nodeId: Number(row.node_id),
-            weight: big(row.weight),
+            picks: row.picks.map((n) => Number(n)),
         }))
     }
 
-    async getVoteTallies(location: CoordinatesType): Promise<{nodeId: number; total: bigint}[]> {
-        const rows = (await this.server
-            .table('inftally', coordsToLocationId(location))
-            .all()) as ServerContract.Types.inftally_row[]
-        return rows.map((row) => ({nodeId: Number(row.node_id), total: big(row.total)}))
-    }
-
     async getBuiltCharters(location: CoordinatesType): Promise<BuiltCharter[]> {
         const rows = (await this.server
-            .table('charters', coordsToLocationId(location))
-            .all()) as ServerContract.Types.charters_row[]
-        return rows.map((row) => ({nodeId: Number(row.node_id), entityId: big(row.entity_id)}))
+            .table('mandates', coordsToLocationId(location))
+            .all()) as ServerContract.Types.mandates_row[]
+        return rows.map((row) => ({nodeId: Number(row.node_id), repeats: Number(row.repeats)}))
     }
 
-    async getBallotQueue(): Promise<PendingBallot[]> {
+    async getBuildings(location: CoordinatesType): Promise<WorldBuilding[]> {
         const rows = (await this.server
-            .table('infballot')
-            .all()) as ServerContract.Types.infballot_row[]
-        return rows.map((row) => ({
-            locationId: big(row.location_id),
-            ...locationIdToCoords(row.location_id),
-            epoch: Number(row.epoch),
-        }))
+            .table('buildings', coordsToLocationId(location))
+            .all()) as ServerContract.Types.buildings_row[]
+        return rows.map((row) => ({entityId: big(row.entity_id), building: Number(row.building)}))
     }
 
     async getFoundedWorlds(opts: {withMandate?: boolean} = {}): Promise<FoundedWorld[]> {
-        const rows = (await this.server.table('infloc').all()) as ServerContract.Types.infloc_row[]
+        const rows = (await this.server.table('worlds').all()) as ServerContract.Types.worlds_row[]
         const epoch = (await this.getState()).epoch
         const worlds = rows.map((row) => ({
             locationId: big(row.location_id),
@@ -321,11 +400,10 @@ export class InfluenceManager extends BaseManager {
             lifetime: big(row.lifetime),
             active: decayActive(
                 big(row.active),
-                Math.max(0, Number(epoch) - Number(row.last_update_epoch))
+                Math.max(0, Number(epoch) - Number(row.active_epoch))
             ),
-            watermark: big(row.watermark),
-            chosen: Number(row.chosen),
-            chosenEpoch: Number(row.chosen_epoch),
+            spent: big(row.spent),
+            ballotId: big(row.ballot_id),
             mandate: undefined as number | undefined,
             founder: Name.from(row.founder),
             founded: Number(row.founded),
@@ -341,7 +419,7 @@ export class InfluenceManager extends BaseManager {
 
     async isFounded(location: CoordinatesType): Promise<boolean> {
         const id = coordsToLocationId(location)
-        const row = await this.server.table('infloc').get(UInt64.from(id))
+        const row = await this.server.table('worlds').get(UInt64.from(id))
         return row !== undefined
     }
 }

package/src/managers/jobs.test.ts

@@ -5,7 +5,7 @@ import {JobsManager} from './jobs'
 const OWNER = 'eggmaple.gm'
 const row = (over: Record<string, unknown> = {}) => ({
     id: {toNumber: () => 7},
-    workshop: {toNumber: () => 42},
+    building: {toNumber: () => 42},
     socket: {toNumber: () => 0},
     owner: Name.from(OWNER),
     ship_id: {toNumber: () => 100},
@@ -33,7 +33,7 @@ describe('JobsManager.getOwnedJobs', () => {
         )
         const jobs = await m.getOwnedJobs(OWNER, {now: new Date('2026-07-26T11:30:00Z')})
         expect(jobs).toHaveLength(1)
-        expect(jobs[0]).toMatchObject({id: 7, workshop: 42, quantity: 5, status: 'ready'})
+        expect(jobs[0]).toMatchObject({id: 7, building: 42, quantity: 5, status: 'ready'})
         expect(jobs[0].coords).toEqual({x: 12, y: 34})
         expect(jobs[0].output).toEqual({item: 'out'} as never)
         expect(jobs[0].inputs).toEqual([{item: 'in'}] as never)

package/src/managers/jobs.ts

@@ -3,7 +3,7 @@ import {BaseManager} from './base'
 import {jobStatus, splitJobCargo, type OwnedJob} from '../scheduling/jobs'
 import type {ServerContract} from '../contracts'
 
-type JobRow = ServerContract.Types.job_row
+type JobRow = ServerContract.Types.craftjob_row
 
 export class JobsManager extends BaseManager {
     async getOwnedJobs(owner: NameType, opts?: {now?: Date}): Promise<OwnedJob[]> {
@@ -14,7 +14,7 @@ export class JobsManager extends BaseManager {
         try {
             // index_position 'tertiary' = nodeos slot 3 = owner's secondary index; no ABI metadata for it.
             rows = (await this.server
-                .table('jobs')
+                .table('craftjobs')
                 .query({
                     index_position: 'tertiary',
                     key_type: 'i64',
@@ -23,7 +23,7 @@ export class JobsManager extends BaseManager {
                 })
                 .all()) as JobRow[]
         } catch {
-            rows = (await this.server.table('jobs').all()) as JobRow[]
+            rows = (await this.server.table('craftjobs').all()) as JobRow[]
         }
 
         return rows.filter((r) => ownerName.equals(r.owner)).map((r) => this.parseOwnedJob(r, now))
@@ -35,7 +35,7 @@ export class JobsManager extends BaseManager {
         const {output, inputs} = splitJobCargo(r.cargo)
         return {
             id: r.id.toNumber(),
-            workshop: r.workshop.toNumber(),
+            building: r.building.toNumber(),
             socket: r.socket.toNumber(),
             shipId: r.ship_id.toNumber(),
             coords: {x: r.coords.x.toNumber(), y: r.coords.y.toNumber()},

package/src/nft/description.ts

@@ -28,7 +28,7 @@ import {
     BATTERY_CAPACITY_TIER_PCT,
 } from '../derivation/capabilities'
 import {getItem, tryGetItem} from '../data/catalog'
-import type {ModuleType} from '../types'
+import {MASS_UNITS_PER_TONNE, type ModuleType} from '../types'
 import {ENTITY_SHIP, getPackedEntityType} from '../data/kind-registry'
 import {getBaseHullmassFor} from '../derivation/capabilities'
 import {computeEffectiveModuleStat} from '../derivation/stat-scaling'
@@ -41,9 +41,8 @@ export function toWholeEnergy(milli: number): number {
     return idiv(milli + 500, 1000)
 }
 
-export function formatMassTonnes(kg: number): string {
-    const tenths = idiv(kg + 50, 100)
-    return `${idiv(tenths, 10)}.${tenths % 10} t`
+export function formatMassTonnes(mass: number): string {
+    return `${idiv(mass, MASS_UNITS_PER_TONNE)}.${mass % MASS_UNITS_PER_TONNE} t`
 }
 
 function isShipHull(itemId: number): boolean {
@@ -67,27 +66,27 @@ export function computeBaseHullmass(itemId: number, stats: bigint): number {
 }
 
 export function computeBaseCapacityShip(stats: bigint): number {
-    return Math.floor(5_000_000 * 6 ** (sumPackedShipChannels(stats) / 4995))
+    return Math.floor(50_000 * 6 ** (sumPackedShipChannels(stats) / 4995))
 }
 
 export function computeBaseCapacityContainer(stats: bigint): number {
     const s = decodeStat(stats, 0) + decodeStat(stats, 2)
-    return Math.floor(22_000_000 * 6 ** (s / 1998))
+    return Math.floor(220_000 * 6 ** (s / 1998))
 }
 
 export function computeBaseCapacityWarehouse(stats: bigint): number {
     const s = decodeStat(stats, 0) + decodeStat(stats, 2)
-    return Math.floor(100_000_000 * 6 ** (s / 1998))
+    return Math.floor(1_000_000 * 6 ** (s / 1998))
 }
 
 export function computeBaseCapacityWorkshop(stats: bigint): number {
     const s = decodeStat(stats, 0) + decodeStat(stats, 2)
-    return Math.floor(5_000_000 * 6 ** (s / 1998))
+    return Math.floor(50_000 * 6 ** (s / 1998))
 }
 
 export function computeBaseCapacityDepot(stats: bigint): number {
     const s = decodeStat(stats, 0) + decodeStat(stats, 2)
-    return Math.floor(50_000_000 * 6 ** (s / 1998))
+    return Math.floor(500_000 * 6 ** (s / 1998))
 }
 
 const CAPACITY_FN_BY_KIND: Record<string, (stats: bigint) => number> = {
@@ -131,7 +130,7 @@ export const computeGathererDrain = (con: number): number =>
     2 * Math.max(250_000, 1_250_000 - con * 1250)
 export const computeGathererDepth = (tol: number, tier: number): number =>
     gathererDepthForTier(tol, tier)
-export const computeLoaderMass = (ins: number): number => Math.max(200, 2000 - ins * 2)
+export const computeLoaderMass = (ins: number): number => Math.max(2, 20 - idiv(ins, 50))
 export const computeLoaderThrust = (pla: number, tier: number): number =>
     idiv((1 + idiv(pla * pla, 10000)) * moduleTierPct(LOADER_THRUST_TIER_PCT, tier), 100)
 export const computeCrafterSpeed = (rea: number, tier: number): number =>
@@ -164,7 +163,7 @@ export const computeCargoBayCapacity = (
     tier: number
 ): number =>
     idiv(
-        (10_000_000 + idiv((strength + density + hardness) * 50_000_000, 2997)) *
+        (100_000 + idiv((strength + density + hardness) * 500_000, 2997)) *
             moduleTierPct(CARGO_BAY_CAPACITY_TIER_PCT, tier),
         100
     )

package/src/planner/index.ts

@@ -3,6 +3,9 @@ import type {ServerContract} from '../contracts'
 import {calc_gather_duration, calc_gather_energy} from '../capabilities/gathering'
 import {calc_rechargetime} from '../travel/travel'
 import {projectRemainingAt, type Projectable} from '../scheduling/projection'
+import {selectGatherLane} from '../scheduling/lanes'
+
+export type GatherLane = ServerContract.Types.gatherer_lane
 
 export interface LanePlanEntry {
     slot: number
@@ -224,6 +227,57 @@ export function buildGatherPlan(
     }
 }
 
+export interface SingleGatherPlan {
+    laneKey: number
+    quantity: number
+    energyCost: number
+    needsRecharge: boolean
+}
+
+// None of these are PRECISION-scaled: stratum/itemMass/richness/energy fields are plain units, same as maxQtyForCharge/splitCost.
+export interface SingleGatherInput {
+    modules: ServerContract.Types.module_entry[]
+    entityItemId: number
+    lanes: ServerContract.Types.lane[]
+    gathererLanes: GatherLane[]
+    stratum: number
+    desiredQuantity: number
+    itemMass: number
+    richness: number
+    generatorCapacity: number
+    currentEnergy: number
+}
+
+export function planSingleGather(opts: SingleGatherInput): SingleGatherPlan {
+    const {
+        modules,
+        entityItemId,
+        lanes,
+        gathererLanes,
+        stratum,
+        desiredQuantity,
+        itemMass,
+        richness,
+        generatorCapacity,
+        currentEnergy,
+    } = opts
+
+    const laneKey = selectGatherLane(modules, entityItemId, lanes, stratum)
+    const lane = gathererLanes.find((l) => l.slot_index.toNumber() === laneKey - 1)
+    if (!lane) throw new Error('gatherer lane not found for selected slot')
+
+    const quantity = maxQtyForCharge(
+        [lane],
+        desiredQuantity,
+        generatorCapacity,
+        stratum,
+        itemMass,
+        richness
+    )
+    const energyCost = splitCost([lane], quantity, stratum, itemMass, richness)
+    return {laneKey, quantity, energyCost, needsRecharge: currentEnergy < energyCost}
+}
+
 export function planParallelTransfer(
     entity: GatherPlanEntity,
     target: PlanTarget