@shipload/sdk 1.0.0-next.37 → 1.0.0-next.38

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@shipload/sdk",
     "description": "SDKs for Shipload",
-    "version": "1.0.0-next.37",
+    "version": "1.0.0-next.38",
     "homepage": "https://github.com/shipload/toolkit/tree/master/packages/sdk",
     "repository": {
         "type": "git",

package/src/data/capabilities.ts

@@ -21,20 +21,22 @@ export const capabilityNames: string[] = [
     'Crafter',
     'Launch',
     'Hauler',
-    'Battery',
 ]
 
 export const capabilityAttributes: CapabilityAttribute[] = [
     {capability: 'Hull', attribute: 'mass', description: 'Total mass of the hull'},
-    {capability: 'Storage', attribute: 'capacity', description: 'Maximum mass that can be stored'},
     {
         capability: 'Storage',
-        attribute: 'bonus',
-        description: 'Capacity bonus added by an installed Storage module',
+        attribute: 'capacity',
+        description: 'Cargo capacity added by hulls and installed Cargo Bay modules',
     },
     {capability: 'Movement', attribute: 'thrust', description: 'Propulsion force'},
     {capability: 'Movement', attribute: 'drain', description: 'Energy consumed per movement'},
-    {capability: 'Energy', attribute: 'capacity', description: 'Maximum energy storage'},
+    {
+        capability: 'Energy',
+        attribute: 'capacity',
+        description: 'Energy capacity from Generators and installed Battery Bank modules',
+    },
     {capability: 'Energy', attribute: 'recharge', description: 'Energy regeneration rate'},
     {capability: 'Loader', attribute: 'mass', description: 'Weight of the loader unit itself'},
     {capability: 'Loader', attribute: 'thrust', description: 'Loading speed/force'},
@@ -72,11 +74,6 @@ export const capabilityAttributes: CapabilityAttribute[] = [
         attribute: 'drain',
         description: 'Energy consumed per target during haul-beam operation',
     },
-    {
-        capability: 'Battery',
-        attribute: 'bonus',
-        description: 'Energy capacity bonus added by an installed Battery module',
-    },
 ]
 
 const invertedAttributes = new Set(['drain', 'mass'])

package/src/data/capability-formulas.ts

@@ -48,10 +48,10 @@ export const SLOT_FORMULAS: Record<SlotConsumerKind, Record<number, SlotConsumer
         1: {capability: 'Crafter', attribute: 'drain'},
     },
     storage: {
-        0: {capability: 'Storage', attribute: 'bonus'},
-        1: {capability: 'Storage', attribute: 'bonus'},
-        2: {capability: 'Storage', attribute: 'bonus'},
-        3: {capability: 'Storage', attribute: 'bonus'},
+        0: {capability: 'Storage', attribute: 'capacity'},
+        1: {capability: 'Storage', attribute: 'capacity'},
+        2: {capability: 'Storage', attribute: 'capacity'},
+        3: {capability: 'Storage', attribute: 'capacity'},
     },
     hauler: {
         0: {capability: 'Hauler', attribute: 'capacity'},
@@ -62,10 +62,10 @@ export const SLOT_FORMULAS: Record<SlotConsumerKind, Record<number, SlotConsumer
         0: {capability: 'Warp', attribute: 'range'},
     },
     battery: {
-        0: {capability: 'Battery', attribute: 'bonus'},
-        1: {capability: 'Battery', attribute: 'bonus'},
-        2: {capability: 'Battery', attribute: 'bonus'},
-        3: {capability: 'Battery', attribute: 'bonus'},
+        0: {capability: 'Energy', attribute: 'capacity'},
+        1: {capability: 'Energy', attribute: 'capacity'},
+        2: {capability: 'Energy', attribute: 'capacity'},
+        3: {capability: 'Energy', attribute: 'capacity'},
     },
     'ship-t1': ENTITY_HULL_SLOTS,
     'container-t1': ENTITY_HULL_SLOTS,

package/src/data/metadata.ts

