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

package/src/scheduling/cancel.test.ts

@@ -1,6 +1,7 @@
 import {describe, expect, test} from 'bun:test'
-import {ServerContract, TaskType, TaskCancelable} from '../index-module'
+import {ServerContract, TaskType, TaskCancelable, HoldKind} from '../index-module'
 import {cancelEligibility, CancelBlockReason} from './cancel'
+import type {IncomingSource} from './availability'
 
 const T0 = '2026-06-19T00:00:00'
 
@@ -380,3 +381,162 @@ describe('cancelEligibility — feasibility', () => {
         )
     })
 })
+
+describe('cancelEligibility — cross-entity strand (counterpart queued consumer)', () => {
+    const upcoming = new Date('2026-06-18T23:59:50.000Z')
+
+    function entityWithId(
+        id: number,
+        tasks: ReturnType<typeof ServerContract.Types.task.from>[],
+        cargo: {
+            id: number
+            item_id: number
+            stats: number
+            modules: never[]
+            quantity: number
+        }[] = []
+    ) {
+        return ServerContract.Types.entity_info.from({
+            type: 'ship',
+            id,
+            owner: 'player.gm',
+            entity_name: `Ship ${id}`,
+            coordinates: {x: 0, y: 0, z: 0},
+            item_id: 1,
+            cargomass: 0,
+            cargo,
+            modules: [],
+            lanes: [{lane_key: 0, schedule: {started: T0, tasks}}],
+            gatherer_lanes: [],
+            crafter_lanes: [],
+            builder_lanes: [],
+            loader_lanes: [],
+            holds: [],
+        })
+    }
+
+    function pushTask() {
+        return ServerContract.Types.task.from({
+            type: TaskType.UNLOAD,
+            duration: 50,
+            cancelable: TaskCancelable.ALWAYS,
+            cargo: [{item_id: 7, stats: 0, modules: [], quantity: 2}],
+            couplings: [
+                {counterpart: {entity_type: 'ship', entity_id: 2}, hold: 1, kind: HoldKind.PUSH},
+            ],
+        })
+    }
+
+    function craftConsumerTask() {
+        return ServerContract.Types.task.from({
+            type: TaskType.CRAFT,
+            duration: 100,
+            cancelable: TaskCancelable.ALWAYS,
+            cargo: [
+                {item_id: 7, stats: 0, modules: [], quantity: 2},
+                {item_id: 9, stats: 0, modules: [], quantity: 1},
+            ],
+            couplings: [],
+        })
+    }
+
+    function incoming(): IncomingSource[] {
+        return [
+            {
+                holdId: '1',
+                until: new Date('2026-06-19T00:00:50.000Z'),
+                items: [
+                    ServerContract.Types.cargo_item.from({
+                        item_id: 7,
+                        stats: 0,
+                        modules: [],
+                        quantity: 2,
+                    }),
+                ],
+            },
+        ]
+    }
+
+    function upgradeConsumerTask() {
+        return ServerContract.Types.task.from({
+            type: TaskType.UPGRADE,
+            duration: 100,
+            cancelable: TaskCancelable.ALWAYS,
+            cargo: [{item_id: 7, stats: 0, modules: [], quantity: 2}],
+            couplings: [],
+        })
+    }
+
+    test('blocked: counterpart consumer loses coverage without this delivery', () => {
+        const producer = entityWithId(1, [pushTask()])
+        const counterpart = entityWithId(2, [craftConsumerTask()])
+        const plan = cancelEligibility(producer, 0, 0, {
+            now: upcoming,
+            counterparts: new Map([['2', counterpart]]),
+            counterpartIncoming: new Map([['2', incoming()]]),
+        })
+        expect(plan.ok).toBe(false)
+        expect(plan.blockedReason).toBe(CancelBlockReason.WOULD_STRAND_COUNTERPART)
+        expect(plan.blockedByCounterpart?.entity_id.toNumber()).toBe(2)
+    })
+
+    test('blocked: counterpart upgrade consumer loses coverage without this delivery', () => {
+        const producer = entityWithId(1, [pushTask()])
+        const counterpart = entityWithId(2, [upgradeConsumerTask()])
+        const plan = cancelEligibility(producer, 0, 0, {
+            now: upcoming,
+            counterparts: new Map([['2', counterpart]]),
+            counterpartIncoming: new Map([['2', incoming()]]),
+        })
+        expect(plan.ok).toBe(false)
+        expect(plan.blockedReason).toBe(CancelBlockReason.WOULD_STRAND_COUNTERPART)
+        expect(plan.blockedByCounterpart?.entity_id.toNumber()).toBe(2)
+    })
+
+    test('allowed: counterpart upgrade consumer already covered on-hand', () => {
+        const producer = entityWithId(1, [pushTask()])
+        const counterpart = entityWithId(
+            2,
+            [upgradeConsumerTask()],
+            [{id: 1, item_id: 7, stats: 0, modules: [], quantity: 2}]
+        )
+        const plan = cancelEligibility(producer, 0, 0, {
+            now: upcoming,
+            counterparts: new Map([['2', counterpart]]),
+            counterpartIncoming: new Map([['2', incoming()]]),
+        })
+        expect(plan.ok).toBe(true)
+    })
+
+    test('allowed: counterpart consumer already covered on-hand (surplus coverage)', () => {
+        const producer = entityWithId(1, [pushTask()])
+        const counterpart = entityWithId(
+            2,
+            [craftConsumerTask()],
+            [{id: 1, item_id: 7, stats: 0, modules: [], quantity: 2}]
+        )
+        const plan = cancelEligibility(producer, 0, 0, {
+            now: upcoming,
+            counterparts: new Map([['2', counterpart]]),
+            counterpartIncoming: new Map([['2', incoming()]]),
+        })
+        expect(plan.ok).toBe(true)
+    })
+
+    test('allowed: counterpart data not loaded, check skipped gracefully', () => {
+        const producer = entityWithId(1, [pushTask()])
+        const plan = cancelEligibility(producer, 0, 0, {now: upcoming})
+        expect(plan.ok).toBe(true)
+    })
+
+    test('allowed: counterpart has no queued consumer', () => {
+        const producer = entityWithId(1, [pushTask()])
+        const idleCounterpart = entityWithId(2, [])
+        const plan = cancelEligibility(producer, 0, 0, {
+            now: upcoming,
+            counterparts: new Map([['2', idleCounterpart]]),
+            counterpartIncoming: new Map([['2', incoming()]]),
+        })
+        expect(plan.ok).toBe(true)
+    })
+})

