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

package/lib/shipload.js

@@ -3727,11 +3727,11 @@ var recipes = [
 		outputMass: 960000,
 		inputs: [
 			{
-				itemId: 10008,
+				itemId: 10009,
 				quantity: 300
 			},
 			{
-				itemId: 10009,
+				itemId: 10006,
 				quantity: 300
 			}
 		],
@@ -3739,7 +3739,7 @@ var recipes = [
 			{
 				sources: [
 					{
-						inputIndex: 1,
+						inputIndex: 0,
 						statIndex: 0
 					}
 				]
@@ -3747,8 +3747,8 @@ var recipes = [
 			{
 				sources: [
 					{
-						inputIndex: 0,
-						statIndex: 1
+						inputIndex: 1,
+						statIndex: 0
 					}
 				]
 			}
@@ -5129,8 +5129,8 @@ const 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: {
@@ -5144,8 +5144,8 @@ const 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',
     },
     10200: {
@@ -5564,7 +5564,7 @@ function endpointInRegion(seed, R, key) {
     const oy = ((h[4] << 24) | (h[5] << 16) | (h[6] << 8) | h[7]) >>> 0;
     return { x: R.rx * WH.RSIZE + (ox % WH.RSIZE), y: R.ry * WH.RSIZE + (oy % WH.RSIZE) };
 }
-function dist(a, b) {
+function dist$1(a, b) {
     return Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2);
 }
 function wormholeOfRegion(seed, R) {
@@ -5576,7 +5576,7 @@ function wormholeOfRegion(seed, R) {
         return null;
     const A = endpointInRegion(seed, R, key);
     const B = endpointInRegion(seed, P, key);
-    if (dist(A, B) < WH.MIN_REACH)
+    if (dist$1(A, B) < WH.MIN_REACH)
         return null;
     return { A, B };
 }
@@ -13018,6 +13018,9 @@ const clampUint32 = (v) => Math.min(Math.max(Math.floor(v), 0), 4294967295);
 function applySlotMultiplier(value, outputPct) {
     return clampUint16(Math.floor((value * outputPct) / 100));
 }
+function applySlotMultiplierUint32(value, outputPct) {
+    return clampUint32(Math.floor((value * outputPct) / 100));
+}
 function getSlotAmp(layout, slotIndex) {
     return layout[slotIndex]?.outputPct ?? 100;
 }
@@ -13090,10 +13093,10 @@ function computeLoaderCapabilities(stats) {
 }
 function computeCrafterCapabilities(stats) {
     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)),
     };
 }
 function computeHaulerCapabilities(stats) {
@@ -13106,14 +13109,21 @@ function computeHaulerCapabilities(stats) {
         drain: Math.max(3, 15 - Math.floor(reflectivity / 80)),
     };
 }
-function computeStorageCapabilities(stats, baseCapacity) {
-    const strength = stats.strength;
-    const density = stats.density;
-    const hardness = stats.hardness;
-    const cohesion = stats.cohesion;
+function computeStorageCapabilities(stats) {
+    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 { capacityBonus };
+    return { capacity: 10000000 + Math.floor((statSum * 50000000) / 3996) };
+}
+function computeBatteryCapabilities(stats) {
+    const volatility = stats.volatility ?? 0;
+    const thermal = stats.thermal ?? 0;
+    const plasticity = stats.plasticity ?? 0;
+    const insulation = stats.insulation ?? 0;
+    const statSum = volatility + thermal + plasticity + insulation;
+    return { capacity: 2500 + Math.floor((statSum * 7500) / 3996) };
 }
 function computeBaseCapacity(itemId, stats) {
     switch (itemId) {
@@ -13158,7 +13168,7 @@ function computeEntityCapabilities(stats, itemId, modules, layout) {
     let totalGathDrain = 0;
     let maxGathDepth = 0;
     let hasGatherer = false;
-    let totalStorageBonus = 0;
+    let totalStorageCapacity = 0;
     const baseCapacity = computeBaseCapacity(itemId, stats);
     let installedModuleMass = 0;
     let totalCrafterSpeed = 0;
@@ -13170,8 +13180,7 @@ function computeEntityCapabilities(stats, itemId, modules, layout) {
     let hasHauler = false;
     let totalWarpRange = 0;
     let hasWarp = false;
-    let totalBatteryStatSum = 0;
-    let batteryCount = 0;
+    let totalBatteryCapacity = 0;
     const gathererLanes = [];
     const crafterLanes = [];
     const loaderLanes = [];
@@ -13224,8 +13233,8 @@ function computeEntityCapabilities(stats, itemId, modules, layout) {
             });
         }
         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;
@@ -13254,22 +13263,16 @@ function computeEntityCapabilities(stats, itemId, modules, layout) {
             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 = {
         hullmass: computeBaseHullmass$1(stats) + installedModuleMass,
-        capacity: baseCapacity + totalStorageBonus,
+        capacity: clampUint32(baseCapacity + totalStorageCapacity),
     };
     if (hasEngine) {
         result.engines = { thrust: totalThrust, drain: totalEngineDrain };
@@ -13919,6 +13922,145 @@ function validateDisplayName(input, opts = {}) {
     return { valid: true, name };
 }
 
+const key = (c) => `${c.x},${c.y}`;
+const sameCoord = (a, b) => a.x === b.x && a.y === b.y;
+const dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+const MAX_LEGS = 12;
+function planRoute(params) {
+    const { origin, dest, perLegReach, graph } = params;
+    const corridorSlack = params.corridorSlack ?? perLegReach;
+    const nodeBudget = params.nodeBudget ?? 5000;
+    const maxLegs = params.maxLegs ?? MAX_LEGS;
+    if (!graph.hasSystem(dest)) {
+        return { ok: false, reason: 'empty-destination' };
+    }
+    const straightLine = dist(origin, dest);
+    const heuristic = (c) => Math.ceil(dist(c, dest) / perLegReach);
+    const gScore = new Map([[key(origin), 0]]);
+    const cameFrom = new Map();
+    const frontier = [
+        { coord: origin, g: 0, f: heuristic(origin), remaining: straightLine },
+    ];
+    let furthest = origin;
+    let furthestRemaining = dist(origin, dest);
+    let expansions = 0;
+    let cappedByMaxLegs = false;
+    while (frontier.length > 0) {
+        let bestIdx = 0;
+        for (let i = 1; i < frontier.length; i++) {
+            const a = frontier[i];
+            const b = frontier[bestIdx];
+            if (a.f < b.f || (a.f === b.f && a.remaining < b.remaining)) {
+                bestIdx = i;
+            }
+        }
+        const current = frontier.splice(bestIdx, 1)[0];
+        if (sameCoord(current.coord, dest)) {
+            return reconstruct(cameFrom, origin, dest);
+        }
+        if (current.remaining < furthestRemaining) {
+            furthestRemaining = current.remaining;
+            furthest = current.coord;
+        }
+        if (++expansions > nodeBudget)
+            break;
+        for (const n of graph.nearby(current.coord, perLegReach)) {
+            const inCorridor = dist(origin, n.coord) + dist(n.coord, dest) <= straightLine + corridorSlack;
+            if (!inCorridor)
+                continue;
+            const tentativeG = current.g + 1;
+            if (tentativeG > maxLegs) {
+                cappedByMaxLegs = true;
+                continue;
+            }
+            const nk = key(n.coord);
+            if (tentativeG < (gScore.get(nk) ?? Infinity)) {
+                gScore.set(nk, tentativeG);
+                cameFrom.set(nk, current.coord);
+                const remaining = dist(n.coord, dest);
+                frontier.push({
+                    coord: n.coord,
+                    g: tentativeG,
+                    f: tentativeG + Math.ceil(remaining / perLegReach),
+                    remaining,
+                });
+            }
+        }
+    }
+    if (cappedByMaxLegs) {
+        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, origin, target) {
+    if (sameCoord(target, origin))
+        return [];
+    const path = [target];
+    let cur = target;
+    while (!sameCoord(cur, origin)) {
+        const prev = cameFrom.get(key(cur));
+        if (!prev)
+            break;
+        path.unshift(prev);
+        cur = prev;
+    }
+    return path.slice(1);
+}
+function reconstruct(cameFrom, origin, dest) {
+    const path = [dest];
+    let cur = dest;
+    let totalDistance = 0;
+    while (!sameCoord(cur, origin)) {
+        const prev = cameFrom.get(key(cur));
+        if (!prev)
+            break;
+        totalDistance += dist(prev, cur);
+        path.unshift(prev);
+        cur = prev;
+    }
+    const waypoints = path.slice(1);
+    return { ok: true, waypoints, legs: waypoints.length, totalDistance };
+}
+function sdkSystemGraph(seed) {
+    const s = antelope.Checksum256.from(seed);
+    return {
+        hasSystem: (c) => hasSystem(s, { x: c.x, y: c.y }),
+        nearby: (c, reachTiles) => findNearbyPlanets(s, { x: c.x, y: c.y }, reachTiles * PRECISION$1)
+            .map((d) => ({
+            coord: { x: Number(d.destination.x), y: Number(d.destination.y) },
+            dist: Number(d.distance) / PRECISION$1,
+        }))
+            .filter((n) => !(n.coord.x === c.x && n.coord.y === c.y)),
+    };
+}
+
+function computePerLegReach(s, haulCount = 0) {
+    const capacity = s.generator?.capacity;
+    const drain = s.engines?.drain;
+    if (capacity === undefined || drain === undefined || drain === 0n) {
+        throw new Error('entity has no usable engine/generator (cannot compute per-leg reach)');
+    }
+    const haulDrain = s.hauler && haulCount > 0 ? s.hauler.drain * BigInt(haulCount) : 0n;
+    return Number(capacity) / Number(drain + haulDrain);
+}
+function computeGroupPerLegReach(participants, haulCount) {
+    const movers = participants.filter((p) => p.engines !== undefined && p.engines.drain !== 0n);
+    if (movers.length === 0) {
+        throw new Error('group has no moving entity (cannot compute per-leg reach)');
+    }
+    return Math.min(...movers.map((p) => computePerLegReach(p, haulCount)));
+}
+
 function idiv(a, b) {
     return Math.floor(a / b);
 }
@@ -13957,6 +14099,8 @@ const computeHaulerCapacity = (fin) => Math.max(1, 1 + idiv(fin, 400));
 const computeHaulerEfficiency = (con) => 2000 + con * 6;
 const computeHaulerDrain$1 = (com) => Math.max(3, 15 - idiv(com, 80));
 const computeWarpRange = (stat) => 100 + stat * 3;
+const computeCargoBayCapacity = (strength, density, hardness, cohesion) => 10000000 + idiv((strength + density + hardness + cohesion) * 50000000, 3996);
+const computeBatteryBankCapacity = (volatility, thermal, plasticity, insulation) => 2500 + idiv((volatility + thermal + plasticity + insulation) * 7500, 3996);
 function entityDisplayName(itemId) {
     switch (itemId) {
         case ITEM_SHIP_T1_PACKED:
@@ -13988,11 +14132,13 @@ function moduleDisplayName(itemId) {
         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';
     }
@@ -14034,17 +14180,16 @@ function formatModuleLine(slot, itemId, stats) {
         }
         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: {
@@ -14059,6 +14204,14 @@ function formatModuleLine(slot, itemId, stats) {
             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;
 }
@@ -15381,19 +15534,21 @@ const capabilityNames = [
     'Crafter',
     'Launch',
     'Hauler',
-    'Battery',
 ];
 const capabilityAttributes = [
     { 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' },
@@ -15431,11 +15586,6 @@ const capabilityAttributes = [
         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']);
 function isInvertedAttribute(attribute) {
@@ -15476,10 +15626,10 @@ const SLOT_FORMULAS = {
         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' },
@@ -15490,10 +15640,10 @@ const SLOT_FORMULAS = {
         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,
@@ -15737,7 +15887,7 @@ function resolveComponent(id, stats) {
         stats: resolvedStats,
     };
 }
-function computeCapabilityGroup(moduleType, stats, tier) {
+function computeCapabilityGroup(moduleType, stats, tier, outputPct = 100) {
     switch (moduleType) {
         case MODULE_ENGINE: {
             const caps = computeEngineCapabilities(stats);
@@ -15803,13 +15953,28 @@ function computeCapabilityGroup(moduleType, stats, tier) {
             };
         }
         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;
@@ -15894,9 +16059,10 @@ function resolveEntity(id, stats, modules) {
                 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,
                 };
@@ -15980,9 +16146,15 @@ const TEMPLATES = {
     },
     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',
@@ -16024,9 +16196,12 @@ function describeModuleForItem(resolved) {
     return describeModule({ capability: group.capability, attributes: group.attributes });
 }
 function describeModuleForSlot(slot) {
-    if (!slot.installed || !slot.name || !slot.attributes)
+    if (!slot.installed || !slot.attributes)
         return null;
-    return describeModule({ capability: slot.name, attributes: slot.attributes });
+    const capability = slot.capability ?? slot.name;
+    if (!capability)
+        return null;
+    return describeModule({ capability, attributes: slot.attributes });
 }
 function renderDescription(desc, options) {
     const translate = options?.translate ?? ((_id, fallback) => fallback);
@@ -16181,11 +16356,11 @@ function buildModuleImmutable(itemId, quantity, stats, originX, originY) {
         }
         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: {
@@ -16193,14 +16368,28 @@ function buildModuleImmutable(itemId, quantity, stats, originX, originY) {
             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;
         }
@@ -16286,6 +16475,8 @@ var index = /*#__PURE__*/Object.freeze({
     computeHaulerEfficiency: computeHaulerEfficiency,
     computeHaulerDrain: computeHaulerDrain$1,
     computeWarpRange: computeWarpRange,
+    computeCargoBayCapacity: computeCargoBayCapacity,
+    computeBatteryBankCapacity: computeBatteryBankCapacity,
     entityDisplayName: entityDisplayName,
     moduleDisplayName: moduleDisplayName,
     formatModuleLine: formatModuleLine,
@@ -16628,6 +16819,7 @@ exports.LOCATION_MAX_DEPTH = LOCATION_MAX_DEPTH;
 exports.LOCATION_MIN_DEPTH = LOCATION_MIN_DEPTH;
 exports.Location = Location;
 exports.LocationsManager = LocationsManager;
+exports.MAX_LEGS = MAX_LEGS;
 exports.MAX_ORBITAL_ALTITUDE = MAX_ORBITAL_ALTITUDE;
 exports.MAX_STARS_PER_STAT = MAX_STARS_PER_STAT;
 exports.MAX_STAR_RATING = MAX_STAR_RATING;
@@ -16789,6 +16981,7 @@ exports.computeBaseCapacity = computeBaseCapacity;
 exports.computeBaseCapacityShip = computeBaseCapacityShip;
 exports.computeBaseCapacityWarehouse = computeBaseCapacityWarehouse;
 exports.computeBaseHullmass = computeBaseHullmass;
+exports.computeBatteryCapabilities = computeBatteryCapabilities;
 exports.computeComponentStats = computeComponentStats;
 exports.computeContainerCapabilities = computeContainerCapabilities;
 exports.computeContainerT2Capabilities = computeContainerT2Capabilities;
@@ -16808,6 +17001,7 @@ exports.computeGathererYield = computeGathererYield;
 exports.computeGeneratorCap = computeGeneratorCap;
 exports.computeGeneratorCapabilities = computeGeneratorCapabilities;
 exports.computeGeneratorRech = computeGeneratorRech;
+exports.computeGroupPerLegReach = computeGroupPerLegReach;
 exports.computeHaulPenalty = computeHaulPenalty;
 exports.computeHaulerCapabilities = computeHaulerCapabilities;
 exports.computeHaulerCapacity = computeHaulerCapacity;
@@ -16818,6 +17012,7 @@ exports.computeLoaderCapabilities = computeLoaderCapabilities;
 exports.computeLoaderMass = computeLoaderMass;
 exports.computeLoaderThrust = computeLoaderThrust;
 exports.computeNftImageUrl = computeNftImageUrl;
+exports.computePerLegReach = computePerLegReach;
 exports.computeShipHullCapabilities = computeShipHullCapabilities;
 exports.computeStorageCapabilities = computeStorageCapabilities;
 exports.computeWarehouseHullCapabilities = computeWarehouseHullCapabilities;
@@ -16976,6 +17171,7 @@ exports.parseWireEntity = parseWireEntity;
 exports.partnerRegion = partnerRegion;
 exports.planParallelGather = planParallelGather;
 exports.planParallelTransfer = planParallelTransfer;
+exports.planRoute = planRoute;
 exports.projectEntity = projectEntity;
 exports.projectEntityAt = projectEntityAt;
 exports.projectRemainingAt = projectRemainingAt;
@@ -16999,6 +17195,7 @@ exports.rollupGatherer = rollupGatherer;
 exports.rollupLoaders = rollupLoaders;
 exports.rotation = rotation;
 exports.schedule = schedule;
+exports.sdkSystemGraph = sdkSystemGraph;
 exports.selectGatherLane = selectGatherLane;
 exports.setSubscriptionsDebug = setSubscriptionsDebug;
 exports.stackKey = stackKey;