@shipload/sdk 1.0.0-next.61 → 1.0.0-next.63

package/src/influence/charters.test.ts

@@ -0,0 +1,126 @@
+import {describe, expect, test} from 'bun:test'
+import {CHARTER_NONE} from './constants'
+import {
+    charterEligible,
+    charterIneligible,
+    charterNode,
+    charterSingletonMandate,
+    charterSpawnNodeFor,
+    effectiveMandate,
+    eligibleCharters,
+    type BuiltCharter,
+    type CharterWorld,
+} from './charters'
+
+const WORKSHOP = 1
+const NEXUS = 2
+const DOCK = 3
+const WORKSHOP_TUNEUP = 4
+const DOCK_TUNEUP = 5
+const DEPOT = 6
+
+const WORKSHOP_ENTITY = 100n
+const DOCK_ENTITY = 300n
+const DEPOT_ENTITY = 600n
+
+function world(built: BuiltCharter[], present?: bigint[]): CharterWorld {
+    if (!present) return {built}
+    return {built, entityExists: (id) => present.includes(id)}
+}
+
+function node(nodeId: number) {
+    const found = charterNode(nodeId)
+    if (!found) throw new Error(`registry is missing node ${nodeId}`)
+    return found
+}
+
+function eligibleIds(w: CharterWorld): number[] {
+    return eligibleCharters(w).map((n) => n.nodeId)
+}
+
+describe('charter eligibility mirror', () => {
+    test('an unbuilt world offers only the root', () => {
+        expect(eligibleIds(world([]))).toEqual([WORKSHOP])
+    })
+
+    test('the root is the mandate by the singleton rule with no ballot', () => {
+        expect(charterSingletonMandate(world([]))).toBe(WORKSHOP)
+    })
+
+    test('completing the root opens the fork and closes the singleton path', () => {
+        const built = world([{nodeId: WORKSHOP, entityId: WORKSHOP_ENTITY}])
+        expect(eligibleIds(built)).toEqual([NEXUS, DOCK, WORKSHOP_TUNEUP, DEPOT])
+        expect(charterSingletonMandate(built)).toBe(CHARTER_NONE)
+    })
+
+    test('a completed charter reports already-taken', () => {
+        const built = world([{nodeId: WORKSHOP, entityId: WORKSHOP_ENTITY}])
+        expect(charterIneligible(built, node(WORKSHOP))).toBe('already-taken')
+    })
+
+    test('an unmet prereq reports prereq-missing', () => {
+        expect(charterIneligible(world([]), node(NEXUS))).toBe('prereq-missing')
+        expect(charterIneligible(world([]), node(DOCK_TUNEUP))).toBe('prereq-missing')
+    })
+
+    test('a refit whose spawned target is gone reports refit-target-missing', () => {
+        const built = [{nodeId: WORKSHOP, entityId: WORKSHOP_ENTITY}]
+        expect(charterEligible(world(built, [WORKSHOP_ENTITY]), node(WORKSHOP_TUNEUP))).toBe(true)
+        expect(charterIneligible(world(built, []), node(WORKSHOP_TUNEUP))).toBe(
+            'refit-target-missing'
+        )
+    })
+
+    test('a demolished target can empty an otherwise singleton eligible set', () => {
+        const built = [
+            {nodeId: WORKSHOP, entityId: WORKSHOP_ENTITY},
+            {nodeId: NEXUS, entityId: 200n},
+            {nodeId: DOCK, entityId: DOCK_ENTITY},
+            {nodeId: DOCK_TUNEUP, entityId: 0n},
+            {nodeId: DEPOT, entityId: DEPOT_ENTITY},
+        ]
+        expect(charterSingletonMandate(world(built, [WORKSHOP_ENTITY, DOCK_ENTITY]))).toBe(
+            WORKSHOP_TUNEUP
+        )
+        expect(charterSingletonMandate(world(built, [DOCK_ENTITY]))).toBe(CHARTER_NONE)
+    })
+
+    test('an absent entity predicate trusts the charter record', () => {
+        const built = world([{nodeId: WORKSHOP, entityId: WORKSHOP_ENTITY}])
+        expect(charterEligible(built, node(WORKSHOP_TUNEUP))).toBe(true)
+    })
+
+    test('refit targets resolve through the node that spawns the item', () => {
+        expect(charterSpawnNodeFor(node(WORKSHOP_TUNEUP).effect.targetItemId)?.nodeId).toBe(
+            WORKSHOP
+        )
+        expect(charterSpawnNodeFor(node(DOCK_TUNEUP).effect.targetItemId)?.nodeId).toBe(DOCK)
+        expect(charterSpawnNodeFor(0)).toBeUndefined()
+    })
+})
+
+describe('effective mandate', () => {
+    const forked = world([{nodeId: WORKSHOP, entityId: WORKSHOP_ENTITY}])
+
+    test('a stored choice holds inside its own epoch', () => {
+        expect(effectiveMandate({chosen: DOCK, chosenEpoch: 7}, forked, 7)).toBe(DOCK)
+    })
+
+    test('the same stored choice expires one epoch later', () => {
+        expect(effectiveMandate({chosen: DOCK, chosenEpoch: 7}, forked, 8)).toBe(CHARTER_NONE)
+    })
+
+    test('an expired choice falls through to the singleton rule', () => {
+        const unbuilt = world([])
+        expect(effectiveMandate({chosen: NEXUS, chosenEpoch: 7}, unbuilt, 8)).toBe(WORKSHOP)
+    })
+
+    test('a cleared pair reads the singleton rule', () => {
+        expect(effectiveMandate({chosen: CHARTER_NONE, chosenEpoch: 0}, world([]), 3)).toBe(
+            WORKSHOP
+        )
+        expect(effectiveMandate({chosen: CHARTER_NONE, chosenEpoch: 0}, forked, 3)).toBe(
+            CHARTER_NONE
+        )
+    })
+})