package/src/scheduling/cancel.ts

@@ -1,7 +1,12 @@
 import type {ServerContract} from '../contracts'
 import {HoldKind, TaskCancelable, TaskType} from '../types'
 import {calcCargoItemMass} from '../capabilities/storage'
-import {taskCargoEffect, cargoKey} from './availability'
+import {
+    taskCargoEffect,
+    cargoKey,
+    isIncomingCouplingKind,
+    type IncomingSource,
+} from './availability'
 import * as schedule from './schedule'
 import {validateSchedule, type Projectable} from './projection'
 
@@ -11,6 +16,7 @@ export enum CancelBlockReason {
     DONE = 'DONE',
     CONTAINS_LINKED_TASK = 'CONTAINS_LINKED_TASK',
     WOULD_STRAND = 'WOULD_STRAND',
+    WOULD_STRAND_COUNTERPART = 'WOULD_STRAND_COUNTERPART',
     WOULD_OVERFILL = 'WOULD_OVERFILL',
     NOT_OWNER = 'NOT_OWNER',
 }
@@ -38,12 +44,14 @@ export interface CancelEffects {
 export interface CancelPlan {
     ok: boolean
     blockedReason?: CancelBlockReason
+    blockedByCounterpart?: EntityRef
     range: {count: number; taskIndices: number[]}
     effects: CancelEffects
 }
 export interface CancelEligibilityInput {
     now: Date
     counterparts?: Map<string, EntityInfo>
+    counterpartIncoming?: Map<string, readonly IncomingSource[]>
 }
 
 const EMPTY_EFFECTS: CancelEffects = {refunds: [], releasedHolds: [], abandonsRunning: false}
@@ -57,15 +65,18 @@ function postCancelEntity(entity: EntityInfo, laneKey: number, fromTaskIndex: nu
     return clone
 }
 
-function feasibleAfterCancel(post: EntityInfo): boolean {
-    const ordered = schedule.orderedTasks(post as unknown as Projectable)
+// C1: every pending consumer keeps its inputs covered by on-hand + own-lane producers strictly-before + incoming strictly-before.
+function queueFeasible(entity: EntityInfo, incoming: readonly IncomingSource[] = []): boolean {
+    const ordered = schedule.orderedTasks(entity as unknown as Projectable)
     const base = new Map<string, number>()
-    for (const c of post.cargo ?? []) {
+    for (const c of entity.cargo ?? []) {
         const k = cargoKey(c)
         base.set(k, (base.get(k) ?? 0) + c.quantity.toNumber())
     }
     const isConsumer = (t: Task) =>
-        t.type.toNumber() === TaskType.CRAFT || t.type.toNumber() === TaskType.UNLOAD
+        t.type.toNumber() === TaskType.CRAFT ||
+        t.type.toNumber() === TaskType.UNLOAD ||
+        t.type.toNumber() === TaskType.UPGRADE
     for (const self of ordered) {
         if (!isConsumer(self.task)) continue
         const map = new Map(base)
@@ -75,6 +86,12 @@ function feasibleAfterCancel(post: EntityInfo): boolean {
                 map.set(cargoKey(out), (map.get(cargoKey(out)) ?? 0) + out.quantity.toNumber())
             }
         }
+        for (const src of incoming) {
+            if (src.until.getTime() >= self.completesAt.getTime()) continue
+            for (const item of src.items) {
+                map.set(cargoKey(item), (map.get(cargoKey(item)) ?? 0) + item.quantity.toNumber())
+            }
+        }
         for (const other of ordered) {
             if (other === self) continue
             for (const inp of taskCargoEffect(other.task).removed) {
@@ -86,6 +103,11 @@ function feasibleAfterCancel(post: EntityInfo): boolean {
             if ((map.get(cargoKey(inp)) ?? 0) < inp.quantity.toNumber()) return false
         }
     }
+    return true
+}
+
+function feasibleAfterCancel(post: EntityInfo): boolean {
+    if (!queueFeasible(post)) return false
     try {
         validateSchedule(post as unknown as Projectable)
     } catch {
@@ -162,6 +184,37 @@ export function cancelEligibility(
     const post = postCancelEntity(entity, laneKey, fromTaskIndex)
     if (!feasibleAfterCancel(post)) return block(CancelBlockReason.WOULD_STRAND)
 
+    // cross-entity C1: a counterpart losing this delivery must still feed its own queued consumers.
+    const releasedByCounterpart = new Map<string, {counterpart: EntityRef; holdIds: Set<string>}>()
+    for (const i of taskIndices) {
+        for (const c of tasks[i].couplings ?? []) {
+            if (!isIncomingCouplingKind(c.kind.toNumber())) continue
+            const id = c.counterpart.entity_id.toString()
+            const entry = releasedByCounterpart.get(id) ?? {
+                counterpart: c.counterpart,
+                holdIds: new Set<string>(),
+            }
+            entry.holdIds.add(c.hold.toString())
+            releasedByCounterpart.set(id, entry)
+        }
+    }
+    for (const [counterpartId, released] of releasedByCounterpart) {
+        const counterpart = input.counterparts?.get(counterpartId)
+        if (!counterpart) continue
+        const incoming = (input.counterpartIncoming?.get(counterpartId) ?? []).filter(
+            (src) => !released.holdIds.has(src.holdId)
+        )
+        if (!queueFeasible(counterpart, incoming)) {
+            return {
+                ok: false,
+                blockedReason: CancelBlockReason.WOULD_STRAND_COUNTERPART,
+                blockedByCounterpart: released.counterpart,
+                range,
+                effects: {...EMPTY_EFFECTS},
+            }
+        }
+    }
+
     const effects: CancelEffects = {refunds: [], releasedHolds: [], abandonsRunning: false}
     let energyForfeited = 0
     for (const i of taskIndices) {