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

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 {