package/src/influence/charters.ts

@@ -0,0 +1,120 @@
+import chartersJson from '../data/charters.json'
+import {CHARTER_EFFECT_REFIT_MODULES, CHARTER_EFFECT_SPAWN_ENTITY, CHARTER_NONE} from './constants'
+
+export interface CharterEffect {
+    kind: number
+    itemId: number
+    targetItemId: number
+    slotMask: number
+    stat: number
+}
+
+export interface CharterNode {
+    nodeId: number
+    cost: bigint
+    prereqs: number[]
+    effect: CharterEffect
+}
+
+export const CHARTER_REGISTRY: CharterNode[] = chartersJson.nodes.map((node) => ({
+    nodeId: node.nodeId,
+    cost: BigInt(node.cost),
+    prereqs: [...node.prereqs],
+    effect: {...node.effect},
+}))
+
+export function charterNode(nodeId: number): CharterNode | undefined {
+    if (nodeId === CHARTER_NONE) return undefined
+    return CHARTER_REGISTRY.find((n) => n.nodeId === nodeId)
+}
+
+export type CharterIneligibility = 'already-taken' | 'prereq-missing' | 'refit-target-missing'
+
+export const CHARTER_INELIGIBILITY_MESSAGES: Record<CharterIneligibility, string> = {
+    'already-taken': 'charter is already completed at this world',
+    'prereq-missing': 'charter prerequisites are not completed',
+    'refit-target-missing': 'charter refit target not found at this world',
+}
+
+export interface BuiltCharter {
+    nodeId: number
+    entityId: bigint
+}
+
+export interface CharterWorld {
+    built: BuiltCharter[]
+    entityExists?: (entityId: bigint) => boolean
+}
+
+export interface ChosenCharter {
+    chosen: number
+    chosenEpoch: number
+}
+
+function builtCharter(world: CharterWorld, nodeId: number): BuiltCharter | undefined {
+    return world.built.find((row) => row.nodeId === nodeId)
+}
+
+export function charterSpawnNodeFor(targetItemId: number): CharterNode | undefined {
+    return CHARTER_REGISTRY.find(
+        (node) =>
+            node.effect.kind === CHARTER_EFFECT_SPAWN_ENTITY && node.effect.itemId === targetItemId
+    )
+}
+
+export function charterPrereqsMet(world: CharterWorld, node: CharterNode): boolean {
+    return node.prereqs.every(
+        (prereq) => prereq === CHARTER_NONE || builtCharter(world, prereq) !== undefined
+    )
+}
+
+export function charterEffectTargetEntity(world: CharterWorld, node: CharterNode): bigint {
+    const spawn = charterSpawnNodeFor(node.effect.targetItemId)
+    if (!spawn) return 0n
+    const record = builtCharter(world, spawn.nodeId)
+    if (!record) return 0n
+    if (world.entityExists && !world.entityExists(record.entityId)) return 0n
+    return record.entityId
+}
+
+export function charterEffectTargetPresent(world: CharterWorld, node: CharterNode): boolean {
+    if (node.effect.kind !== CHARTER_EFFECT_REFIT_MODULES) return true
+    return charterEffectTargetEntity(world, node) !== 0n
+}
+
+export function charterIneligible(
+    world: CharterWorld,
+    node: CharterNode
+): CharterIneligibility | undefined {
+    if (builtCharter(world, node.nodeId) !== undefined) return 'already-taken'
+    if (!charterPrereqsMet(world, node)) return 'prereq-missing'
+    if (!charterEffectTargetPresent(world, node)) return 'refit-target-missing'
+    return undefined
+}
+
+export function charterEligible(world: CharterWorld, node: CharterNode): boolean {
+    return charterIneligible(world, node) === undefined
+}
+
+export function eligibleCharters(world: CharterWorld): CharterNode[] {
+    return CHARTER_REGISTRY.filter((node) => charterEligible(world, node))
+}
+
+export function charterSingletonMandate(world: CharterWorld): number {
+    let only = CHARTER_NONE
+    for (const node of CHARTER_REGISTRY) {
+        if (!charterEligible(world, node)) continue
+        if (only !== CHARTER_NONE) return CHARTER_NONE
+        only = node.nodeId
+    }
+    return only
+}
+
+export function effectiveMandate(
+    stored: ChosenCharter,
+    world: CharterWorld,
+    epoch: number
+): number {
+    if (stored.chosen !== CHARTER_NONE && stored.chosenEpoch === epoch) return stored.chosen
+    return charterSingletonMandate(world)
+}

