@shipload/sdk 1.0.0-next.48 → 1.0.0-next.49

package/src/planner/planner.test.ts

@@ -1,9 +1,14 @@
 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'
+import {
+    planParallelTransfer,
+    type GatherPlanEntity,
+    gatherEnergyCost,
+    splitCost,
+    maxQtyForCharge,
+    buildGatherPlan,
+} from './index'
 
 function gathererLane(
     slotIndex: number,
@@ -63,257 +68,258 @@ function entity(overrides: EntityOverrides = {}): GatherPlanEntity {
 
 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
+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({
-            gatherer_lanes: [
-                gathererLane(0, YIELD1, DRAIN, DEPTH),
-                gathererLane(1, YIELD2, DRAIN, DEPTH),
-            ],
-            generator: energyStats(10000, 100),
-            energy: 10000,
+            loader_lanes: [loaderLane(0, 500, THRUST1), loaderLane(1, 500, THRUST2)],
         })
 
-        const plan = planParallelGather(e, {quantity: QUANTITY}, STRATUM, NOW)
+        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(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)
+        expect(q2 / q1).toBeCloseTo(THRUST2 / THRUST1, 0)
     })
 
-    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,
-        })
+    test('no loader lanes: returns empty plan', () => {
+        const plan = planParallelTransfer(entity({loader_lanes: []}), {quantity: 10})
+        expect(plan).toHaveLength(0)
+    })
 
-        const plan = planParallelGather(e, 'max', 0, NOW)
+    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)
         }
     })
+})
 
-    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)
+describe('cost helpers', () => {
+    const STRATUM = 100
+    const ITEM_MASS = 1000
+    const RICHNESS = 500
 
-        // 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('gatherEnergyCost is 0 for non-positive quantity and positive otherwise', () => {
+        const lane = gathererLane(0, 700, 1250, 5000)
+        expect(gatherEnergyCost(lane, 0, STRATUM, ITEM_MASS, RICHNESS)).toBe(0)
+        expect(gatherEnergyCost(lane, 100, STRATUM, ITEM_MASS, RICHNESS)).toBeGreaterThan(0)
     })
 
-    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,
-        })
+    test('splitCost across two lanes is monotonic non-decreasing in quantity', () => {
+        const reaching = [gathererLane(0, 700, 1250, 5000), gathererLane(1, 700, 1250, 5000)]
+        const c100 = splitCost(reaching, 100, STRATUM, ITEM_MASS, RICHNESS)
+        const c200 = splitCost(reaching, 200, STRATUM, ITEM_MASS, RICHNESS)
+        expect(c200).toBeGreaterThanOrEqual(c100)
+    })
 
-        const plan = planParallelGather(e, {quantity: 120}, 0, NOW)
+    test('maxQtyForCharge returns hi when the whole batch fits the charge', () => {
+        const reaching = [gathererLane(0, 700, 1250, 5000)]
+        // capacity huge → the full 500 fits
+        expect(maxQtyForCharge(reaching, 500, 1_000_000, STRATUM, ITEM_MASS, RICHNESS)).toBe(500)
+    })
 
-        expect(plan).toHaveLength(1)
-        expect(plan[0].slot).toBe(0)
-        expect(plan[0].quantity).toBe(50)
+    test('maxQtyForCharge finds the boundary: result fits, result+1 does not', () => {
+        const reaching = [gathererLane(0, 700, 1250, 5000)]
+        const capacity = 40
+        const q = maxQtyForCharge(reaching, 100_000, capacity, STRATUM, ITEM_MASS, RICHNESS)
+        expect(splitCost(reaching, q, STRATUM, ITEM_MASS, RICHNESS)).toBeLessThanOrEqual(capacity)
+        expect(splitCost(reaching, q + 1, STRATUM, ITEM_MASS, RICHNESS)).toBeGreaterThan(capacity)
     })
+})
 
