@shipload/sdk 1.0.0-next.60 → 1.0.0-next.62

package/src/derivation/crafting.ts

@@ -187,7 +187,7 @@ function legacyEntityIdToItemId(id: string): number {
         case 'warehouse-t1':
             return 10202
         case 'container-t2':
-            return 20200
+            return 11200
         default:
             return 0
     }

package/src/derivation/recipe-usage.test.ts

@@ -15,6 +15,7 @@ import {
     ITEM_CRAFTER_T1,
     ITEM_BUILDER_T1,
     ITEM_EXTRACTOR_T1_PACKED,
+    ITEM_WORKSHOP_T1_PACKED,
     ITEM_ROUSTABOUT_T1A_PACKED,
     ITEM_PROSPECTOR_T1A_PACKED,
     ITEM_TENDER_T1A_PACKED,
@@ -36,6 +37,7 @@ test('getRecipeConsumers lists every recipe that consumes Sensor', () => {
             ITEM_CRAFTER_T1,
             ITEM_BUILDER_T1,
             ITEM_EXTRACTOR_T1_PACKED,
+            ITEM_WORKSHOP_T1_PACKED,
             ITEM_ROUSTABOUT_T1A_PACKED,
         ].sort((a, b) => a - b)
     )

package/src/index-module.ts

@@ -51,6 +51,7 @@ export {
     computeFreeCells,
     NftManager,
     ConstructionManager,
+    JobsManager,
 } from './managers'
 export type {GridCell, ClusterCell, Cluster} from './managers'
 export type {
@@ -288,8 +289,15 @@ export type {
 export {taskCargoChanges} from './scheduling/task-cargo'
 export type {TaskCargoChange, TaskCargoDirection} from './scheduling/task-cargo'
 
-export {jobsToLanes, pickFabricator, socketTail, JOB_QUEUE_CAP} from './scheduling/jobs'
-export type {JobWindow, JobLane, JobLaneEntry} from './scheduling/jobs'
+export {
+    jobsToLanes,
+    pickFabricator,
+    socketTail,
+    JOB_QUEUE_CAP,
+    jobStatus,
+    splitJobCargo,
+} from './scheduling/jobs'
+export type {JobWindow, JobLane, JobLaneEntry, JobStatus, OwnedJob} from './scheduling/jobs'
 
 export {composeIdleResolve} from './scheduling/idle-resolve'
 export type {CounterpartLookup, IdleResolveTarget} from './scheduling/idle-resolve'

package/src/managers/context.ts

@@ -11,6 +11,7 @@ import {EpochsManager} from './epochs'
 import {ActionsManager} from './actions'
 import {ClusterManager} from './cluster'
 import {NftManager} from './nft'
+import {JobsManager} from './jobs'
 import {SubscriptionsManager} from '../subscriptions/manager'
 
 export class GameContext {
@@ -22,6 +23,7 @@ export class GameContext {
     private _actions?: ActionsManager
     private _clusters?: ClusterManager
     private _nft?: NftManager
+    private _jobs?: JobsManager
     private _subscriptions?: SubscriptionsManager
     private _subscriptionsUrl?: string
 
@@ -91,6 +93,13 @@ export class GameContext {
         return this._nft
     }
 
+    get jobs(): JobsManager {
+        if (!this._jobs) {
+            this._jobs = new JobsManager(this)
+        }
+        return this._jobs
+    }
+
     setSubscriptionsUrl(url: string) {
         this._subscriptionsUrl = url
     }

package/src/managers/index.ts

@@ -12,6 +12,7 @@ export {ClusterManager, computeFreeCells} from './cluster'
 export type {GridCell, ClusterCell, Cluster} from './cluster'
 export {NftManager} from './nft'
 export type {NftConfigForItem} from './nft'
+export {JobsManager} from './jobs'
 export {PlotManager} from './plot'
 export type {PlotProgress, PlotProgressInputRow} from './plot'
 export {ConstructionManager} from './construction'

package/src/managers/jobs.test.ts

@@ -0,0 +1,62 @@
+import {describe, expect, it} from 'bun:test'
+import {Name} from '@wharfkit/antelope'
+import {JobsManager} from './jobs'
+
+const OWNER = 'eggmaple.gm'
+const row = (over: Record<string, unknown> = {}) => ({
+    id: {toNumber: () => 7},
+    workshop: {toNumber: () => 42},
+    socket: {toNumber: () => 0},
+    owner: Name.from(OWNER),
+    ship_id: {toNumber: () => 100},
+    coords: {x: {toNumber: () => 12}, y: {toNumber: () => 34}},
+    starts_at: {toDate: () => new Date('2026-07-26T10:00:00Z')},
+    completes_at: {toDate: () => new Date('2026-07-26T11:00:00Z')},
+    recipe_id: {toNumber: () => 10001},
+    quantity: {toNumber: () => 5},
+    energy_paid: {toNumber: () => 0},
+    cargo: [{item: 'in'}, {item: 'out'}],
+    ...over,
+})
+
+function managerWith(queryImpl: () => Promise<unknown[]>, allImpl: () => Promise<unknown[]>) {
+    const table = () => ({query: () => ({all: queryImpl}), all: allImpl})
+    const ctx = {server: {table}} as never
+    return new JobsManager(ctx)
+}
+
+describe('JobsManager.getOwnedJobs', () => {
+    it('parses owner rows: output = last cargo, inputs = rest, status derived', async () => {
+        const m = managerWith(
+            async () => [row()],
+            async () => []
+        )
+        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].coords).toEqual({x: 12, y: 34})
+        expect(jobs[0].output).toEqual({item: 'out'} as never)
+        expect(jobs[0].inputs).toEqual([{item: 'in'}] as never)
+    })
+
+    it('drops rows whose owner does not match (positional-index safety re-filter)', async () => {
+        const other = row({owner: Name.from('someoneelse.gm')})
+        const m = managerWith(
+            async () => [row(), other],
+            async () => []
+        )
+        const jobs = await m.getOwnedJobs(OWNER)
+        expect(jobs).toHaveLength(1)
+    })
+
+    it('falls back to a full-scan .all() when the positional query throws', async () => {
+        const m = managerWith(
+            async () => {
+                throw new Error('bad index_position')
+            },
+            async () => [row()]
+        )
+        const jobs = await m.getOwnedJobs(OWNER)
+        expect(jobs).toHaveLength(1)
+    })
+})

package/src/managers/jobs.ts

@@ -0,0 +1,52 @@
+import {Name, type NameType} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import {jobStatus, splitJobCargo, type OwnedJob} from '../scheduling/jobs'
+import type {ServerContract} from '../contracts'
+
+type JobRow = ServerContract.Types.job_row
+
+export class JobsManager extends BaseManager {
+    async getOwnedJobs(owner: NameType, opts?: {now?: Date}): Promise<OwnedJob[]> {
+        const ownerName = Name.from(owner)
+        const now = opts?.now ?? new Date()
+
+        let rows: JobRow[]
+        try {
+            // index_position 'tertiary' = nodeos slot 3 = owner's secondary index; no ABI metadata for it.
+            rows = (await this.server
+                .table('jobs')
+                .query({
+                    index_position: 'tertiary',
+                    key_type: 'i64',
+                    from: ownerName.value,
+                    to: ownerName.value,
+                })
+                .all()) as JobRow[]
+        } catch {
+            rows = (await this.server.table('jobs').all()) as JobRow[]
+        }
+
+        return rows.filter((r) => ownerName.equals(r.owner)).map((r) => this.parseOwnedJob(r, now))
+    }
+
+    private parseOwnedJob(r: JobRow, now: Date): OwnedJob {
+        const startsAt = r.starts_at.toDate()
+        const completesAt = r.completes_at.toDate()
+        const {output, inputs} = splitJobCargo(r.cargo)
+        return {
+            id: r.id.toNumber(),
+            workshop: r.workshop.toNumber(),
+            socket: r.socket.toNumber(),
+            shipId: r.ship_id.toNumber(),
+            coords: {x: r.coords.x.toNumber(), y: r.coords.y.toNumber()},
+            startsAt,
+            completesAt,
+            recipeId: r.recipe_id.toNumber(),
+            quantity: r.quantity.toNumber(),
+            status: jobStatus({startsAt, completesAt}, now),
+            output,
+            inputs,
+            outputStats: output?.stats === undefined ? undefined : BigInt(output.stats.toString()),
+        }
+    }
+}

package/src/nft/buildImmutableData.ts

@@ -285,7 +285,7 @@ export function buildModuleImmutable(
             base.push({first: 'cohesion', second: ['uint16', com]})
             base.push({
                 first: 'capacity',
-                second: ['uint32', computeCargoBayCapacity(str, den, hrd)],
+                second: ['uint32', computeCargoBayCapacity(str, den, hrd, item.tier)],
             })
             base.push({
                 first: 'drain',
@@ -304,7 +304,10 @@ export function buildModuleImmutable(
             base.push({first: 'insulation', second: ['uint16', ins]})
             base.push({
                 first: 'capacity',
-                second: ['uint32', toWholeEnergy(computeBatteryBankCapacity(vol, thm, pla, ins))],
+                second: [
+                    'uint32',
+                    toWholeEnergy(computeBatteryBankCapacity(vol, thm, pla, ins, item.tier)),
+                ],
             })
             break
         }

package/src/nft/description.ts

@@ -11,44 +11,7 @@ import {
     MODULE_STORAGE,
     MODULE_WARP,
 } from '../capabilities/modules'
-import {
-    ITEM_CONTAINER_T1_PACKED,
-    ITEM_CONTAINER_T2_PACKED,
-    ITEM_CONSTRUCTION_DOCK_T1_PACKED,
-    ITEM_BUILDER_T1,
-    ITEM_BUILDER_T2,
-    ITEM_CRAFTER_T1,
-    ITEM_CRAFTER_T2,
-    ITEM_ENGINE_T1,
-    ITEM_ENGINE_T2,
-    ITEM_EXTRACTOR_T1_PACKED,
-    ITEM_FACTORY_T1_PACKED,
-    ITEM_GATHERER_T1,
-    ITEM_GATHERER_T2,
-    ITEM_GENERATOR_T1,
-    ITEM_GENERATOR_T2,
-    ITEM_HAULER_T1,
-    ITEM_HAULER_T2,
-    ITEM_BATTERY_T1,
-    ITEM_LAUNCHER_T1,
-    ITEM_LOADER_T1,
-    ITEM_LOADER_T2,
-    ITEM_PROSPECTOR_T1A_PACKED,
-    ITEM_PROSPECTOR_T2A_PACKED,
-    ITEM_PROSPECTOR_T2B_PACKED,
-    ITEM_ROUSTABOUT_T1A_PACKED,
-    ITEM_SHIP_T1_PACKED,
-    ITEM_SMITH_T1A_PACKED,
-    ITEM_STORAGE_T1,
-    ITEM_TENDER_T1A_PACKED,
-    ITEM_TUG_T1A_PACKED,
-    ITEM_PORTER_T1A_PACKED,
-    ITEM_WRIGHT_T1A_PACKED,
-    ITEM_DREDGER_T2A_PACKED,
-    ITEM_WAREHOUSE_T1_PACKED,
-    ITEM_WARP_T1,
-    ITEM_WARP_T2,
-} from '../data/item-ids'
+import {getKindMeta, getTemplateMeta} from '../data/kind-registry'
 import {decodeStat} from '../derivation/crafting'
 import {
     gathererDepthForTier,
@@ -61,8 +24,11 @@ import {
     BUILDER_SPEED_TIER_PCT,
     WARP_RANGE_TIER_PCT,
     LOADER_THRUST_TIER_PCT,
+    CARGO_BAY_CAPACITY_TIER_PCT,
+    BATTERY_CAPACITY_TIER_PCT,
 } from '../derivation/capabilities'
-import {getItem} from '../data/catalog'
+import {getItem, tryGetItem} from '../data/catalog'
+import type {ModuleType} from '../types'
 import {ENTITY_SHIP, getPackedEntityType} from '../data/kind-registry'
 import {getBaseHullmassFor} from '../derivation/capabilities'
 import {computeEffectiveModuleStat} from '../derivation/stat-scaling'
@@ -75,6 +41,11 @@ 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`
+}
+
 function isShipHull(itemId: number): boolean {
     return getPackedEntityType(itemId)?.equals(ENTITY_SHIP) ?? false
 }
@@ -109,6 +80,29 @@ export function computeBaseCapacityWarehouse(stats: bigint): number {
     return Math.floor(100_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))
+}
+
+const CAPACITY_FN_BY_KIND: Record<string, (stats: bigint) => number> = {
+    ship: computeBaseCapacityShip,
+    warehouse: computeBaseCapacityWarehouse,
+    workshop: computeBaseCapacityWorkshop,
+    extractor: computeBaseCapacityContainer,
+    factory: computeBaseCapacityContainer,
+    builddock: computeBaseCapacityContainer,
+    mdriver: computeBaseCapacityContainer,
+    mcatcher: computeBaseCapacityContainer,
+    container: computeBaseCapacityContainer,
+}
+
+export function computeBaseCapacityForEntity(itemId: number, stats: bigint): number {
+    const kind = getTemplateMeta(itemId)?.kind
+    if (!kind) return 0
+    return CAPACITY_FN_BY_KIND[kind.toString()]?.(stats) ?? 0
+}
+
 export const computeEngineThrust = (vol: number, tier: number): number =>
     idiv((400 + idiv(vol * 3, 4)) * moduleTierPct(ENGINE_THRUST_TIER_PCT, tier), 100)
 export const computeEngineDrain = (thm: number): number => 2 * Math.max(30, 50 - idiv(thm, 70))
@@ -159,91 +153,52 @@ export const computeWarpRange = (stat: number, tier: number): number =>
 export const computeCargoBayCapacity = (
     strength: number,
     density: number,
-    hardness: number
-): number => 10_000_000 + idiv((strength + density + hardness) * 50_000_000, 2997)
+    hardness: number,
+    tier: number
+): number =>
+    idiv(
+        (10_000_000 + idiv((strength + density + hardness) * 50_000_000, 2997)) *
+            moduleTierPct(CARGO_BAY_CAPACITY_TIER_PCT, tier),
+        100
+    )
 export const computeBatteryBankCapacity = (
     volatility: number,
     thermal: number,
     plasticity: number,
-    insulation: number
-): number => 2_500_000 + idiv((volatility + thermal + plasticity + insulation) * 7_500_000, 3996)
+    insulation: number,
+    tier: number
+): number =>
+    idiv(
+        (2_500_000 + idiv((volatility + thermal + plasticity + insulation) * 7_500_000, 3996)) *
+            moduleTierPct(BATTERY_CAPACITY_TIER_PCT, tier),
+        100
+    )
 
 export function entityDisplayName(itemId: number): string {
-    switch (itemId) {
-        case ITEM_SHIP_T1_PACKED:
-            return 'Ship'
-        case ITEM_ROUSTABOUT_T1A_PACKED:
-            return 'Roustabout'
-        case ITEM_PROSPECTOR_T1A_PACKED:
-            return 'Prospector'
-        case ITEM_TENDER_T1A_PACKED:
-            return 'Tender'
-        case ITEM_TUG_T1A_PACKED:
-            return 'Tug'
-        case ITEM_PORTER_T1A_PACKED:
-            return 'Porter'
-        case ITEM_WRIGHT_T1A_PACKED:
-            return 'Wright'
-        case ITEM_SMITH_T1A_PACKED:
-            return 'Smith'
-        case ITEM_WAREHOUSE_T1_PACKED:
-            return 'Warehouse'
-        case ITEM_EXTRACTOR_T1_PACKED:
-            return 'Mining Rig'
-        case ITEM_FACTORY_T1_PACKED:
-            return 'Factory'
-        case ITEM_CONSTRUCTION_DOCK_T1_PACKED:
-            return 'Construction Dock'
-        case ITEM_CONTAINER_T1_PACKED:
-            return 'Container'
-        case ITEM_CONTAINER_T2_PACKED:
-            return 'Container'
-        case ITEM_PROSPECTOR_T2A_PACKED:
-            return 'Prospector'
-        case ITEM_PROSPECTOR_T2B_PACKED:
-            return 'Prospector'
-        case ITEM_DREDGER_T2A_PACKED:
-            return 'Dredger'
-        default:
-            return 'Entity'
-    }
+    const template = getTemplateMeta(itemId)
+    if (!template) return 'Entity'
+    if (template.displayLabel) return template.displayLabel
+    return getKindMeta(template.kind)?.defaultLabel || 'Entity'
+}
+
+const MODULE_DISPLAY_NAME_BY_TYPE: Partial<Record<ModuleType, string>> = {
+    engine: 'Engine',
+    generator: 'Power Core',
+    gatherer: 'Limpet Bay',
+    loader: 'Shuttle Bay',
+    crafter: 'Fabricator',
+    storage: 'Cargo Hold',
+    hauler: 'Tractor Beam',
+    warp: 'Warp Drive',
+    battery: 'Battery Bank',
+    launcher: 'Drive Coil',
+    builder: 'Assembly Arm',
 }
 
 export function moduleDisplayName(itemId: number): string {
-    switch (itemId) {
-        case ITEM_ENGINE_T1:
-        case ITEM_ENGINE_T2:
-            return 'Engine'
-        case ITEM_GENERATOR_T1:
-        case ITEM_GENERATOR_T2:
-            return 'Power Core'
-        case ITEM_GATHERER_T1:
-        case ITEM_GATHERER_T2:
-            return 'Limpet Bay'
-        case ITEM_LOADER_T1:
-        case ITEM_LOADER_T2:
-            return 'Shuttle Bay'
-        case ITEM_CRAFTER_T1:
-        case ITEM_CRAFTER_T2:
-            return 'Fabricator'
-        case ITEM_BUILDER_T1:
-        case ITEM_BUILDER_T2:
-            return 'Assembly Arm'
-        case ITEM_STORAGE_T1:
-            return 'Cargo Hold'
-        case ITEM_HAULER_T1:
-        case ITEM_HAULER_T2:
-            return 'Tractor Beam'
-        case ITEM_WARP_T1:
-        case ITEM_WARP_T2:
-            return 'Warp Drive'
-        case ITEM_BATTERY_T1:
-            return 'Battery Bank'
-        case ITEM_LAUNCHER_T1:
-            return 'Drive Coil'
-        default:
-            return 'Module'
-    }
+    const item = tryGetItem(itemId)
+    if (item?.type !== 'module' || !item.moduleType) return 'Module'
+    return MODULE_DISPLAY_NAME_BY_TYPE[item.moduleType] ?? 'Module'
 }
 
 export function formatModuleLine(slot: number, itemId: number, stats: bigint): string {
@@ -288,7 +243,7 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             const fin = decodeStat(stats, 0)
             const pla = decodeStat(stats, 1)
             const tier = getItem(itemId).tier
-            out += `  Mass ${computeLoaderMass(fin)}  Thrust ${computeLoaderThrust(pla, tier)}`
+            out += `  Mass ${formatMassTonnes(computeLoaderMass(fin))}  Thrust ${computeLoaderThrust(pla, tier)}`
             break
         }
         case MODULE_CRAFTER: {
@@ -311,7 +266,7 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             const hrd = decodeStat(stats, 2)
             const coh = decodeStat(stats, 3)
             const tier = getItem(itemId).tier
-            out += `  Cargo Capacity ${computeCargoBayCapacity(str, den, hrd)}  Drain ${toWholeEnergy(computeCargoBayDrain(coh, tier))}`
+            out += `  Cargo Capacity ${formatMassTonnes(computeCargoBayCapacity(str, den, hrd, tier))}  Drain ${toWholeEnergy(computeCargoBayDrain(coh, tier))}`
             break
         }
         case MODULE_HAULER: {
@@ -333,7 +288,8 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             const thm = decodeStat(stats, 1)
             const pla = decodeStat(stats, 2)
             const ins = decodeStat(stats, 3)
-            out += `  Energy Capacity ${toWholeEnergy(computeBatteryBankCapacity(vol, thm, pla, ins))}`
+            const tier = getItem(itemId).tier
+            out += `  Energy Capacity ${toWholeEnergy(computeBatteryBankCapacity(vol, thm, pla, ins, tier))}`
             break
         }
     }
@@ -347,25 +303,12 @@ export function buildEntityDescription(
     moduleStats: bigint[]
 ): string {
     const hullMass = computeBaseHullmass(itemId, hullStats)
-    let baseCapacity = 0
-    if (isShipHull(itemId)) {
-        baseCapacity = computeBaseCapacityShip(hullStats)
-    } else if (itemId === ITEM_WAREHOUSE_T1_PACKED) {
-        baseCapacity = computeBaseCapacityWarehouse(hullStats)
-    } else if (
-        itemId === ITEM_EXTRACTOR_T1_PACKED ||
-        itemId === ITEM_FACTORY_T1_PACKED ||
-        itemId === ITEM_CONSTRUCTION_DOCK_T1_PACKED ||
-        itemId === ITEM_CONTAINER_T1_PACKED ||
-        itemId === ITEM_CONTAINER_T2_PACKED
-    ) {
-        baseCapacity = computeBaseCapacityContainer(hullStats)
-    }
+    const baseCapacity = computeBaseCapacityForEntity(itemId, hullStats)
 
     let out = entityDisplayName(itemId)
-    out += ` - Hull ${hullMass} mass`
+    out += ` - Hull ${formatMassTonnes(hullMass)}`
     if (baseCapacity > 0) {
-        out += ` * ${baseCapacity} capacity`
+        out += ` * ${formatMassTonnes(baseCapacity)} capacity`
     }
     out += '\n\n'
 

package/src/resolution/resolve-item.ts

@@ -247,7 +247,7 @@ function computeCapabilityGroup(
             }
         }
         case MODULE_BATTERY: {
-            const caps = computeBatteryCapabilities(stats)
+            const caps = computeBatteryCapabilities(stats, tier)
             return {
                 capability: 'Energy',
                 attributes: [

package/src/scheduling/jobs.test.ts

@@ -0,0 +1,32 @@
+import {describe, expect, it} from 'bun:test'
+import {jobStatus, splitJobCargo} from './jobs'
+
+const at = (s: string) => new Date(s)
+
+describe('jobStatus', () => {
+    const job = {startsAt: at('2026-07-26T10:00:00Z'), completesAt: at('2026-07-26T11:00:00Z')}
+    it('is waiting before startsAt', () => {
+        expect(jobStatus(job, at('2026-07-26T09:59:59Z'))).toBe('waiting')
+    })
+    it('is crafting between startsAt and completesAt', () => {
+        expect(jobStatus(job, at('2026-07-26T10:30:00Z'))).toBe('crafting')
+    })
+    it('is ready at or after completesAt', () => {
+        expect(jobStatus(job, at('2026-07-26T11:00:00Z'))).toBe('ready')
+        expect(jobStatus(job, at('2026-07-26T12:00:00Z'))).toBe('ready')
+    })
+})
+
+describe('splitJobCargo', () => {
+    it('takes the last element as output, the rest as inputs', () => {
+        const cargo = [{n: 'a'}, {n: 'b'}, {n: 'out'}] as unknown as Parameters<
+            typeof splitJobCargo
+        >[0]
+        const {output, inputs} = splitJobCargo(cargo)
+        expect(output).toEqual({n: 'out'} as never)
+        expect(inputs).toEqual([{n: 'a'}, {n: 'b'}] as never)
+    })
+    it('returns null output for empty cargo', () => {
+        expect(splitJobCargo([])).toEqual({output: null, inputs: []})
+    })
+})

package/src/scheduling/jobs.ts

@@ -1,3 +1,7 @@
+import type {ServerContract} from '../contracts'
+
+type CargoItem = ServerContract.Types.cargo_item
+
 export interface JobWindow {
     id: number
     socket: number
@@ -6,6 +10,8 @@ export interface JobWindow {
     completesAt: Date
     recipeId: number
     quantity: number
+    /** Packed stat roll of the job's output, when the source carried the job's cargo. */
+    outputStats?: bigint
 }
 
 export interface JobLaneEntry {
@@ -69,3 +75,34 @@ export function pickFabricator(
     }
     return best
 }
+
+export type JobStatus = 'waiting' | 'crafting' | 'ready'
+
+export function jobStatus(job: {startsAt: Date; completesAt: Date}, now: Date): JobStatus {
+    if (now < job.startsAt) return 'waiting'
+    if (now < job.completesAt) return 'crafting'
+    return 'ready'
+}
+
+// Generic in the element so raw chain JSON (readonly actions) splits by the same rule as decoded rows.
+export function splitJobCargo<T>(cargo: readonly T[]): {output: T | null; inputs: T[]} {
+    if (cargo.length === 0) return {output: null, inputs: []}
+    return {output: cargo[cargo.length - 1], inputs: cargo.slice(0, -1)}
+}
+
+export interface OwnedJob {
+    id: number
+    workshop: number
+    socket: number
+    shipId: number
+    coords: {x: number; y: number}
+    startsAt: Date
+    completesAt: Date
+    recipeId: number
+    quantity: number
+    status: JobStatus
+    output: CargoItem | null
+    inputs: CargoItem[]
+    /** Packed stat roll of `output`, so every job shape answers this the same way. */
+    outputStats?: bigint
+}

package/src/shipload.ts

@@ -12,6 +12,7 @@ import type {EpochsManager} from './managers/epochs'
 import type {ActionsManager} from './managers/actions'
 import type {ClusterManager} from './managers/cluster'
 import type {NftManager} from './managers/nft'
+import type {JobsManager} from './managers/jobs'
 import type {SubscriptionsManager} from './subscriptions/manager'
 import type {GameState} from './entities/gamestate'
 
@@ -132,6 +133,10 @@ export class Shipload {
         return this._context.nft
     }
 
+    get jobs(): JobsManager {
+        return this._context.jobs
+    }
+
     get subscriptions(): SubscriptionsManager {
         return this._context.subscriptions
     }