package/src/influence/citizenry.ts

@@ -0,0 +1,31 @@
+import {Checksum256, type Checksum256Type} from '@wharfkit/antelope'
+import {Coordinates, type CoordinatesType, LocationType} from '../types'
+import {hash512} from '../utils/hash'
+import {deriveLocationStatic, getSystemName} from '../utils/system'
+
+const CITIZENRY_PATTERNS: ((world: string) => string)[] = [
+    (w) => `${w} Collective`,
+    (w) => `${w} Compact`,
+    (w) => `Concord of ${w}`,
+    (w) => `${w} Union`,
+]
+
+export function citizenryName(
+    gameSeed: Checksum256Type,
+    coordinates: CoordinatesType
+): string | undefined {
+    const coords = Coordinates.from(coordinates)
+    const location = deriveLocationStatic(gameSeed, coords)
+    if (Number(location.type) !== LocationType.PLANET) return undefined
+
+    const world = getSystemName(gameSeed, coords)
+    const roll = hash512(
+        Checksum256.from(gameSeed),
+        `citizenry-${coords.x.toString()}-${coords.y.toString()}`
+    ).array[0]
+    return CITIZENRY_PATTERNS[roll % CITIZENRY_PATTERNS.length](world)
+}
+
+export function citizenryPatternCount(): number {
+    return CITIZENRY_PATTERNS.length
+}

package/src/influence/constants.ts

@@ -0,0 +1,63 @@
+export const INFLUENCE_ATOMIC_PER_POINT = 10_000
+export const NEED_FP_SCALE = 10_000
+export const WEIGHT_FP_SCALE = 10_000
+export const MASS_KG_PER_TONNE = 1_000
+
+export const INFLUENCE_WEIGHT_FP_MAX = 1_000_000n
+export const INFLUENCE_NEED_FP_MAX = 1_000_000n
+export const INFLUENCE_MASS_KG_MAX = 1n << 48n
+
+export const DECAY_RETAIN_NUM = 19n
+export const DECAY_RETAIN_DEN = 20n
+export const DECAY_MAX_ITERATIONS = 1_024
+
+export const W_EFF_ATOMIC_PER_KG = BigInt(INFLUENCE_ATOMIC_PER_POINT / MASS_KG_PER_TONNE)
+
+export const DECOMP_MAX_BUCKETS = 12
+export const DECOMP_MAX_DEPTH = 8
+export const DECOMP_RAW_KG_MAX = 100_000_000
+export const DECOMP_PROCESSED_KG_MAX = 100_000_000
+
+export const RESOURCE_ORE = 0
+export const RESOURCE_GAS = 1
+export const RESOURCE_REGOLITH = 2
+export const RESOURCE_BIOMASS = 3
+export const RESOURCE_CRYSTAL = 4
+export const RESOURCE_CATEGORY_COUNT = 5
+
+export const CIVIC_LOADER_STAT = 213
+export const CIVIC_LOADER_TIER = 1
+export const DEFAULT_ORBITAL_Z = 800
+
+export const GRADE_STANDARD = 0
+export const GRADE_PREMIUM = 1
+export const MINTREADY_DEFAULT_CAP = 10
+
+export const BAR_SEED = 102_363
+export const BAR_STEP_UNIT = 20
+export const BAR_STEP_UP = BAR_STEP_UNIT * 9
+export const BAR_STEP_DOWN = BAR_STEP_UNIT
+
+export const CHARTER_NONE = 0
+export const CHARTER_WORKSHOP = 1
+export const CHARTER_EFFECT_SPAWN_ENTITY = 1
+export const CHARTER_EFFECT_REFIT_MODULES = 2
+export const VOTE_READY_DEFAULT_MAX = 20
+export const CHARTER_WORKSHOP_COST = 2_000_000_000n
+export const CHARTER_BASELINE_STAT = 213
+export const CHARTER_MAX_PREREQS = 4
+
+export const INFLUENCE_D1_SEED = 45_369
+export const DEMAND_TRIPLE_SEED = {peak: 20_000n, base: 10_000n, floor: 1_000n}
+
+export function poolKey(category: number, tier: number, grade: number): bigint {
+    return (BigInt(category) << 16n) | (BigInt(tier) << 8n) | BigInt(grade)
+}
+
+export function influenceWeightKey(category: number, tier: number): bigint {
+    return (BigInt(category) << 8n) | BigInt(tier)
+}
+
+export function atomicToPoints(atomic: bigint | number | string): number {
+    return Math.floor(Number(BigInt(atomic.toString())) / INFLUENCE_ATOMIC_PER_POINT)
+}

