@shipload/sdk 1.0.0-next.34 → 1.0.0-next.36

package/src/planner/planner.test.ts

@@ -0,0 +1,319 @@
+import {UInt8, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
+import {expect, test, describe} from 'bun:test'
+import type {GathererStats} from '../types/capabilities'
+import {ServerContract} from '../contracts'
+import {calc_gather_duration} from '../capabilities/gathering'
+import {planParallelGather, planParallelTransfer, type GatherPlanEntity} from './index'
+
+function gathererLane(
+    slotIndex: number,
+    yieldVal: number,
+    drain: number,
+    depth: number
+): ServerContract.Types.gatherer_lane {
+    return ServerContract.Types.gatherer_lane.from({
+        slot_index: UInt8.from(slotIndex),
+        yield: UInt16.from(yieldVal),
+        drain: UInt32.from(drain),
+        depth: UInt16.from(depth),
+        output_pct: UInt16.from(100),
+    })
+}
+
+function loaderLane(
+    slotIndex: number,
+    mass: number,
+    thrust: number
+): ServerContract.Types.loader_lane {
+    return ServerContract.Types.loader_lane.from({
+        slot_index: UInt8.from(slotIndex),
+        mass: UInt32.from(mass),
+        thrust: UInt16.from(thrust),
+        output_pct: UInt16.from(100),
+    })
+}
+
+function energyStats(capacity: number, recharge: number): ServerContract.Types.energy_stats {
+    return ServerContract.Types.energy_stats.from({
+        capacity: UInt32.from(capacity),
+        recharge: UInt32.from(recharge),
+    })
+}
+
+interface EntityOverrides {
+    gatherer_lanes?: ServerContract.Types.gatherer_lane[]
+    loader_lanes?: ServerContract.Types.loader_lane[]
+    generator?: ServerContract.Types.energy_stats
+    energy?: number
+    lanes?: ServerContract.Types.lane[]
+}
+
+function entity(overrides: EntityOverrides = {}): GatherPlanEntity {
+    return {
+        gatherer_lanes: overrides.gatherer_lanes ?? [],
+        loader_lanes: overrides.loader_lanes ?? [],
+        generator: overrides.generator,
+        energy: overrides.energy !== undefined ? UInt16.from(overrides.energy) : undefined,
+        lanes: overrides.lanes ?? [],
+        coordinates: ServerContract.Types.coordinates.from({x: 0, y: 0}),
+        cargo: [],
+        cargomass: UInt32.from(0),
+    }
+}
+
+const NOW = new Date('2026-06-21T00:00:00.000Z')
+
+describe('planParallelGather', () => {
+    test('sanity: single-gatherer qty 20 = ~35s matches calc_gather_duration', () => {
+        const gatherer: GathererStats = {
+            yield: UInt16.from(57),
+            drain: UInt32.from(500),
+            depth: UInt16.from(5000),
+        }
+        const dur = calc_gather_duration(gatherer, 228, 20, 0, 1000)
+        expect(Number(dur)).toBeCloseTo(35, 0)
+    })
+
+    test('two gatherers: quantities proportional to yield, durations within 1s', () => {
+        const YIELD1 = 200
+        const YIELD2 = 400
+        const DEPTH = 5000
+        const DRAIN = 500
+        const QUANTITY = 60
+        const STRATUM = 0
+
+        const e = entity({
+            gatherer_lanes: [
+                gathererLane(0, YIELD1, DRAIN, DEPTH),
+                gathererLane(1, YIELD2, DRAIN, DEPTH),
+            ],
+            generator: energyStats(10000, 100),
+            energy: 10000,
+        })
+
+        const plan = planParallelGather(e, {quantity: QUANTITY}, STRATUM, NOW)
+
+        expect(plan).toHaveLength(2)
+        expect(plan.reduce((s, p) => s + p.quantity, 0)).toBe(QUANTITY)
+
+        const q1 = plan.find((p) => p.slot === 0)!.quantity
+        const q2 = plan.find((p) => p.slot === 1)!.quantity
+        expect(q1 + q2).toBe(QUANTITY)
+        expect(q2 / q1).toBeCloseTo(YIELD2 / YIELD1, 0)
+
+        const ITEM_MASS = 228
+        const RICHNESS = 1000
+        const g1: GathererStats = {
+            yield: UInt16.from(YIELD1),
+            drain: UInt32.from(DRAIN),
+            depth: UInt16.from(DEPTH),
+        }
+        const g2: GathererStats = {
+            yield: UInt16.from(YIELD2),
+            drain: UInt32.from(DRAIN),
+            depth: UInt16.from(DEPTH),
+        }
+        const dur1 = Number(calc_gather_duration(g1, ITEM_MASS, q1, STRATUM, RICHNESS))
+        const dur2 = Number(calc_gather_duration(g2, ITEM_MASS, q2, STRATUM, RICHNESS))
+        expect(Math.abs(dur1 - dur2)).toBeLessThan(1)
+    })
+
+    test("'max' target: uses all reaching lanes, each slot gets >= 1 unit", () => {
+        const e = entity({
+            gatherer_lanes: [gathererLane(0, 200, 500, 5000), gathererLane(1, 300, 500, 5000)],
+            generator: energyStats(10000, 100),
+            energy: 10000,
+        })
+
+        const plan = planParallelGather(e, 'max', 0, NOW)
+
+        expect(plan.length).toBeGreaterThan(0)
+        for (const entry of plan) {
+            expect(entry.quantity).toBeGreaterThanOrEqual(1)
+        }
+    })
+
+    test('energy-starved: drops the lowest-yield lane(s) until the pool sustains the plan', () => {
+        // Full-Q energy: 3 lanes=>144, 2 lanes(drop yield=50)=>120; pool 130 fits 2 but not 3.
+        const e = entity({
+            gatherer_lanes: [
+                gathererLane(0, 50, 10000, 5000),
+                gathererLane(1, 100, 10000, 5000),
+                gathererLane(2, 100, 10000, 5000),
+            ],
+            generator: energyStats(10000, 1),
+            energy: 130,
+        })
+
+        const plan = planParallelGather(e, {quantity: 120}, 0, NOW)
+
+        // Lowest-yield lane (slot 0) dropped; the two yield-100 lanes survive.
+        expect(plan).toHaveLength(2)
+        expect(plan.find((p) => p.slot === 0)).toBeUndefined()
+        expect(plan.reduce((s, p) => s + p.quantity, 0)).toBe(120)
+    })
+
+    test('energy-starved: single lane caps quantity to the sustainable max', () => {
+        // energyPerUnit=1, full Q=120 costs 120 > pool 50, so quantity caps at 50.
+        const e = entity({
+            gatherer_lanes: [gathererLane(0, 100, 10000, 5000)],
+            generator: energyStats(10000, 1),
+            energy: 50,
+        })
+
+        const plan = planParallelGather(e, {quantity: 120}, 0, NOW)
+
+        expect(plan).toHaveLength(1)
+        expect(plan[0].slot).toBe(0)
+        expect(plan[0].quantity).toBe(50)
+    })
+
+    test('energy-starved: projected energy nets out a queued gather task', () => {
+        // A queued task costing 9970 leaves 30 projected energy => quantity caps at 30.
+        const queued = ServerContract.Types.lane.from({
+            lane_key: UInt8.from(0),
+            schedule: {
+                started: NOW.toISOString().slice(0, -1),
+                tasks: [
+                    ServerContract.Types.task.from({
+                        type: UInt8.from(5),
+                        duration: UInt32.from(100),
+                        cancelable: 0,
+                        cargo: [],
+                        entitytarget: {entity_type: 'ship', entity_id: UInt64.from(1)},
+                        energy_cost: UInt32.from(9970),
+                    }),
+                ],
+            },
+        })
+
+        const e = entity({
+            gatherer_lanes: [gathererLane(0, 100, 10000, 5000)],
+            generator: energyStats(10000, 1),
+            energy: 10000,
+            lanes: [queued],
+        })
+
+        const plan = planParallelGather(e, {quantity: 120}, 0, NOW)
+
+        expect(plan).toHaveLength(1)
+        expect(plan[0].quantity).toBe(30)
+    })
+
+    test('stratum filter: shallow lane excluded, only deep lane used', () => {
+        const e = entity({
+            gatherer_lanes: [gathererLane(0, 200, 500, 500), gathererLane(1, 300, 500, 5000)],
+            generator: energyStats(10000, 100),
+            energy: 10000,
+        })
+
+        const plan = planParallelGather(e, {quantity: 10}, 2000, NOW)
+
+        expect(plan).toHaveLength(1)
+        expect(plan[0].slot).toBe(1)
+    })
+
+    test('no reaching gatherers throws', () => {
+        const e = entity({
+            gatherer_lanes: [gathererLane(0, 200, 500, 100)],
+            generator: energyStats(10000, 100),
+            energy: 10000,
+        })
+
+        expect(() => planParallelGather(e, {quantity: 10}, 2000, NOW)).toThrow(
+            'no gatherer reaches this stratum'
+        )
+    })
+
+    test('two identical gatherers: per-lane quantity halved, durations equal and within 1s', () => {
+        const YIELD = 200
+        const DEPTH = 5000
+        const DRAIN = 500
+        const QUANTITY = 60
+        const STRATUM = 0
+
+        const eSingle = entity({
+            gatherer_lanes: [gathererLane(0, YIELD, DRAIN, DEPTH)],
+            generator: energyStats(10000, 100),
+            energy: 10000,
+        })
+        const eDouble = entity({
+            gatherer_lanes: [
+                gathererLane(0, YIELD, DRAIN, DEPTH),
+                gathererLane(1, YIELD, DRAIN, DEPTH),
+            ],
+            generator: energyStats(10000, 100),
+            energy: 10000,
+        })
+
+        const planSingle = planParallelGather(eSingle, {quantity: QUANTITY}, STRATUM, NOW)
+        const planDouble = planParallelGather(eDouble, {quantity: QUANTITY}, STRATUM, NOW)
+
+        expect(planSingle).toHaveLength(1)
+        expect(planDouble).toHaveLength(2)
+
+        const singleQ = planSingle[0].quantity
+        const doubleQ1 = planDouble[0].quantity
+        const doubleQ2 = planDouble[1].quantity
+        expect(doubleQ1 + doubleQ2).toBe(QUANTITY)
+
+        const ITEM_MASS = 228
+        const RICHNESS = 1000
+        const g: GathererStats = {
+            yield: UInt16.from(YIELD),
+            drain: UInt32.from(DRAIN),
+            depth: UInt16.from(DEPTH),
+        }
+        const durSingle = Number(calc_gather_duration(g, ITEM_MASS, singleQ, STRATUM, RICHNESS))
+        const durDouble1 = Number(calc_gather_duration(g, ITEM_MASS, doubleQ1, STRATUM, RICHNESS))
+        const durDouble2 = Number(calc_gather_duration(g, ITEM_MASS, doubleQ2, STRATUM, RICHNESS))
+
+        expect(durDouble1).toBeCloseTo(durSingle / 2, 0)
+        expect(durDouble2).toBeCloseTo(durSingle / 2, 0)
+        expect(Math.abs(durDouble1 - durDouble2)).toBeLessThan(1)
+    })
+})
+
+describe('planParallelTransfer', () => {
+    test('two loader lanes: quantities proportional to thrust, sums to target', () => {
+        const THRUST1 = 100
+        const THRUST2 = 200
+        const QUANTITY = 90
+
+        const e = entity({
+            loader_lanes: [loaderLane(0, 500, THRUST1), loaderLane(1, 500, THRUST2)],
+        })
+
+        const plan = planParallelTransfer(e, {quantity: QUANTITY})
+
+        expect(plan).toHaveLength(2)
+        expect(plan.reduce((s, p) => s + p.quantity, 0)).toBe(QUANTITY)
+
+        const q1 = plan.find((p) => p.slot === 0)!.quantity
+        const q2 = plan.find((p) => p.slot === 1)!.quantity
+        expect(q2 / q1).toBeCloseTo(THRUST2 / THRUST1, 0)
+    })
+
+    test('no loader lanes: returns empty plan', () => {
+        const plan = planParallelTransfer(entity({loader_lanes: []}), {quantity: 10})
+        expect(plan).toHaveLength(0)
+    })
+
+    test('thrust=0 loader lane (no-loader/mobility case): returns empty plan', () => {
+        const plan = planParallelTransfer(entity({loader_lanes: [loaderLane(0, 500, 0)]}), {
+            quantity: 10,
+        })
+        expect(plan).toHaveLength(0)
+    })
+
+    test("'max' target: each loader lane gets >= 1 unit", () => {
+        const e = entity({
+            loader_lanes: [loaderLane(0, 500, 100), loaderLane(1, 500, 200)],
+        })
+        const plan = planParallelTransfer(e, 'max')
+        expect(plan.length).toBeGreaterThan(0)
+        for (const entry of plan) {
+            expect(entry.quantity).toBeGreaterThanOrEqual(1)
+        }
+    })
+})

package/src/resolution/resolve-item.ts

@@ -287,7 +287,10 @@ function resolveEntity(
     let moduleSlots: ResolvedModuleSlot[] | undefined
 
     if (stats !== undefined) {
-        const decoded = decodeCraftedItemStats(id, toBigStats(stats))
+        const bigStats = toBigStats(stats)
+        const decoded = decodeCraftedItemStats(id, bigStats)
+        if (decoded.strength === undefined) decoded.strength = decodeStat(bigStats, 0)
+        if (decoded.hardness === undefined) decoded.hardness = decodeStat(bigStats, 2)
         const hullCaps = hullCapsForEntity(id, decoded)
         attributes = [
             {

package/src/scheduling/availability.ts

@@ -36,7 +36,7 @@ export function taskCargoEffect(task: Task): CargoEffect {
     }
 }
 
-function cargoKey(item: CargoItem): string {
+export function cargoKey(item: CargoItem): string {
     const base = `${item.item_id.toNumber()}:${item.stats.toString()}`
     const modules = item.modules ?? []
     const entityId = item.entity_id?.toString()

package/src/scheduling/cancel.test.ts

@@ -0,0 +1,348 @@
+import {describe, expect, test} from 'bun:test'
+import {ServerContract, TaskType, TaskCancelable} from '../index-module'
+import {cancelEligibility, CancelBlockReason} from './cancel'
+
+const T0 = '2026-06-19T00:00:00'
+
+function task(over: Partial<{type: number; duration: number; cancelable: number; group: number}>) {
+    return ServerContract.Types.task.from({
+        type: over.type ?? TaskType.TRAVEL,
+        duration: over.duration ?? 100,
+        cancelable: over.cancelable ?? TaskCancelable.BEFORE_START,
+        cargo: [],
+        ...(over.group ? {entitygroup: over.group} : {}),
+    })
+}
+
+function entity(tasks: ReturnType<typeof task>[], 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: [],
+        loader_lanes: [],
+        holds: [],
+    })
+}
+
+describe('cancelEligibility — local gates', () => {
+    const now = new Date('2026-06-19T00:00:10.000Z') // 10s in: task 0 running, task 1 upcoming
+
+    test('cancelling the last upcoming task: ok, count 1', () => {
+        const e = entity([task({}), task({})])
+        const plan = cancelEligibility(e, 0, 1, {now})
+        expect(plan.ok).toBe(true)
+        expect(plan.range.count).toBe(1)
+        expect(plan.range.taskIndices).toEqual([1])
+    })
+
+    test('NEVER task is blocked', () => {
+        const e = entity([
+            task({}),
+            task({cancelable: TaskCancelable.NEVER, type: TaskType.GATHER}),
+        ])
+        expect(cancelEligibility(e, 0, 1, {now}).blockedReason).toBe(CancelBlockReason.TASK_NEVER)
+    })
+
+    test('BEFORE_START task that is running is blocked', () => {
+        const e = entity([task({cancelable: TaskCancelable.BEFORE_START, duration: 100})])
+        // task 0 is running at now=10s
+        expect(cancelEligibility(e, 0, 0, {now}).blockedReason).toBe(
+            CancelBlockReason.BEFORE_START_RUNNING
+        )
+    })
+
+    test('done task is blocked', () => {
+        const e = entity([task({duration: 5})]) // completes at 5s, now=10s
+        expect(cancelEligibility(e, 0, 0, {now}).blockedReason).toBe(CancelBlockReason.DONE)
+    })
+
+    test('unknown lane: count 0, ok false', () => {
+        const e = entity([task({})])
+        const plan = cancelEligibility(e, 9, 0, {now})
+        expect(plan.ok).toBe(false)
+        expect(plan.range.count).toBe(0)
+    })
+
+    test('multi-task range: 4 tasks, fromIndex 1 yields count 3', () => {
+        const e = entity([
+            task({duration: 100}),
+            task({cancelable: TaskCancelable.ALWAYS, duration: 100}),
+            task({cancelable: TaskCancelable.ALWAYS, duration: 100}),
+            task({cancelable: TaskCancelable.ALWAYS, duration: 100}),
+        ])
+        const plan = cancelEligibility(e, 0, 1, {now})
+        expect(plan.ok).toBe(true)
+        expect(plan.range.count).toBe(3)
+        expect(plan.range.taskIndices).toEqual([1, 2, 3])
+    })
+})
+
+describe('cancelEligibility — linked tasks', () => {
+    const now = new Date('2026-06-19T00:00:10.000Z')
+    test('range containing a linked (entitygroup) task is blocked', () => {
+        const e = entity([task({}), task({group: 42}), task({})])
+        expect(cancelEligibility(e, 0, 0, {now}).blockedReason).toBe(
+            CancelBlockReason.CONTAINS_LINKED_TASK
+        )
+    })
+    test('task after the linked one cancels normally', () => {
+        const e = entity([task({}), task({group: 42}), task({})])
+        expect(cancelEligibility(e, 0, 2, {now}).ok).toBe(true)
+    })
+})
+
+const HOLD_PULL = 1
+function loadTask(giverType: string, giverId: number, holdId: number, qty: number) {
+    return ServerContract.Types.task.from({
+        type: TaskType.LOAD,
+        duration: 100,
+        cancelable: TaskCancelable.ALWAYS,
+        cargo: [{item_id: 7, stats: 0, modules: [], quantity: qty}],
+        entitytarget: {entity_type: giverType, entity_id: giverId},
+        hold: holdId,
+    })
+}
+
+describe('cancelEligibility — effects', () => {
+    const now = new Date('2026-06-19T00:00:10.000Z')
+
+    test('abandonsRunning true when the front of range is a running ALWAYS task', () => {
+        const e = entity([
+            task({cancelable: TaskCancelable.ALWAYS, type: TaskType.RECHARGE, duration: 100}),
+        ])
+        expect(cancelEligibility(e, 0, 0, {now}).effects.abandonsRunning).toBe(true)
+    })
+
+    test('buildplot cancel reports keepsPlotDeposits', () => {
+        const e = entity([
+            ServerContract.Types.task.from({
+                type: TaskType.BUILDPLOT,
+                duration: 100,
+                cancelable: TaskCancelable.ALWAYS,
+                cargo: [],
+                entitytarget: {entity_type: 'plot', entity_id: 55},
+            }),
+        ])
+        const plan = cancelEligibility(e, 0, 0, {now})
+        expect(plan.effects.keepsPlotDeposits?.plot.entity_id.toNumber()).toBe(55)
+    })
+
+    test('PULL load cancel refunds cargo to the giver', () => {
+        const lt = loadTask('warehouse', 6, 1, 4)
+        const upcoming = new Date('2026-06-18T23:59:50.000Z')
+        const e = 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: T0, tasks: [lt]}}],
+            gatherer_lanes: [],
+            crafter_lanes: [],
+            loader_lanes: [],
+            holds: [
+                {
+                    id: 1,
+                    kind: HOLD_PULL,
+                    counterpart: {entity_type: 'warehouse', entity_id: 6},
+                    until: T0,
+                    incoming_mass: 0,
+                },
+            ],
+        })
+        const plan = cancelEligibility(e, 0, 0, {now: upcoming})
+        expect(plan.effects.refunds[0]?.giver.entity_id.toNumber()).toBe(6)
+        expect(plan.effects.refunds[0]?.cargo[0].quantity.toNumber()).toBe(4)
+    })
+
+    test('PULL load cancel populates releasedHolds with kind and counterpart', () => {
+        const lt = loadTask('warehouse', 6, 1, 4)
+        const upcoming = new Date('2026-06-18T23:59:50.000Z')
+        const e = 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: T0, tasks: [lt]}}],
+            gatherer_lanes: [],
+            crafter_lanes: [],
+            loader_lanes: [],
+            holds: [
+                {
+                    id: 1,
+                    kind: HOLD_PULL,
+                    counterpart: {entity_type: 'warehouse', entity_id: 6},
+                    until: T0,
+                    incoming_mass: 0,
+                },
+            ],
+        })
+        const plan = cancelEligibility(e, 0, 0, {now: upcoming})
+        expect(plan.effects.releasedHolds[0]?.kind).toBe(1)
+        expect(plan.effects.releasedHolds[0]?.counterpart.entity_id.toNumber()).toBe(6)
+    })
+
+    test('unresolvable hold emits no releasedHolds entry', () => {
+        const lt = loadTask('warehouse', 6, 99, 4)
+        const upcoming = new Date('2026-06-18T23:59:50.000Z')
+        const e = 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: T0, tasks: [lt]}}],
+            gatherer_lanes: [],
+            crafter_lanes: [],
+            loader_lanes: [],
+            holds: [],
+        })
+        const plan = cancelEligibility(e, 0, 0, {now: upcoming})
+        expect(plan.effects.releasedHolds).toHaveLength(0)
+    })
+})
+
+describe('cancelEligibility — feasibility', () => {
+    const upcoming = new Date('2026-06-18T23:59:50.000Z')
+
+    test('WOULD_STRAND when cancelling a producer a later consumer needs', () => {
+        const producer = ServerContract.Types.task.from({
+            type: TaskType.LOAD,
+            duration: 50,
+            cancelable: TaskCancelable.ALWAYS,
+            cargo: [{item_id: 7, stats: 0, modules: [], quantity: 2}],
+        })
+        const consumer = ServerContract.Types.task.from({
+            type: TaskType.CRAFT,
+            duration: 50,
+            cancelable: TaskCancelable.ALWAYS,
+            cargo: [
+                {item_id: 7, stats: 0, modules: [], quantity: 2},
+                {item_id: 9, stats: 0, modules: [], quantity: 1},
+            ],
+        })
+        const e = ServerContract.Types.entity_info.from({
+            type: 'ship',
+            id: 1,
+            owner: 'player.gm',
+            entity_name: 'S',
+            coordinates: {x: 0, y: 0, z: 0},
+            item_id: 1,
+            cargomass: 0,
+            cargo: [],
+            modules: [],
+            lanes: [
+                {
+                    lane_key: 1,
+                    schedule: {started: '2026-06-19T00:00:00', tasks: [producer]},
+                },
+                {
+                    lane_key: 2,
+                    schedule: {started: '2026-06-19T00:00:00', tasks: [consumer]},
+                },
+            ],
+            gatherer_lanes: [],
+            crafter_lanes: [],
+            loader_lanes: [],
+            holds: [],
+        })
+        expect(cancelEligibility(e, 1, 0, {now: upcoming}).blockedReason).toBe(
+            CancelBlockReason.WOULD_STRAND
+        )
+    })
+
+    test('benign cancel on independent lane does NOT strand', () => {
+        const producer = ServerContract.Types.task.from({
+            type: TaskType.LOAD,
+            duration: 50,
+            cancelable: TaskCancelable.ALWAYS,
+            cargo: [{item_id: 7, stats: 0, modules: [], quantity: 2}],
+        })
+        const independent = ServerContract.Types.task.from({
+            type: TaskType.TRAVEL,
+            duration: 50,
+            cancelable: TaskCancelable.ALWAYS,
+            cargo: [],
+        })
+        const e = ServerContract.Types.entity_info.from({
+            type: 'ship',
+            id: 1,
+            owner: 'player.gm',
+            entity_name: 'S',
+            coordinates: {x: 0, y: 0, z: 0},
+            item_id: 1,
+            cargomass: 0,
+            cargo: [],
+            modules: [],
+            lanes: [
+                {lane_key: 1, schedule: {started: '2026-06-19T00:00:00', tasks: [producer]}},
+                {lane_key: 2, schedule: {started: '2026-06-19T00:00:00', tasks: [independent]}},
+            ],
+            gatherer_lanes: [],
+            crafter_lanes: [],
+            loader_lanes: [],
+            holds: [],
+        })
+        expect(cancelEligibility(e, 2, 0, {now: upcoming}).ok).toBe(true)
+    })
+
+    test('WOULD_STRAND when cancelling producer of a MODULAR cargo the consumer needs', () => {
+        const moduledCargo = {item_id: 7, stats: 0, modules: [{type: 3}], quantity: 2}
+        const producer = ServerContract.Types.task.from({
+            type: TaskType.LOAD,
+            duration: 50,
+            cancelable: TaskCancelable.ALWAYS,
+            cargo: [moduledCargo],
+        })
+        const consumer = ServerContract.Types.task.from({
+            type: TaskType.CRAFT,
+            duration: 50,
+            cancelable: TaskCancelable.ALWAYS,
+            cargo: [moduledCargo, {item_id: 9, stats: 0, modules: [], quantity: 1}],
+        })
+        const e = ServerContract.Types.entity_info.from({
+            type: 'ship',
+            id: 1,
+            owner: 'player.gm',
+            entity_name: 'S',
+            coordinates: {x: 0, y: 0, z: 0},
+            item_id: 1,
+            cargomass: 0,
+            cargo: [],
+            modules: [],
+            lanes: [
+                {lane_key: 1, schedule: {started: '2026-06-19T00:00:00', tasks: [producer]}},
+                {lane_key: 2, schedule: {started: '2026-06-19T00:00:00', tasks: [consumer]}},
+            ],
+            gatherer_lanes: [],
+            crafter_lanes: [],
+            loader_lanes: [],
+            holds: [],
+        })
+        expect(cancelEligibility(e, 1, 0, {now: upcoming}).blockedReason).toBe(
+            CancelBlockReason.WOULD_STRAND
+        )
+    })
+})