@@ -197,8 +197,8 @@ export const itemMetadata: Record<number, ItemMetadata> = {
         color: '#B877FF',
     },
     10105: {
-        name: 'Storage',
-        description: 'Expands cargo capacity based on hull material quality.',
+        name: 'Cargo Bay',
+        description: 'Expanded cargo storage with reinforced internal holds.',
         color: '#8B7355',
     },
     10106: {
@@ -214,9 +214,8 @@ export const itemMetadata: Record<number, ItemMetadata> = {
         color: '#9be4ff',
     },
     10108: {
-        name: 'Battery',
-        description:
-            'Extends energy capacity. Stores additional charge produced by generators, letting builds chain more high-drain actions between recharges.',
+        name: 'Battery Bank',
+        description: 'Stores additional charge produced by generators.',
         color: '#4ADBFF',
     },
 

package/src/data/recipes.json

@@ -450,11 +450,11 @@
     "outputMass": 960000,
     "inputs": [
       {
-        "itemId": 10008,
+        "itemId": 10009,
         "quantity": 300
       },
       {
-        "itemId": 10009,
+        "itemId": 10006,
         "quantity": 300
       }
     ],
@@ -462,7 +462,7 @@
       {
         "sources": [
           {
-            "inputIndex": 1,
+            "inputIndex": 0,
             "statIndex": 0
           }
         ]
@@ -470,8 +470,8 @@
       {
         "sources": [
           {
-            "inputIndex": 0,
-            "statIndex": 1
+            "inputIndex": 1,
+            "statIndex": 0
           }
         ]
       }

package/src/derivation/capabilities.test.ts

@@ -20,8 +20,8 @@ function makeGathererStats(strength: number, tolerance: number, conductivity: nu
     return encodeStats([strength, tolerance, conductivity, 0])
 }
 
-function makeCrafterStats(reactivity: number, fineness: number): bigint {
-    return encodeStats([reactivity, fineness])
+function makeCrafterStats(reactivity: number, conductivity: number): bigint {
+    return encodeStats([reactivity, conductivity])
 }
 
 function makeLoaderStats(insulation: number, plasticity: number): bigint {
@@ -92,7 +92,7 @@ test('computeEntityCapabilities emits crafterLanes alongside legacy crafter sum'
     expect(result.crafterLanes!.length).toBe(1)
     expect(result.crafterLanes![0].slotIndex).toBe(0)
 
-    const caps = computeCrafterCapabilities({reactivity: 400, fineness: 300})
+    const caps = computeCrafterCapabilities({reactivity: 400, conductivity: 300})
     const expectedSpeed = applySlotMultiplier(caps.speed, 120)
     expect(result.crafterLanes![0].speed).toBe(expectedSpeed)
     expect(result.crafterLanes![0].drain).toBe(caps.drain)

package/src/derivation/capabilities.ts

@@ -107,11 +107,11 @@ export function computeCrafterCapabilities(stats: Record<string, number>): {
     drain: number
 } {
     const rea = stats.reactivity
-    const fin = stats.fineness
+    const con = stats.conductivity
 
     return {
         speed: 100 + Math.floor((rea * 4) / 5),
-        drain: Math.max(5, 30 - Math.floor(fin / 33)),
+        drain: Math.max(5, 30 - Math.floor(con / 33)),
     }
 }
 
@@ -131,23 +131,28 @@ export function computeHaulerCapabilities(stats: Record<string, number>): {
     }
 }
 
-export function computeStorageCapabilities(
-    stats: Record<string, number>,
-    baseCapacity: number
-): {
-    capacityBonus: number
+export function computeStorageCapabilities(stats: Record<string, number>): {
+    capacity: number
 } {
-    const strength = stats.strength
-    const density = stats.density
-    const hardness = stats.hardness
-    const cohesion = stats.cohesion
+    const strength = stats.strength ?? 0
+    const density = stats.density ?? 0
+    const hardness = stats.hardness ?? 0
+    const cohesion = stats.cohesion ?? 0
 
     const statSum = strength + density + hardness + cohesion
-    const capacityBonus = Math.floor(
-        (baseCapacity * (10 + Math.floor((statSum * 10) / 2997))) / 100
-    )
+    return {capacity: 10_000_000 + Math.floor((statSum * 50_000_000) / 3996)}
+}
+
+export function computeBatteryCapabilities(stats: Record<string, number>): {
+    capacity: number
+} {
+    const volatility = stats.volatility ?? 0
+    const thermal = stats.thermal ?? 0
+    const plasticity = stats.plasticity ?? 0
+    const insulation = stats.insulation ?? 0
 
-    return {capacityBonus}
+    const statSum = volatility + thermal + plasticity + insulation
+    return {capacity: 2_500 + Math.floor((statSum * 7_500) / 3996)}
 }
 
 import {
@@ -174,6 +179,7 @@ import {getItem} from '../data/catalog'
 import {decodeCraftedItemStats} from './crafting'
 import {
     applySlotMultiplier,
+    applySlotMultiplierUint32,
     clampUint16,
     clampUint32,
     getSlotAmp,
@@ -278,7 +284,7 @@ export function computeEntityCapabilities(
     let maxGathDepth = 0
     let hasGatherer = false
 
-    let totalStorageBonus = 0
+    let totalStorageCapacity = 0
     const baseCapacity = computeBaseCapacity(itemId, stats)
     let installedModuleMass = 0
 
@@ -294,8 +300,7 @@ export function computeEntityCapabilities(
     let totalWarpRange = 0
     let hasWarp = false
 
-    let totalBatteryStatSum = 0
-    let batteryCount = 0
+    let totalBatteryCapacity = 0
 
     const gathererLanes: GathererLaneEntry[] = []
     const crafterLanes: CrafterLaneEntry[] = []
@@ -346,8 +351,8 @@ export function computeEntityCapabilities(
                 outputPct: amp,
             })
         } else if (modType === MODULE_STORAGE) {
-            const caps = computeStorageCapabilities(decodedStats, baseCapacity)
-            totalStorageBonus += caps.capacityBonus
+            const caps = computeStorageCapabilities(decodedStats)
+            totalStorageCapacity += applySlotMultiplierUint32(caps.capacity, amp)
         } else if (modType === MODULE_CRAFTER) {
             hasCrafter = true
             const caps = computeCrafterCapabilities(decodedStats)
@@ -372,24 +377,18 @@ export function computeEntityCapabilities(
             const caps = computeWarpCapabilities(decodedStats)
             totalWarpRange += applySlotMultiplier(caps.range, amp)
         } else if (modType === MODULE_BATTERY) {
-            batteryCount++
-            const vol = decodedStats.volatility ?? 0
-            const thm = decodedStats.thermal ?? 0
-            const pla = decodedStats.plasticity ?? 0
-            const ins = decodedStats.insulation ?? 0
-            totalBatteryStatSum += vol + thm + pla + ins
+            const caps = computeBatteryCapabilities(decodedStats)
+            totalBatteryCapacity += applySlotMultiplierUint32(caps.capacity, amp)
         }
     }
 
-    if (hasGenerator && batteryCount > 0) {
-        const genCapBase = totalGenCapacity
-        const bonusPctNum = 10 * batteryCount + Math.floor((totalBatteryStatSum * 10) / 2997)
-        totalGenCapacity += Math.floor((genCapBase * bonusPctNum) / 100)
+    if (hasGenerator && totalBatteryCapacity > 0) {
+        totalGenCapacity += totalBatteryCapacity
     }
 
     const result: ComputedCapabilities = {
         hullmass: computeBaseHullmass(stats) + installedModuleMass,
-        capacity: baseCapacity + totalStorageBonus,
+        capacity: clampUint32(baseCapacity + totalStorageCapacity),
     }
 
     if (hasEngine) {

package/src/entities/slot-multiplier.ts

@@ -34,6 +34,10 @@ export function applySlotMultiplier(value: number, outputPct: number): number {
     return clampUint16(Math.floor((value * outputPct) / 100))
 }
 
+export function applySlotMultiplierUint32(value: number, outputPct: number): number {
+    return clampUint32(Math.floor((value * outputPct) / 100))
+}
+
 export function getSlotAmp(layout: EntitySlot[], slotIndex: number): number {
     return layout[slotIndex]?.outputPct ?? 100
 }

package/src/index-module.ts

@@ -191,7 +191,7 @@ export type {
     HasScheduleAndLocation,
 } from './travel/travel'
 
-export {planRoute, sdkSystemGraph} from './travel/route-planner'
+export {planRoute, sdkSystemGraph, MAX_LEGS} from './travel/route-planner'
 export type {
     Coord,
     Neighbor,
@@ -379,6 +379,7 @@ export {
     computeCrafterCapabilities,
     computeWarehouseHullCapabilities,
     computeStorageCapabilities,
+    computeBatteryCapabilities,
     computeContainerCapabilities,
     computeContainerT2Capabilities,
     computeWarpCapabilities,

package/src/nft/buildImmutableData.ts

@@ -2,6 +2,7 @@ import {Serializer} from '@wharfkit/antelope'
 import {getItem} from '../data/catalog'
 import {
     getModuleCapabilityType,
+    MODULE_BATTERY,
     MODULE_CRAFTER,
     MODULE_ENGINE,
     MODULE_GATHERER,
@@ -26,6 +27,8 @@ import {
     computeGathererYield,
     computeGeneratorCap,
     computeGeneratorRech,
+    computeCargoBayCapacity,
+    computeBatteryBankCapacity,
     computeHaulerCapacity,
     computeHaulerDrain,
     computeHaulerEfficiency,
@@ -224,11 +227,11 @@ export function buildModuleImmutable(
         }
         case MODULE_CRAFTER: {
             const rea = decodeStat(stats, 0)
-            const fin = decodeStat(stats, 1)
+            const con = decodeStat(stats, 1)
             base.push({first: 'reactivity', second: ['uint16', rea]})
-            base.push({first: 'fineness', second: ['uint16', fin]})
+            base.push({first: 'conductivity', second: ['uint16', con]})
             base.push({first: 'speed', second: ['uint16', computeCrafterSpeed(rea)]})
-            base.push({first: 'drain', second: ['uint16', computeCrafterDrain(fin)]})
+            base.push({first: 'drain', second: ['uint16', computeCrafterDrain(con)]})
             break
         }
         case MODULE_STORAGE: {
@@ -236,14 +239,28 @@ export function buildModuleImmutable(
             const den = decodeStat(stats, 1)
             const hrd = decodeStat(stats, 2)
             const com = decodeStat(stats, 3)
-            const sum = str + den + hrd + com
             base.push({first: 'strength', second: ['uint16', str]})
             base.push({first: 'density', second: ['uint16', den]})
             base.push({first: 'hardness', second: ['uint16', hrd]})
             base.push({first: 'cohesion', second: ['uint16', com]})
             base.push({
-                first: 'capacity_bonus_pct',
-                second: ['uint16', 10 + Math.floor((sum * 10) / 2997)],
+                first: 'capacity',
+                second: ['uint32', computeCargoBayCapacity(str, den, hrd, com)],
+            })
+            break
+        }
+        case MODULE_BATTERY: {
+            const vol = decodeStat(stats, 0)
+            const thm = decodeStat(stats, 1)
+            const pla = decodeStat(stats, 2)
+            const ins = decodeStat(stats, 3)
+            base.push({first: 'volatility', second: ['uint16', vol]})
+            base.push({first: 'thermal', second: ['uint16', thm]})
+            base.push({first: 'plasticity', second: ['uint16', pla]})
+            base.push({first: 'insulation', second: ['uint16', ins]})
+            base.push({
+                first: 'capacity',
+                second: ['uint32', computeBatteryBankCapacity(vol, thm, pla, ins)],
             })
             break
         }

package/src/nft/description.ts

@@ -4,6 +4,7 @@ import {
     MODULE_ENGINE,
     MODULE_GATHERER,
     MODULE_GENERATOR,
+    MODULE_BATTERY,
     MODULE_HAULER,
     MODULE_LOADER,
     MODULE_STORAGE,
@@ -19,6 +20,7 @@ import {
     ITEM_GATHERER_T1,
     ITEM_GENERATOR_T1,
     ITEM_HAULER_T1,
+    ITEM_BATTERY_T1,
     ITEM_LOADER_T1,
     ITEM_SHIP_T1_PACKED,
     ITEM_STORAGE_T1,
@@ -75,6 +77,18 @@ export const computeHaulerCapacity = (fin: number): number => Math.max(1, 1 + id
 export const computeHaulerEfficiency = (con: number): number => 2000 + con * 6
 export const computeHaulerDrain = (com: number): number => Math.max(3, 15 - idiv(com, 80))
 export const computeWarpRange = (stat: number): number => 100 + stat * 3
+export const computeCargoBayCapacity = (
+    strength: number,
+    density: number,
+    hardness: number,
+    cohesion: number
+): number => 10_000_000 + idiv((strength + density + hardness + cohesion) * 50_000_000, 3996)
+export const computeBatteryBankCapacity = (
+    volatility: number,
+    thermal: number,
+    plasticity: number,
+    insulation: number
+): number => 2_500 + idiv((volatility + thermal + plasticity + insulation) * 7_500, 3996)
 
 export function entityDisplayName(itemId: number): string {
     switch (itemId) {
@@ -108,11 +122,13 @@ export function moduleDisplayName(itemId: number): string {
         case ITEM_CRAFTER_T1:
             return 'Crafter'
         case ITEM_STORAGE_T1:
-            return 'Storage'
+            return 'Cargo Bay'
         case ITEM_HAULER_T1:
             return 'Hauler'
         case ITEM_WARP_T1:
             return 'Warp'
+        case ITEM_BATTERY_T1:
+            return 'Battery Bank'
         default:
             return 'Module'
     }
@@ -160,17 +176,16 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
         }
         case MODULE_CRAFTER: {
             const rea = decodeStat(stats, 0)
-            const com = decodeStat(stats, 1)
-            out += `  Speed ${computeCrafterSpeed(rea)}  Drain ${computeCrafterDrain(com)}`
+            const con = decodeStat(stats, 1)
+            out += `  Speed ${computeCrafterSpeed(rea)}  Drain ${computeCrafterDrain(con)}`
             break
         }
         case MODULE_STORAGE: {
             const str = decodeStat(stats, 0)
-            const fin = decodeStat(stats, 2)
-            const sat = decodeStat(stats, 3)
-            const sum = str + fin + sat
-            const pct = 10 + idiv(sum * 10, 2997)
-            out += `  +${pct}% capacity`
+            const den = decodeStat(stats, 1)
+            const hrd = decodeStat(stats, 2)
+            const com = decodeStat(stats, 3)
+            out += `  Cargo Capacity ${computeCargoBayCapacity(str, den, hrd, com)}`
             break
         }
         case MODULE_HAULER: {
@@ -185,6 +200,14 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             out += `  Range ${computeWarpRange(stat)}`
             break
         }
+        case MODULE_BATTERY: {
+            const vol = decodeStat(stats, 0)
+            const thm = decodeStat(stats, 1)
+            const pla = decodeStat(stats, 2)
+            const ins = decodeStat(stats, 3)
+            out += `  Energy Capacity ${computeBatteryBankCapacity(vol, thm, pla, ins)}`
+            break
+        }
     }
     return out
 }

package/src/resolution/describe-module.ts

@@ -81,9 +81,15 @@ const TEMPLATES: Record<string, TemplateSpec> = {
     },
     storage: {
         id: 'module.storage.description',
-        template: 'boosts cargo capacity by {bonus}%',
-        params: [['bonus', 'Capacity Bonus']],
-        highlightKeys: ['bonus'],
+        template: 'adds {capacity} cargo capacity',
+        params: [['capacity', 'Cargo Capacity']],
+        highlightKeys: ['capacity'],
+    },
+    energy: {
+        id: 'module.energy-capacity.description',
+        template: 'adds {capacity} energy capacity',
+        params: [['capacity', 'Energy Capacity']],
+        highlightKeys: ['capacity'],
     },
     hauler: {
         id: 'module.hauler.description',
@@ -124,8 +130,10 @@ export function describeModuleForItem(resolved: ResolvedItem): ModuleDescription
 }
 
 export function describeModuleForSlot(slot: ResolvedModuleSlot): ModuleDescription | null {
-    if (!slot.installed || !slot.name || !slot.attributes) return null
-    return describeModule({capability: slot.name, attributes: slot.attributes})
+    if (!slot.installed || !slot.attributes) return null
+    const capability = slot.capability ?? slot.name
+    if (!capability) return null
+    return describeModule({capability, attributes: slot.attributes})
 }
 
 export function renderDescription(

package/src/resolution/resolve-item.ts

@@ -9,6 +9,7 @@ import {
     isModuleItem,
     MODULE_CRAFTER,
     MODULE_ENGINE,
+    MODULE_BATTERY,
     MODULE_GATHERER,
     MODULE_GENERATOR,
     MODULE_HAULER,
@@ -19,6 +20,7 @@ import {decodeCraftedItemStats, decodeStat} from '../derivation/crafting'
 import {getStatDefinitions} from '../derivation/stats'
 import {
     computeCrafterCapabilities,
+    computeBatteryCapabilities,
     computeEngineCapabilities,
     computeGathererCapabilities,
     computeGeneratorCapabilities,
@@ -28,7 +30,9 @@ import {
     computeWarehouseHullCapabilities,
     computeContainerCapabilities,
     computeContainerT2Capabilities,
+    computeStorageCapabilities,
 } from '../derivation/capabilities'
+import {applySlotMultiplierUint32} from '../entities/slot-multiplier'
 import {categoryColors, componentIcon, itemAbbreviations, moduleIcon} from '../data/colors'
 import type {ServerContract} from '../contracts'
 import {
@@ -58,6 +62,7 @@ export type ResolvedItemType = 'resource' | 'component' | 'module' | 'entity'
 
 export interface ResolvedModuleSlot {
     name?: string
+    capability?: string
     installed: boolean
     attributes?: {label: string; value: number}[]
 }
@@ -152,7 +157,8 @@ function resolveComponent(id: number, stats?: UInt64Type): ResolvedItem {
 function computeCapabilityGroup(
     moduleType: number,
     stats: Record<string, number>,
-    tier: number
+    tier: number,
+    outputPct = 100
 ): ResolvedAttributeGroup | undefined {
     switch (moduleType) {
         case MODULE_ENGINE: {
@@ -219,13 +225,28 @@ function computeCapabilityGroup(
             }
         }
         case MODULE_STORAGE: {
-            const str = stats.strength
-            const den = stats.density
-            const hrd = stats.hardness
-            const com = stats.cohesion
-            const statSum = str + den + hrd + com
-            const pct = 10 + Math.floor((statSum * 10) / 2997)
-            return {capability: 'Storage', attributes: [{label: 'Capacity Bonus', value: pct}]}
+            const caps = computeStorageCapabilities(stats)
+            return {
+                capability: 'Storage',
+                attributes: [
+                    {
+                        label: 'Cargo Capacity',
+                        value: applySlotMultiplierUint32(caps.capacity, outputPct),
+                    },
+                ],
+            }
+        }
+        case MODULE_BATTERY: {
+            const caps = computeBatteryCapabilities(stats)
+            return {
+                capability: 'Energy',
+                attributes: [
+                    {
+                        label: 'Energy Capacity',
+                        value: applySlotMultiplierUint32(caps.capacity, outputPct),
+                    },
+                ],
+            }
         }
         default:
             return undefined
@@ -321,9 +342,10 @@ function resolveEntity(
                 } catch {
                     modName = itemMetadata[modItemId]?.name ?? 'Module'
                 }
-                const group = computeCapabilityGroup(modType, decodedStats, modTier)
+                const group = computeCapabilityGroup(modType, decodedStats, modTier, slot.outputPct)
                 return {
                     name: modName,
+                    capability: group?.capability,
                     installed: true,
                     attributes: group?.attributes,
                 }

package/src/travel/route-planner.ts

@@ -32,6 +32,7 @@ export interface RouteFailure {
     reason: RouteFailureReason
     furthest?: Coord
     legsNeeded?: number
+    partialWaypoints?: Coord[]
 }
 
 export type RouteResult = RoutePlan | RouteFailure
@@ -50,11 +51,13 @@ const key = (c: Coord): string => `${c.x},${c.y}`
 const sameCoord = (a: Coord, b: Coord): boolean => a.x === b.x && a.y === b.y
 const dist = (a: Coord, b: Coord): number => Math.hypot(a.x - b.x, a.y - b.y)
 
+export const MAX_LEGS = 12
+
 export function planRoute(params: PlanRouteParams): RouteResult {
     const {origin, dest, perLegReach, graph} = params
     const corridorSlack = params.corridorSlack ?? perLegReach
     const nodeBudget = params.nodeBudget ?? 5000
-    const maxLegs = params.maxLegs ?? 12
+    const maxLegs = params.maxLegs ?? MAX_LEGS
 
     if (!graph.hasSystem(dest)) {
         return {ok: false, reason: 'empty-destination'}
@@ -122,9 +125,32 @@ export function planRoute(params: PlanRouteParams): RouteResult {
     }
 
     if (cappedByMaxLegs) {
-        return {ok: false, reason: 'max-legs', furthest}
+        return {
+            ok: false,
+            reason: 'max-legs',
+            furthest,
+            partialWaypoints: reconstructWaypoints(cameFrom, origin, furthest),
+        }
+    }
+    return {
+        ok: false,
+        reason: 'no-path',
+        furthest,
+        partialWaypoints: reconstructWaypoints(cameFrom, origin, furthest),
+    }
+}
+
+function reconstructWaypoints(cameFrom: Map<string, Coord>, origin: Coord, target: Coord): Coord[] {
+    if (sameCoord(target, origin)) return []
+    const path: Coord[] = [target]
+    let cur = target
+    while (!sameCoord(cur, origin)) {
+        const prev = cameFrom.get(key(cur))
+        if (!prev) break
+        path.unshift(prev)
+        cur = prev
     }
-    return {ok: false, reason: 'no-path', furthest}
+    return path.slice(1)
 }
 
 function reconstruct(cameFrom: Map<string, Coord>, origin: Coord, dest: Coord): RoutePlan {