package/src/influence/decay.ts

@@ -0,0 +1,20 @@
+import {DECAY_MAX_ITERATIONS, DECAY_RETAIN_DEN, DECAY_RETAIN_NUM} from './constants'
+
+export function decayActive(active: bigint, epochsElapsed: number): bigint {
+    const iterations = epochsElapsed > DECAY_MAX_ITERATIONS ? DECAY_MAX_ITERATIONS : epochsElapsed
+    let value = active
+    for (let i = 0; i < iterations && value > 0n; i++) {
+        value = (value * DECAY_RETAIN_NUM) / DECAY_RETAIN_DEN
+    }
+    return value
+}
+
+export interface DecayableStanding {
+    active: bigint
+    lastUpdateEpoch: number
+}
+
+export function normalizeActive(standing: DecayableStanding, epoch: number): bigint {
+    const elapsed = epoch > standing.lastUpdateEpoch ? epoch - standing.lastUpdateEpoch : 0
+    return decayActive(standing.active, elapsed)
+}

package/src/influence/decomp.ts

@@ -0,0 +1,95 @@
+import {tryGetItem} from '../data/catalog'
+import {getRecipe} from '../data/recipes-runtime'
+import recipes from '../data/recipes.json'
+import {
+    DECOMP_MAX_BUCKETS,
+    DECOMP_MAX_DEPTH,
+    DECOMP_PROCESSED_KG_MAX,
+    DECOMP_RAW_KG_MAX,
+} from './constants'
+import {categoryIndex} from './categories'
+
+export interface DecompBucket {
+    category: number
+    tier: number
+    rawKg: number
+}
+
+export interface DecompEntry {
+    itemId: number
+    processedKg: number
+    buckets: DecompBucket[]
+}
+
+interface Accumulator {
+    buckets: DecompBucket[]
+    processedKg: number
+    overflow: boolean
+}
+
+function add(acc: Accumulator, category: number, tier: number, kg: number): void {
+    const existing = acc.buckets.find((b) => b.category === category && b.tier === tier)
+    if (existing) {
+        existing.rawKg += kg
+        return
+    }
+    if (acc.buckets.length >= DECOMP_MAX_BUCKETS) {
+        acc.overflow = true
+        return
+    }
+    acc.buckets.push({category, tier, rawKg: kg})
+}
+
+function walk(itemId: number, multiplier: number, acc: Accumulator, depth: number): void {
+    if (depth > DECOMP_MAX_DEPTH) {
+        acc.overflow = true
+        return
+    }
+    const recipe = getRecipe(itemId)
+    if (!recipe) return
+
+    for (const input of recipe.inputs) {
+        const def = tryGetItem(input.itemId)
+        const units = multiplier * input.quantity
+        const kg = units * (def ? def.mass : 0)
+        acc.processedKg += kg
+        if (getRecipe(input.itemId)) {
+            walk(input.itemId, units, acc, depth + 1)
+        } else if (def?.type !== 'resource' || def.category === undefined) {
+            acc.overflow = true
+        } else {
+            add(acc, categoryIndex(def.category), def.tier, kg)
+        }
+    }
+}
+
+function buildRegistry(): DecompEntry[] {
+    const out: DecompEntry[] = []
+    for (const recipe of recipes as {outputItemId: number}[]) {
+        const acc: Accumulator = {buckets: [], processedKg: 0, overflow: false}
+        walk(recipe.outputItemId, 1, acc, 0)
+        acc.buckets.sort((a, b) => a.category - b.category || a.tier - b.tier)
+
+        const rawTotal = acc.buckets.reduce((sum, b) => sum + b.rawKg, 0)
+        if (rawTotal > DECOMP_RAW_KG_MAX || acc.processedKg > DECOMP_PROCESSED_KG_MAX) {
+            acc.overflow = true
+        }
+
+        out.push({
+            itemId: recipe.outputItemId,
+            processedKg: acc.overflow ? 0 : acc.processedKg,
+            buckets: acc.buckets,
+        })
+    }
+    out.sort((a, b) => a.itemId - b.itemId)
+    return out
+}
+
+export const DECOMP_REGISTRY: DecompEntry[] = buildRegistry()
+
+const byItemId = new Map<number, DecompEntry>()
+for (const entry of DECOMP_REGISTRY) byItemId.set(entry.itemId, entry)
+
+export function findDecomp(itemId: number): DecompEntry | undefined {
+    return byItemId.get(itemId)
+}