-    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),
-                    }),
-                ],
-            },
-        })
+describe('buildGatherPlan', () => {
+    const STRATUM = 100
+    const OPTS = {
+        richness: 500,
+        itemMass: 1000,
+        holdRoom: 1_000_000,
+        reserveRemaining: 1_000_000,
+        now: NOW,
+    }
 
+    test('single cycle when the target fits one charge and energy is full', () => {
         const e = entity({
-            gatherer_lanes: [gathererLane(0, 100, 10000, 5000)],
-            generator: energyStats(10000, 1),
-            energy: 10000,
-            lanes: [queued],
+            gatherer_lanes: [gathererLane(0, 700, 1250, 5000)],
+            generator: energyStats(1200, 2),
+            energy: 1200,
         })
-
-        const plan = planParallelGather(e, {quantity: 120}, 0, NOW)
-
-        expect(plan).toHaveLength(1)
-        expect(plan[0].quantity).toBe(30)
+        const plan = buildGatherPlan(e, STRATUM, {quantity: 100}, OPTS)
+        expect(plan.cycleCount).toBe(1)
+        expect(plan.totalOre).toBe(100)
+        expect(plan.cycles[0].rechargeBefore).toBe(false)
+        expect(plan.cycles[0].limpets).toHaveLength(1)
+        expect(plan.cycles[0].limpets[0].quantity).toBe(100)
+        expect(plan.cap).toBe('requested')
     })
 
-    test('stratum filter: shallow lane excluded, only deep lane used', () => {
+    test('two limpets split one charge proportional to yield, finish within 1s of each other', () => {
         const e = entity({
-            gatherer_lanes: [gathererLane(0, 200, 500, 500), gathererLane(1, 300, 500, 5000)],
-            generator: energyStats(10000, 100),
-            energy: 10000,
+            gatherer_lanes: [gathererLane(0, 200, 500, 5000), gathererLane(1, 400, 500, 5000)],
+            generator: energyStats(60_000, 2),
+            energy: 60_000,
         })
-
-        const plan = planParallelGather(e, {quantity: 10}, 2000, NOW)
-
-        expect(plan).toHaveLength(1)
-        expect(plan[0].slot).toBe(1)
+        const plan = buildGatherPlan(e, STRATUM, {quantity: 60}, OPTS)
+        expect(plan.cycleCount).toBe(1)
+        const [a, b] = plan.cycles[0].limpets
+        expect(a.quantity + b.quantity).toBe(60)
+        expect(b.quantity).toBeGreaterThan(a.quantity) // higher yield gets more
+        expect(Math.abs(a.durationSeconds - b.durationSeconds)).toBeLessThanOrEqual(2)
     })
 
-    test('no reaching gatherers throws', () => {
+    test('multi-cycle: fills beyond one charge; totalOre equals fill target; each cycle fits the charge', () => {
+        const CAP = 40
         const e = entity({
-            gatherer_lanes: [gathererLane(0, 200, 500, 100)],
-            generator: energyStats(10000, 100),
-            energy: 10000,
+            gatherer_lanes: [gathererLane(0, 700, 1250, 5000)],
+            generator: energyStats(CAP, 2),
+            energy: CAP,
         })
+        const plan = buildGatherPlan(e, STRATUM, {quantity: 500}, OPTS)
+        expect(plan.cycleCount).toBeGreaterThan(1)
+        expect(plan.totalOre).toBe(500)
+        // every cycle's summed gather cost fits one full charge
+        for (const c of plan.cycles) {
+            const cost = splitCost(
+                e.gatherer_lanes,
+                c.batchOre,
+                STRATUM,
+                OPTS.itemMass,
+                OPTS.richness
+            )
+            expect(cost).toBeLessThanOrEqual(CAP)
+        }
+        // cycles after the first recharge to full
+        expect(plan.cycles.slice(1).every((c) => c.rechargeBefore)).toBe(true)
+        // limpet quantities across all cycles sum to the target
+        const gathered = plan.cycles.flatMap((c) => c.limpets).reduce((s, l) => s + l.quantity, 0)
+        expect(gathered).toBe(500)
+    })
 
-        expect(() => planParallelGather(e, {quantity: 10}, 2000, NOW)).toThrow(
-            'no gatherer reaches this stratum'
-        )
+    test('cap reasons: hold binds, reserve binds, requested binds', () => {
+        const e = entity({
+            gatherer_lanes: [gathererLane(0, 700, 1250, 5000)],
+            generator: energyStats(60_000, 2),
+            energy: 60_000,
+        })
+        expect(
+            buildGatherPlan(e, STRATUM, 'max', {...OPTS, holdRoom: 300, reserveRemaining: 9999}).cap
+        ).toBe('hold')
+        expect(
+            buildGatherPlan(e, STRATUM, 'max', {...OPTS, holdRoom: 9999, reserveRemaining: 200}).cap
+        ).toBe('reserve')
+        expect(buildGatherPlan(e, STRATUM, {quantity: 50}, OPTS).cap).toBe('requested')
     })
 
-    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,
+    test('total ETA sums per-cycle recharge + gather seconds', () => {
+        const CAP = 40
+        const e = entity({
+            gatherer_lanes: [gathererLane(0, 700, 1250, 5000)],
+            generator: energyStats(CAP, 2),
+            energy: CAP,
         })
-        const eDouble = entity({
+        const plan = buildGatherPlan(e, STRATUM, {quantity: 500}, OPTS)
+        const expected = plan.cycles.reduce((s, c) => s + c.rechargeSeconds + c.gatherSeconds, 0)
+        expect(plan.totalSeconds).toBe(expected)
+    })
+
+    test('excludes limpets that cannot reach the stratum and warns', () => {
+        const e = entity({
             gatherer_lanes: [
-                gathererLane(0, YIELD, DRAIN, DEPTH),
-                gathererLane(1, YIELD, DRAIN, DEPTH),
+                gathererLane(0, 700, 1250, 5000), // reaches 100
+                gathererLane(1, 700, 1250, 50), // does not reach 100
             ],
-            generator: energyStats(10000, 100),
-            energy: 10000,
+            generator: energyStats(60_000, 2),
+            energy: 60_000,
         })
-
-        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)
+        const plan = buildGatherPlan(e, STRATUM, {quantity: 100}, OPTS)
+        expect(plan.cycles[0].limpets).toHaveLength(1)
+        expect(plan.cycles[0].limpets[0].slot).toBe(0)
+        expect(plan.warnings.some((w) => w.includes("can't reach"))).toBe(true)
     })
-})
-
-describe('planParallelTransfer', () => {
-    test('two loader lanes: quantities proportional to thrust, sums to target', () => {
-        const THRUST1 = 100
-        const THRUST2 = 200
-        const QUANTITY = 90
 
+    test('reports structured limpet reach counts (all reaching)', () => {
         const e = entity({
-            loader_lanes: [loaderLane(0, 500, THRUST1), loaderLane(1, 500, THRUST2)],
+            gatherer_lanes: [gathererLane(0, 700, 1250, 5000), gathererLane(1, 700, 1250, 5000)],
+            generator: energyStats(60_000, 2),
+            energy: 60_000,
         })
+        const plan = buildGatherPlan(e, STRATUM, {quantity: 50}, OPTS)
+        expect(plan.totalLimpets).toBe(2)
+        expect(plan.reachingCount).toBe(2)
+    })
 
-        const plan = planParallelTransfer(e, {quantity: QUANTITY})
-
-        expect(plan).toHaveLength(2)
-        expect(plan.reduce((s, p) => s + p.quantity, 0)).toBe(QUANTITY)
+    test('reachingCount excludes limpets that cannot reach the stratum', () => {
+        const e = entity({
+            gatherer_lanes: [
+                gathererLane(0, 700, 1250, 5000), // reaches 100
+                gathererLane(1, 700, 1250, 50), // does not reach 100
+            ],
+            generator: energyStats(60_000, 2),
+            energy: 60_000,
+        })
+        const plan = buildGatherPlan(e, STRATUM, {quantity: 50}, OPTS)
+        expect(plan.totalLimpets).toBe(2)
+        expect(plan.reachingCount).toBe(1)
+    })
 
-        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('single-limpet ship still fills across cycles', () => {
+        const CAP = 40
+        const e = entity({
+            gatherer_lanes: [gathererLane(0, 700, 1250, 5000)],
+            generator: energyStats(CAP, 2),
+            energy: CAP,
+        })
+        const plan = buildGatherPlan(e, STRATUM, {quantity: 300}, OPTS)
+        expect(plan.cycles.every((c) => c.limpets.length === 1)).toBe(true)
+        expect(plan.totalOre).toBe(300)
     })
 
-    test('no loader lanes: returns empty plan', () => {
-        const plan = planParallelTransfer(entity({loader_lanes: []}), {quantity: 10})
-        expect(plan).toHaveLength(0)
+    test('throws when no gatherer reaches the stratum', () => {
+        const e = entity({
+            gatherer_lanes: [gathererLane(0, 700, 1250, 50)],
+            generator: energyStats(1200, 2),
+            energy: 1200,
+        })
+        expect(() => buildGatherPlan(e, STRATUM, 'max', OPTS)).toThrow('no gatherer reaches')
     })
 
-    test('thrust=0 loader lane (no-loader/mobility case): returns empty plan', () => {
-        const plan = planParallelTransfer(entity({loader_lanes: [loaderLane(0, 500, 0)]}), {
-            quantity: 10,
+    test('zero fill target yields an empty plan (no cycles)', () => {
+        const e = entity({
+            gatherer_lanes: [gathererLane(0, 700, 1250, 5000)],
+            generator: energyStats(1200, 2),
+            energy: 1200,
         })
-        expect(plan).toHaveLength(0)
+        const plan = buildGatherPlan(e, STRATUM, 'max', {...OPTS, holdRoom: 0})
+        expect(plan.cycleCount).toBe(0)
+        expect(plan.totalOre).toBe(0)
+        expect(plan.cap).toBe('hold')
     })
 
-    test("'max' target: each loader lane gets >= 1 unit", () => {
+    test('first cycle skips recharge when current energy already covers the small batch', () => {
         const e = entity({
-            loader_lanes: [loaderLane(0, 500, 100), loaderLane(1, 500, 200)],
+            gatherer_lanes: [gathererLane(0, 700, 1250, 5000)],
+            generator: energyStats(60_000, 2),
+            energy: 60_000, // full
         })
-        const plan = planParallelTransfer(e, 'max')
-        expect(plan.length).toBeGreaterThan(0)
-        for (const entry of plan) {
-            expect(entry.quantity).toBeGreaterThanOrEqual(1)
-        }
+        const plan = buildGatherPlan(e, STRATUM, {quantity: 50}, OPTS)
+        expect(plan.cycles[0].rechargeBefore).toBe(false)
+        expect(plan.cycles[0].rechargeSeconds).toBe(0)
     })
 })

package/src/scheduling/unwrap.test.ts

@@ -39,6 +39,32 @@ describe('unwrap duration mirror', () => {
         expect(unwrapTransitDuration(0, {x: 0, y: 0}, {x: 9, y: 9})).toBe(0)
         expect(unwrapLoadDuration(null, 500, 3000)).toBe(0)
     })
+
+    test('load altitude is floored so ground-level (z=0) destinations are not instant', () => {
+        const loaders = {mass: 500, thrust: 200, quantity: 1}
+        const atZero = unwrapLoadDuration(loaders, 1000, 0)
+        const at800 = unwrapLoadDuration(loaders, 1000, 800)
+        expect(atZero).toBeGreaterThan(0)
+        expect(atZero).toBe(at800)
+    })
+
+    test('estimateUnwrapDuration uses worst-loader baseline when dest has no loaders', () => {
+        // IRON (101); same coords so transit is 0 and the estimate is baseline load alone
+        const item = {itemId: 101, quantity: 10, modules: [], originX: 0, originY: 0}
+        const bareDest = {loader_lanes: [], coordinates: {x: 0, y: 0, z: 800}}
+
+        const bare = estimateUnwrapDuration(bareDest, item)
+        expect(bare).toBeGreaterThan(0)
+
+        const loadedDest = {
+            loader_lanes: [{mass: 500, thrust: 200}],
+            coordinates: {x: 0, y: 0, z: 800},
+        }
+        const loaded = estimateUnwrapDuration(loadedDest, item)
+        expect(loaded).toBeLessThanOrEqual(bare)
+
+        expect(unwrapLoadDuration(null, 500, 3000)).toBe(0)
+    })
 })
 
 test('incomingHoldMass sums incoming-kind hold mass', () => {

package/src/scheduling/unwrap.ts

@@ -7,6 +7,9 @@ import {taskCargoEffect} from './availability'
 import {candidateLaneCompletesAt} from './lanes'
 
 const NFT_TRANSIT_THRUST = 400
+const BASELINE_LOADER: DerivedLoaders = {mass: 2000, thrust: 1, quantity: 1}
+// ground-level entities (warehouses, z=0) still incur a base orbital climb of load effort
+const MIN_LOAD_Z = 800
 
 export interface DerivedLoaders {
     mass: number
@@ -67,7 +70,7 @@ export function unwrapLoadDuration(
 ): number {
     if (!loaders || itemMass <= 0) return 0
     const total = itemMass + loaders.mass
-    const flight = flightTime(destZ, acceleration(loaders.thrust, total))
+    const flight = flightTime(Math.max(destZ, MIN_LOAD_Z), acceleration(loaders.thrust, total))
     return Math.floor(flight / loaders.quantity)
 }
 
@@ -92,7 +95,7 @@ export function estimateUnwrapDuration(dest: UnwrapDestination, item: UnwrapItem
             modules: item.modules,
         })
     )
-    const loaders = derivedLoaders(dest.loader_lanes)
+    const loaders = derivedLoaders(dest.loader_lanes) ?? BASELINE_LOADER
     const dz = Number(dest.coordinates.z ?? 0)
     const load = unwrapLoadDuration(loaders, itemMass, dz)
     const transit = unwrapTransitDuration(