@shipload/sdk 1.0.0-next.52 → 1.0.0-next.54

package/src/entities/entity.ts

@@ -31,6 +31,10 @@ export class Entity extends ServerContract.Types.entity_info {
         return schedule.isIdle(this)
     }
 
+    get hasPendingCapper(): boolean {
+        return schedule.hasPendingCapper(this)
+    }
+
     get sched(): ScheduleAccessor {
         this._sched ??= new ScheduleAccessor(this)
         return this._sched

package/src/nft/buildImmutableData.ts

@@ -263,12 +263,12 @@ export function buildModuleImmutable(
             break
         }
         case MODULE_BUILDER: {
-            const coh = decodeStat(stats, 0)
-            const tol = decodeStat(stats, 1)
-            base.push({first: 'cohesion', second: ['uint16', coh]})
-            base.push({first: 'tolerance', second: ['uint16', tol]})
-            base.push({first: 'speed', second: ['uint16', computeBuilderSpeed(coh)]})
-            base.push({first: 'drain', second: ['uint16', toWholeEnergy(computeBuilderDrain(tol))]})
+            const res = decodeStat(stats, 0)
+            const fin = decodeStat(stats, 1)
+            base.push({first: 'resonance', second: ['uint16', res]})
+            base.push({first: 'fineness', second: ['uint16', fin]})
+            base.push({first: 'speed', second: ['uint16', computeBuilderSpeed(res)]})
+            base.push({first: 'drain', second: ['uint16', toWholeEnergy(computeBuilderDrain(fin))]})
             break
         }
         case MODULE_STORAGE: {

package/src/nft/description.ts

@@ -37,6 +37,7 @@ import {
     ITEM_TUG_T1_PACKED,
     ITEM_PORTER_T1_PACKED,
     ITEM_WRANGLER_T1_PACKED,
+    ITEM_WRIGHT_T1_PACKED,
     ITEM_DREDGER_T1_PACKED,
     ITEM_WAREHOUSE_T1_PACKED,
     ITEM_WARP_T1,
@@ -114,9 +115,9 @@ export const computeLoaderThrust = (pla: number): number => 1 + idiv(pla * pla,
 export const computeCrafterSpeed = (rea: number): number => 100 + idiv(rea * 4, 5)
 export const computeCrafterDrain = (fin: number): number =>
     Math.max(5000, 30000 - idiv(fin * 1000, 33))
-export const computeBuilderSpeed = (coh: number): number => 100 + idiv(coh * 4, 5)
-export const computeBuilderDrain = (tol: number): number =>
-    Math.max(5000, 30000 - idiv(tol * 1000, 33))
+export const computeBuilderSpeed = (resonance: number): number => 100 + idiv(resonance * 4, 5)
+export const computeBuilderDrain = (fineness: number): number =>
+    Math.max(5000, 30000 - idiv(fineness * 1000, 33))
 export const computeHaulerCapacity = (fin: number, tier: number): number =>
     Math.max(tier, tier + idiv(fin, 400))
 export const computeHaulerEfficiency = (con: number): number => 2000 + con * 6
@@ -159,6 +160,8 @@ export function entityDisplayName(itemId: number): string {
             return 'Porter'
         case ITEM_WRANGLER_T1_PACKED:
             return 'Wrangler'
+        case ITEM_WRIGHT_T1_PACKED:
+            return 'Wright'
         case ITEM_DREDGER_T1_PACKED:
             return 'Dredger'
         case ITEM_WAREHOUSE_T1_PACKED:
@@ -260,9 +263,9 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             break
         }
         case MODULE_BUILDER: {
-            const coh = decodeStat(stats, 0)
-            const tol = decodeStat(stats, 1)
-            out += `  Speed ${computeBuilderSpeed(coh)}  Drain ${toWholeEnergy(computeBuilderDrain(tol))}`
+            const res = decodeStat(stats, 0)
+            const fin = decodeStat(stats, 1)
+            out += `  Speed ${computeBuilderSpeed(res)}  Drain ${toWholeEnergy(computeBuilderDrain(fin))}`
             break
         }
         case MODULE_STORAGE: {

package/src/scheduling/lanes.ts

@@ -130,12 +130,12 @@ export function resolveLaneBuilder(
     const item = getItem(Number(installed.item_id.value ?? installed.item_id))
     if (item.moduleType !== 'builder') throw new Error('lane module is not a builder')
     const stats = BigInt(installed.stats.toString())
-    const coh = decodeStat(stats, 0)
-    const tol = decodeStat(stats, 1)
+    const res = decodeStat(stats, 0)
+    const fin = decodeStat(stats, 1)
     const layout = getEntityLayout(entityItemId)?.slots ?? []
     const amp = getSlotAmp(layout, idx)
-    const speed = applySlotMultiplier(computeBuilderSpeed(coh), amp)
-    const drain = computeBuilderDrain(tol)
+    const speed = applySlotMultiplier(computeBuilderSpeed(res), amp)
+    const drain = computeBuilderDrain(fin)
     return {slotIndex: idx, speed, drain, outputPct: amp}
 }
 

package/src/scheduling/projection.ts

@@ -1,6 +1,6 @@
 import {Name, type UInt16, UInt32, UInt64} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
-import {Coordinates, TaskType} from '../types'
+import {Coordinates, RefitOp, TaskType} from '../types'
 import {
     capsHasMovement,
     capsHasStorage,
@@ -402,6 +402,13 @@ function applyCraftTask(projected: ProjectedEntity, task: ServerContract.Types.t
     }
 }
 
+// Mirrors calc_task_effect's TASK_REFIT: only ADD has a projectable cargo effect (REMOVE/SWAP return mass the entity row holds, invisible to the task itself).
+function applyRefitTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    if (task.refit?.op.toNumber() === RefitOp.ADD) {
+        removeCargoItem(projected, task.cargo[0])
+    }
+}
+
 function applyTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
     switch (task.type.toNumber()) {
         case TaskType.RECHARGE:
@@ -425,6 +432,9 @@ function applyTask(projected: ProjectedEntity, task: ServerContract.Types.task):
         case TaskType.CRAFT:
             applyCraftTask(projected, task)
             break
+        case TaskType.REFIT:
+            applyRefitTask(projected, task)
+            break
         case TaskType.UNDEPLOY:
         case TaskType.DEMOLISH:
             break
@@ -581,6 +591,9 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
             case TaskType.CRAFT:
                 if (taskComplete) applyCraftTask(projected, task)
                 break
+            case TaskType.REFIT:
+                if (taskComplete) applyRefitTask(projected, task)
+                break
             case TaskType.UNDEPLOY:
             case TaskType.DEMOLISH:
                 break

package/src/scheduling/schedule.test.ts

@@ -0,0 +1,116 @@
+import {describe, expect, test} from 'bun:test'
+import {ServerContract, TaskType} from '../index-module'
+import {hasPendingCapper, hasResolvable, isCapperTaskType} from './schedule'
+
+const T0 = '2026-06-19T00:00:00'
+const NOW = new Date('2026-06-19T00:01:00.000Z')
+
+function task(over: Partial<{type: number; duration: number}>) {
+    return ServerContract.Types.task.from({
+        type: over.type ?? TaskType.TRAVEL,
+        duration: over.duration ?? 30,
+        cancelable: 0,
+        cargo: [],
+        couplings: [],
+    })
+}
+
+function entity(
+    tasks: ReturnType<typeof task>[],
+    holds: ServerContract.Types.hold[] = [],
+    startedISO = T0
+) {
+    return ServerContract.Types.entity_info.from({
+        type: 'ship',
+        id: 1,
+        owner: 'player.gm',
+        entity_name: 'Ship 1',
+        coordinates: {x: 0, y: 0, z: 0},
+        item_id: 1,
+        cargomass: 0,
+        cargo: [],
+        modules: [],
+        lanes: [{lane_key: 0, schedule: {started: startedISO, tasks}}],
+        gatherer_lanes: [],
+        crafter_lanes: [],
+        builder_lanes: [],
+        loader_lanes: [],
+        holds,
+    })
+}
+
+function hold(kind: number) {
+    return ServerContract.Types.hold.from({
+        id: 1,
+        kind,
+        counterpart: {entity_type: 'ship', entity_id: 2},
+        until: T0,
+        incoming_mass: 0,
+    })
+}
+
+describe('isCapperTaskType', () => {
+    test('UNDEPLOY, DEMOLISH, REFIT are cappers', () => {
+        expect(isCapperTaskType(TaskType.UNDEPLOY)).toBe(true)
+        expect(isCapperTaskType(TaskType.DEMOLISH)).toBe(true)
+        expect(isCapperTaskType(TaskType.REFIT)).toBe(true)
+    })
+
+    test('non-capper task types are not cappers', () => {
+        expect(isCapperTaskType(TaskType.TRAVEL)).toBe(false)
+        expect(isCapperTaskType(TaskType.LOAD)).toBe(false)
+    })
+})
+
+describe('hasPendingCapper', () => {
+    test('false with no schedule', () => {
+        expect(hasPendingCapper(entity([]))).toBe(false)
+    })
+
+    test('false with only non-capper tasks queued', () => {
+        expect(hasPendingCapper(entity([task({type: TaskType.TRAVEL})]))).toBe(false)
+    })
+
+    test('true when a REFIT task is queued anywhere in the lane', () => {
+        const e = entity([task({type: TaskType.TRAVEL}), task({type: TaskType.REFIT})])
+        expect(hasPendingCapper(e)).toBe(true)
+    })
+
+    test('true when a DEMOLISH task is queued', () => {
+        expect(hasPendingCapper(entity([task({type: TaskType.DEMOLISH})]))).toBe(true)
+    })
+})
+
+describe('hasResolvable — capper gating', () => {
+    test('a completed non-capper front is resolvable', () => {
+        const e = entity([task({type: TaskType.TRAVEL, duration: 30})])
+        expect(hasResolvable(e, NOW)).toBe(true)
+    })
+
+    test('a completed capper front with no holds is resolvable', () => {
+        const e = entity([task({type: TaskType.REFIT, duration: 30})])
+        expect(hasResolvable(e, NOW)).toBe(true)
+    })
+
+    test('a completed capper front with a live hold is gated', () => {
+        const e = entity([task({type: TaskType.REFIT, duration: 30})], [hold(2)])
+        expect(hasResolvable(e, NOW)).toBe(false)
+    })
+
+    test('a capper front clears once holds empty', () => {
+        const withHold = entity([task({type: TaskType.REFIT, duration: 30})], [hold(2)])
+        const cleared = entity([task({type: TaskType.REFIT, duration: 30})], [])
+        expect(hasResolvable(withHold, NOW)).toBe(false)
+        expect(hasResolvable(cleared, NOW)).toBe(true)
+    })
+
+    test('a live hold does not gate a non-capper front', () => {
+        const e = entity([task({type: TaskType.TRAVEL, duration: 30})], [hold(2)])
+        expect(hasResolvable(e, NOW)).toBe(true)
+    })
+
+    test('an in-progress front is not resolvable regardless of holds', () => {
+        const e = entity([task({type: TaskType.REFIT, duration: 3600})])
+        expect(hasResolvable(e, NOW)).toBe(false)
+    })
+})

package/src/scheduling/schedule.ts

@@ -63,6 +63,24 @@ export function isIdle(entity: ScheduleData): boolean {
     return !hasSchedule(entity) && !hasHolds(entity)
 }
 
+// Mirrors is_capper_task_type: demolish/undeploy/refit cap a plan — no further appends once queued.
+export function isCapperTaskType(taskType: number): boolean {
+    return (
+        taskType === TaskType.UNDEPLOY ||
+        taskType === TaskType.DEMOLISH ||
+        taskType === TaskType.REFIT
+    )
+}
+
+export function hasPendingCapper(entity: ScheduleData): boolean {
+    for (const l of entity.lanes ?? []) {
+        for (const t of l.schedule.tasks) {
+            if (isCapperTaskType(t.type.toNumber())) return true
+        }
+    }
+    return false
+}
+
 export function isEntityIdle(entity: ScheduleData, now: Date): boolean {
     if (hasHolds(entity)) return false
     const lanes = entity.lanes
@@ -121,10 +139,13 @@ export function scheduleComplete(entity: ScheduleData, now: Date): boolean {
     return remaining === 0
 }
 
-// Mirrors contract lane_front_complete: any lane whose front task is complete and non-reserved.
+// Mirrors lane_front_complete && !capper_front_gated for own-entity holds (workshop/undeploy-target gates need cross-entity context this ScheduleData lacks).
 export function hasResolvable(entity: ScheduleData, now: Date): boolean {
     for (const l of entity.lanes ?? []) {
-        if (core.laneTaskComplete(l.schedule, 0, now)) return true
+        if (!core.laneTaskComplete(l.schedule, 0, now)) continue
+        const front = l.schedule.tasks[0]
+        if (isCapperTaskType(front.type.toNumber()) && hasHolds(entity)) continue
+        return true
     }
     return false
 }

package/src/types.ts

@@ -69,6 +69,13 @@ export enum TaskType {
     CHARGE = 16,
     UPGRADE = 17,
     SHUTTLE = 18,
+    REFIT = 19,
+}
+
+export enum RefitOp {
+    ADD = 0,
+    REMOVE = 1,
+    SWAP = 2,
 }
 
 export enum HoldKind {