package/src/influence/demand.ts

@@ -0,0 +1,106 @@
+import {Checksum256, type Checksum256Type, type Checksum512} from '@wharfkit/antelope'
+import {getLocationProfile} from '../derivation/resources'
+import {Coordinates, type CoordinatesType} from '../types'
+import {hash512} from '../utils/hash'
+import {deriveLocationStatic} from '../utils/system'
+import {RESOURCE_CATEGORY_COUNT} from './constants'
+
+export interface DemandTriple {
+    peak: bigint
+    base: bigint
+    floor: bigint
+}
+
+export interface DemandView {
+    abundantMask: number
+    lackingMask: number
+    acute: number
+    needFp: bigint[]
+}
+
+const ALL_CATEGORIES_MASK = 0x1f
+
+export function abundantMaskFor(locationType: number, subtype: number): number {
+    let mask = 0
+    for (const entry of getLocationProfile(locationType, subtype)) {
+        mask |= 1 << entry.category
+    }
+    return mask
+}
+
+export function lackingMaskFrom(abundantMask: number): number {
+    return ~abundantMask & ALL_CATEGORIES_MASK
+}
+
+export function popcount5(mask: number): number {
+    let n = 0
+    for (let i = 0; i < RESOURCE_CATEGORY_COUNT; i++) if (mask & (1 << i)) n++
+    return n
+}
+
+export function pickAcuteCategory(lackingMask: number, roll: number): number {
+    const count = popcount5(lackingMask)
+    if (count === 0) throw new Error('location has no lacking category')
+    let index = roll % count
+    for (let c = 0; c < RESOURCE_CATEGORY_COUNT; c++) {
+        if ((lackingMask & (1 << c)) === 0) continue
+        if (index === 0) return c
+        index--
+    }
+    throw new Error('acute pick fell through')
+}
+
+export function demandRoll(hash: Checksum512): number {
+    const bytes = hash.array
+    return ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0
+}
+
+export function buildDemand(abundantMask: number, acute: number, triple: DemandTriple): DemandView {
+    const lackingMask = lackingMaskFrom(abundantMask)
+    const needFp: bigint[] = []
+    for (let c = 0; c < RESOURCE_CATEGORY_COUNT; c++) {
+        if (c === acute) needFp.push(triple.peak)
+        else if (lackingMask & (1 << c)) needFp.push(triple.base)
+        else needFp.push(triple.floor)
+    }
+    return {abundantMask, lackingMask, acute, needFp}
+}
+
+export function needForCategory(demand: DemandView, category: number): bigint {
+    if (category < 0 || category >= RESOURCE_CATEGORY_COUNT) {
+        throw new Error('invalid category')
+    }
+    return demand.needFp[category]
+}
+
+// Two distinct seeds: composition from the genesis game seed, acute rotation from the epoch seed.
+export function deriveDemand(args: {
+    gameSeed: Checksum256Type
+    epochSeed: Checksum256Type
+    coordinates: CoordinatesType
+    triple: DemandTriple
+}): DemandView {
+    const coords = Coordinates.from(args.coordinates)
+    const location = deriveLocationStatic(args.gameSeed, coords)
+    const abundant = abundantMaskFor(Number(location.type), Number(location.subtype))
+    if (abundant === 0) throw new Error('location has no composition')
+
+    const hash = hash512(
+        Checksum256.from(args.epochSeed),
+        `demand-${coords.x.toString()}-${coords.y.toString()}`
+    )
+    const acute = pickAcuteCategory(lackingMaskFrom(abundant), demandRoll(hash))
+    return buildDemand(abundant, acute, args.triple)
+}
+
+export function isAbundant(demand: DemandView, category: number): boolean {
+    return (demand.abundantMask & (1 << category)) !== 0
+}
+
+export function isAcute(demand: DemandView, category: number): boolean {
+    return demand.acute === category
+}
+
+export function needMultiplier(demand: DemandView, category: number): number {
+    return Number(needForCategory(demand, category)) / 10_000
+}

