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

package/src/derivation/capabilities.ts

@@ -218,6 +218,7 @@ export function computeBatteryCapabilities(stats: Record<string, number>): {
 import {
     ITEM_CONTAINER_T1_PACKED,
     ITEM_CONTAINER_T2_PACKED,
+    ITEM_CONSTRUCTION_DOCK_T1_PACKED,
     ITEM_EXTRACTOR_T1_PACKED,
     ITEM_FACTORY_T1_PACKED,
     ITEM_MASS_CATCHER_T1_PACKED,
@@ -277,6 +278,7 @@ export function computeBaseCapacity(itemId: number, stats: Record<string, number
         switch (itemId) {
             case ITEM_EXTRACTOR_T1_PACKED:
             case ITEM_FACTORY_T1_PACKED:
+            case ITEM_CONSTRUCTION_DOCK_T1_PACKED:
             case ITEM_MASS_DRIVER_T1_PACKED:
             case ITEM_MASS_CATCHER_T1_PACKED:
             case ITEM_CONTAINER_T1_PACKED:

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

@@ -13,6 +13,7 @@ import {
     ITEM_BEAM,
     ITEM_GATHERER_T1,
     ITEM_CRAFTER_T1,
+    ITEM_BUILDER_T1,
     ITEM_EXTRACTOR_T1_PACKED,
     ITEM_ROUSTABOUT_T1_PACKED,
     ITEM_PROSPECTOR_T1_PACKED,
@@ -33,7 +34,12 @@ test('getRecipeConsumers lists every recipe that consumes Sensor', () => {
     const consumers = getRecipeConsumers(ITEM_SENSOR)
     const ids = consumers.map((c) => c.outputItemId).sort((a, b) => a - b)
     expect(ids).toEqual(
-        [ITEM_CRAFTER_T1, ITEM_EXTRACTOR_T1_PACKED, ITEM_ROUSTABOUT_T1_PACKED].sort((a, b) => a - b)
+        [
+            ITEM_CRAFTER_T1,
+            ITEM_BUILDER_T1,
+            ITEM_EXTRACTOR_T1_PACKED,
+            ITEM_ROUSTABOUT_T1_PACKED,
+        ].sort((a, b) => a - b)
     )
 })
 

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/index-module.ts

@@ -333,6 +333,7 @@ export {
     ENTITY_WAREHOUSE,
     ENTITY_EXTRACTOR,
     ENTITY_FACTORY,
+    ENTITY_CONSTRUCTION_DOCK,
     ENTITY_WORKSHOP,
     ENTITY_CONTAINER,
     ENTITY_NEXUS,
@@ -351,6 +352,7 @@ export {
     isWarehouse,
     isExtractor,
     isFactory,
+    isConstructionDock,
     isWorkshop,
     isContainer,
     isNexus,

package/src/nft/description.ts

@@ -14,6 +14,7 @@ import {
 import {
     ITEM_CONTAINER_T1_PACKED,
     ITEM_CONTAINER_T2_PACKED,
+    ITEM_CONSTRUCTION_DOCK_T1_PACKED,
     ITEM_BUILDER_T1,
     ITEM_CRAFTER_T1,
     ITEM_ENGINE_T1,
@@ -37,6 +38,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,
@@ -159,6 +161,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:
@@ -167,6 +171,8 @@ export function entityDisplayName(itemId: number): string {
             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:
@@ -314,6 +320,7 @@ export function buildEntityDescription(
     } 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
     ) {

package/src/scheduling/schedule.test.ts

@@ -0,0 +1,119 @@
+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 are cappers', () => {
+        expect(isCapperTaskType(TaskType.UNDEPLOY)).toBe(true)
+        expect(isCapperTaskType(TaskType.DEMOLISH)).toBe(true)
+    })
+
+    test('REFIT is not a capper', () => {
+        expect(isCapperTaskType(TaskType.REFIT)).toBe(false)
+    })
+
+    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 DEMOLISH task is queued anywhere in the lane', () => {
+        const e = entity([task({type: TaskType.TRAVEL}), task({type: TaskType.DEMOLISH})])
+        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.DEMOLISH, 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.DEMOLISH, duration: 30})], [hold(2)])
+        expect(hasResolvable(e, NOW)).toBe(false)
+    })
+
+    test('a capper front clears once holds empty', () => {
+        const withHold = entity([task({type: TaskType.DEMOLISH, duration: 30})], [hold(2)])
+        const cleared = entity([task({type: TaskType.DEMOLISH, 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.DEMOLISH, duration: 3600})])
+        expect(hasResolvable(e, NOW)).toBe(false)
+    })
+})

package/src/scheduling/schedule.ts

@@ -63,6 +63,20 @@ export function isIdle(entity: ScheduleData): boolean {
     return !hasSchedule(entity) && !hasHolds(entity)
 }
 
+// Mirrors is_capper_task_type: demolish/undeploy cap a plan — no further appends once queued.
+export function isCapperTaskType(taskType: number): boolean {
+    return taskType === TaskType.UNDEPLOY || taskType === TaskType.DEMOLISH
+}
+
+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 +135,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 {