package/src/influence/duration.ts

@@ -0,0 +1,36 @@
+import {computeLoaderMass, computeLoaderThrust} from '../nft/description'
+import {PRECISION} from '../types'
+import {CIVIC_LOADER_STAT, CIVIC_LOADER_TIER, DEFAULT_ORBITAL_Z} from './constants'
+
+export interface CivicLoaderStats {
+    thrust: number
+    mass: number
+}
+
+export function civicLoader(): CivicLoaderStats {
+    return {
+        thrust: Math.min(computeLoaderThrust(CIVIC_LOADER_STAT, CIVIC_LOADER_TIER), 65_535),
+        mass: computeLoaderMass(CIVIC_LOADER_STAT),
+    }
+}
+
+function acceleration(thrust: number, mass: number): number {
+    if (mass <= 0) return 0
+    return (thrust / mass) * PRECISION
+}
+
+function flightTime(distance: number, accel: number): number {
+    if (accel <= 0 || distance <= 0) return 0
+    return Math.floor(2 * Math.sqrt(distance / accel))
+}
+
+export function contributeDuration(totalMassKg: number, altitudeZ = 0): number {
+    const loader = civicLoader()
+    const totalMass = totalMassKg + loader.mass
+    const z = Math.max(altitudeZ, DEFAULT_ORBITAL_Z)
+    return flightTime(z, acceleration(loader.thrust, totalMass))
+}
+
+export function contributeDurationForTonnes(tonnes: number, altitudeZ = 0): number {
+    return contributeDuration(Math.floor(tonnes * 1000), altitudeZ)
+}

package/src/influence/index.ts

@@ -0,0 +1,63 @@
+export * from './constants'
+export * from './categories'
+export {decayActive, normalizeActive, type DecayableStanding} from './decay'
+export {getStatCount, statsSumSq, qualityFactor} from './quality'
+export {
+    DECOMP_REGISTRY,
+    findDecomp,
+    type DecompBucket,
+    type DecompEntry,
+} from './decomp'
+export {
+    abundantMaskFor,
+    buildDemand,
+    demandRoll,
+    deriveDemand,
+    isAbundant,
+    isAcute,
+    lackingMaskFrom,
+    needForCategory,
+    needMultiplier,
+    pickAcuteCategory,
+    popcount5,
+    type DemandTriple,
+    type DemandView,
+} from './demand'
+export {
+    componentBaseAtomic,
+    componentEffortAtomic,
+    pricingFromWeights,
+    resourceValueAtomic,
+    valueCargoItem,
+    valueContribution,
+    weightedQualityAtomic,
+    type InfluencePricing,
+    type ValuedItem,
+} from './valuation'
+export {
+    civicLoader,
+    contributeDuration,
+    contributeDurationForTonnes,
+    type CivicLoaderStats,
+} from './duration'
+export {citizenryName, citizenryPatternCount} from './citizenry'
+export {
+    charterEffectTargetEntity,
+    charterEffectTargetPresent,
+    charterEligible,
+    charterIneligible,
+    charterNode,
+    charterPrereqsMet,
+    charterSingletonMandate,
+    charterSpawnNodeFor,
+    CHARTER_INELIGIBILITY_MESSAGES,
+    CHARTER_REGISTRY,
+    effectiveMandate,
+    eligibleCharters,
+    type BuiltCharter,
+    type CharterEffect,
+    type CharterIneligibility,
+    type CharterNode,
+    type CharterWorld,
+    type ChosenCharter,
+} from './charters'