@shipload/sdk 1.0.0-next.3 → 1.0.0-next.4

package/lib/shipload.js

@@ -3184,10 +3184,6 @@ var recipes = [
 			},
 			{
 				sources: [
-					{
-						inputIndex: 1,
-						statIndex: 1
-					}
 				]
 			},
 			{
@@ -3227,8 +3223,8 @@ var recipes = [
 			{
 				sources: [
 					{
-						inputIndex: 0,
-						statIndex: 0
+						inputIndex: 1,
+						statIndex: 1
 					}
 				]
 			},
@@ -3346,7 +3342,7 @@ var recipes = [
 				sources: [
 					{
 						inputIndex: 0,
-						statIndex: 0
+						statIndex: 1
 					}
 				]
 			},
@@ -3362,16 +3358,12 @@ var recipes = [
 				sources: [
 					{
 						inputIndex: 0,
-						statIndex: 1
+						statIndex: 0
 					}
 				]
 			},
 			{
 				sources: [
-					{
-						inputIndex: 1,
-						statIndex: 1
-					}
 				]
 			}
 		],
@@ -8499,10 +8491,10 @@ function moduleSlotTypeToCode(slotType) {
 }
 
 function computeShipHullCapabilities(stats) {
-    const density = stats.density ?? 500;
-    const strength = stats.strength ?? 500;
-    const hardness = stats.hardness ?? 500;
-    const saturation = stats.saturation ?? 500;
+    const density = stats.density;
+    const strength = stats.strength;
+    const hardness = stats.hardness;
+    const saturation = stats.saturation;
     const hullmass = 25000 + 75 * density;
     const statSum = strength + hardness + saturation;
     const exponent = statSum / 2997.0;
@@ -8510,26 +8502,26 @@ function computeShipHullCapabilities(stats) {
     return { hullmass, capacity };
 }
 function computeEngineCapabilities(stats) {
-    const vol = stats.volatility ?? 500;
-    const thm = stats.thermal ?? 500;
+    const vol = stats.volatility;
+    const thm = stats.thermal;
     return {
         thrust: 400 + Math.floor((vol * 3) / 4),
         drain: Math.max(30, 50 - Math.floor(thm / 70)),
     };
 }
 function computeGeneratorCapabilities(stats) {
-    const res = stats.resonance ?? 500;
-    const ref = stats.reflectivity ?? 500;
+    const com = stats.composition;
+    const fin = stats.fineness;
     return {
-        capacity: 300 + Math.floor(res / 6),
-        recharge: 1 + Math.floor((ref * 3) / 1000),
+        capacity: 300 + Math.floor(com / 6),
+        recharge: 1 + Math.floor((fin * 3) / 1000),
     };
 }
 function computeGathererCapabilities(stats) {
-    const str = stats.strength ?? 500;
-    const con = stats.conductivity ?? 500;
-    const ref = stats.reflectivity ?? 500;
-    const tol = stats.tolerance ?? 500;
+    const str = stats.strength;
+    const con = stats.conductivity;
+    const ref = stats.reflectivity;
+    const tol = stats.tolerance;
     return {
         yield: 200 + str,
         drain: Math.max(250, 1250 - Math.floor((con * 25) / 20)),
@@ -8538,45 +8530,46 @@ function computeGathererCapabilities(stats) {
     };
 }
 function computeLoaderCapabilities(stats) {
-    const hrd = stats.hardness ?? 500;
-    const pla = stats.plasticity ?? 500;
+    const insulation = stats.insulation;
+    const plasticity = stats.plasticity;
     return {
-        mass: Math.max(200, 2000 - Math.floor(hrd * 2)),
-        thrust: 1 + Math.floor(pla / 500),
+        mass: Math.max(200, 2000 - Math.floor(insulation * 2)),
+        thrust: 1 + Math.floor(plasticity / 500),
         quantity: 1,
     };
 }
 function computeCrafterCapabilities(stats) {
-    const rea = stats.reactivity ?? 500;
-    const com = stats.composition ?? 500;
+    const rea = stats.reactivity;
+    const fin = stats.fineness;
     return {
         speed: 100 + Math.floor((rea * 4) / 5),
-        drain: Math.max(5, 30 - Math.floor(com / 33)),
+        drain: Math.max(5, 30 - Math.floor(fin / 33)),
     };
 }
 function computeHaulerCapabilities(stats) {
-    const res = stats.resonance ?? 500;
-    const con = stats.conductivity ?? 500;
-    const ref = stats.reflectivity ?? 500;
+    const fineness = stats.fineness;
+    const conductivity = stats.conductivity;
+    const composition = stats.composition;
     return {
-        capacity: Math.max(1, 1 + Math.floor(res / 400)),
-        efficiency: 2000 + con * 6,
-        drain: Math.max(3, 15 - Math.floor(ref / 80)),
+        capacity: Math.max(1, 1 + Math.floor(fineness / 400)),
+        efficiency: 2000 + conductivity * 6,
+        drain: Math.max(3, 15 - Math.floor(composition / 80)),
     };
 }
 function computeStorageCapabilities(stats, baseCapacity) {
-    const strength = stats.strength ?? 500;
-    const hardness = stats.hardness ?? 500;
-    const saturation = stats.saturation ?? 500;
-    const statSum = strength + hardness + saturation;
+    const strength = stats.strength;
+    const density = stats.density;
+    const hardness = stats.hardness;
+    const saturation = stats.saturation;
+    const statSum = strength + density + hardness + saturation;
     const capacityBonus = Math.floor((baseCapacity * (10 + Math.floor((statSum * 10) / 2997))) / 100);
     return { capacityBonus };
 }
 function computeWarehouseHullCapabilities(stats) {
-    const density = stats.density ?? 500;
-    const strength = stats.strength ?? 500;
-    const hardness = stats.hardness ?? 500;
-    const saturation = stats.saturation ?? 500;
+    const density = stats.density;
+    const strength = stats.strength;
+    const hardness = stats.hardness;
+    const saturation = stats.saturation;
     const hullmass = 25000 + 75 * density;
     const statSum = strength + hardness + saturation;
     const exponent = statSum / 2997.0;
@@ -8779,10 +8772,10 @@ class Container extends exports.ServerTypes.entity_info {
     }
 }
 function computeContainerCapabilities(stats) {
-    const density = stats['density'] ?? 500;
-    const strength = stats['strength'] ?? 500;
-    const hardness = stats['hardness'] ?? 500;
-    const saturation = stats['saturation'] ?? 500;
+    const density = stats.density;
+    const strength = stats.strength;
+    const hardness = stats.hardness;
+    const saturation = stats.saturation;
     const hullmass = 25000 + 75 * density;
     const statSum = strength + hardness + saturation;
     const exponent = statSum / 2997;
@@ -8790,10 +8783,10 @@ function computeContainerCapabilities(stats) {
     return { hullmass, capacity };
 }
 function computeContainerT2Capabilities(stats) {
-    const strength = stats['strength'] ?? 0;
-    const density = stats['density'] ?? 0;
-    const hardness = stats['hardness'] ?? 0;
-    const saturation = stats['saturation'] ?? 0;
+    const strength = stats.strength;
+    const density = stats.density;
+    const hardness = stats.hardness;
+    const saturation = stats.saturation;
     const hullmass = 20000 + 50 * density;
     const statSum = strength + hardness + saturation;
     const exponent = statSum / 2500;
@@ -10130,6 +10123,11 @@ const capabilityNames = [
 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',
+    },
     { capability: 'Movement', attribute: 'thrust', description: 'Propulsion force' },
     { capability: 'Movement', attribute: 'drain', description: 'Energy consumed per movement' },
     { capability: 'Energy', attribute: 'capacity', description: 'Maximum energy storage' },
@@ -10167,338 +10165,149 @@ const capabilityAttributes = [
         description: 'Energy consumed per target during haul-beam operation',
     },
 ];
-const statMappings = [
-    {
-        stat: 'Strength',
-        capability: 'Gathering',
-        attribute: 'yield',
-        rationale: 'Raw mechanical force drives faster gathering',
-    },
-    {
-        stat: 'Strength',
-        capability: 'Storage',
-        attribute: 'capacity',
-        rationale: 'Stronger walls hold more capacity per mass',
-    },
-    {
-        stat: 'Strength',
-        capability: 'Launch',
-        attribute: 'capacity',
-        rationale: 'Stronger housing handles larger launch loads',
-    },
-    {
-        stat: 'Tolerance',
-        capability: 'Movement',
-        attribute: 'thrust',
-        rationale: 'Engine components that tolerate more can push harder',
-    },
-    {
-        stat: 'Tolerance',
-        capability: 'Energy',
-        attribute: 'recharge',
-        rationale: 'Generator housing withstands stress for faster recharge',
-    },
-    {
-        stat: 'Tolerance',
-        capability: 'Gathering',
-        attribute: 'depth',
-        rationale: 'Housing withstands pressure/heat at extreme depths',
-    },
-    {
-        stat: 'Tolerance',
-        capability: 'Warp',
-        attribute: 'range',
-        rationale: 'Warp drive housing withstands extreme forces',
-    },
-    {
-        stat: 'Density',
-        capability: 'Hull',
-        attribute: 'mass',
-        rationale: 'Lighter metal = lighter hull',
-    },
-    {
-        stat: 'Density',
-        capability: 'Loader',
-        attribute: 'mass',
-        rationale: 'Lighter metal = lighter loader units',
-    },
-    {
-        stat: 'Density',
-        capability: 'Movement',
-        attribute: 'drain',
-        rationale: 'Lighter components require less energy to move',
-    },
-    {
-        stat: 'Conductivity',
-        capability: 'Movement',
-        attribute: 'drain',
-        rationale: 'Efficient energy transfer reduces movement energy cost',
-    },
-    {
-        stat: 'Conductivity',
-        capability: 'Gathering',
-        attribute: 'drain',
-        rationale: 'Efficient energy transfer reduces gathering energy cost',
-    },
-    {
-        stat: 'Conductivity',
-        capability: 'Crafter',
-        attribute: 'drain',
-        rationale: 'Efficient energy transfer reduces crafting energy cost',
-    },
-    {
-        stat: 'Conductivity',
-        capability: 'Energy',
-        attribute: 'recharge',
-        rationale: 'Better conductivity speeds energy flow during recharge',
-    },
-    {
-        stat: 'Ductility',
-        capability: 'Crafter',
-        attribute: 'quality',
-        rationale: 'Precise shaping enables tighter crafting tolerances',
-    },
-    {
-        stat: 'Ductility',
-        capability: 'Gathering',
-        attribute: 'yield',
-        rationale: 'Precisely shaped conduit components gather faster',
-    },
-    {
-        stat: 'Ductility',
-        capability: 'Storage',
-        attribute: 'capacity',
-        rationale: 'Precision-formed container walls maximize volume',
-    },
-    {
-        stat: 'Ductility',
-        capability: 'Loader',
-        attribute: 'mass',
-        rationale: 'Precision-formed precious metal reduces loader unit mass',
-    },
-    {
-        stat: 'Reflectivity',
-        capability: 'Gathering',
-        attribute: 'depth',
-        rationale: 'Reflective heat shielding protects equipment at depth',
-    },
-    {
-        stat: 'Reflectivity',
-        capability: 'Launch',
-        attribute: 'range',
-        rationale: 'Reflective surfaces focus electromagnetic launch energy',
-    },
-    {
-        stat: 'Volatility',
-        capability: 'Gathering',
-        attribute: 'yield',
-        rationale: 'Energy release powers faster gathering',
-    },
-    {
-        stat: 'Volatility',
-        capability: 'Movement',
-        attribute: 'thrust',
-        rationale: 'Energy release drives propulsion force',
-    },
-    {
-        stat: 'Volatility',
-        capability: 'Loader',
-        attribute: 'thrust',
-        rationale: 'Energy release powers loader motors',
-    },
-    {
-        stat: 'Volatility',
-        capability: 'Launch',
-        attribute: 'capacity',
-        rationale: 'Energy release enables launching heavier payloads',
-    },
-    {
-        stat: 'Reactivity',
-        capability: 'Crafter',
-        attribute: 'speed',
-        rationale: 'Reactive gases accelerate chemical/thermal processing',
-    },
-    {
-        stat: 'Reactivity',
-        capability: 'Gathering',
-        attribute: 'speed',
-        rationale: 'Reactive gases manage heat/friction during gathering',
-    },
-    {
-        stat: 'Reactivity',
-        capability: 'Launch',
-        attribute: 'drain',
-        rationale: 'Reactive gas medium reduces electromagnetic resistance',
-    },
-    {
-        stat: 'Thermal',
-        capability: 'Crafter',
-        attribute: 'quality',
-        rationale: 'Precise thermal control during fabrication',
-    },
-    {
-        stat: 'Thermal',
-        capability: 'Gathering',
-        attribute: 'drain',
-        rationale: 'Thermal management reduces energy waste during gathering',
-    },
-    {
-        stat: 'Thermal',
-        capability: 'Energy',
-        attribute: 'capacity',
-        rationale: 'Thermal management enables denser energy storage',
-    },
-    {
-        stat: 'Resonance',
-        capability: 'Energy',
-        attribute: 'capacity',
-        rationale: 'Resonating crystals store energy in fields',
-    },
-    {
-        stat: 'Resonance',
-        capability: 'Warp',
-        attribute: 'range',
-        rationale: 'Resonant crystals amplify warp field projection',
-    },
-    {
-        stat: 'Resonance',
-        capability: 'Launch',
-        attribute: 'range',
-        rationale: 'Resonant crystals focus electromagnetic launch field',
-    },
-    {
-        stat: 'Resonance',
-        capability: 'Launch',
-        attribute: 'capacity',
-        rationale: 'Stronger resonant field launches heavier payloads',
-    },
-    {
-        stat: 'Hardness',
-        capability: 'Crafter',
-        attribute: 'speed',
-        rationale: 'Hard tooling surfaces cut and shape materials faster',
-    },
-    {
-        stat: 'Hardness',
-        capability: 'Launch',
-        attribute: 'drain',
-        rationale: 'Hard rail surfaces reduce friction, less energy wasted',
-    },
-    {
-        stat: 'Clarity',
-        capability: 'Energy',
-        attribute: 'recharge',
-        rationale: 'Flawless crystals enable smoother energy flow during recharge',
-    },
-    {
-        stat: 'Clarity',
-        capability: 'Crafter',
-        attribute: 'quality',
-        rationale: 'Precision optics for calibration during fabrication',
-    },
-    {
-        stat: 'Clarity',
-        capability: 'Crafter',
-        attribute: 'drain',
-        rationale: 'Precision computing optimizes energy routing in factory',
-    },
-    {
-        stat: 'Plasticity',
-        capability: 'Crafter',
-        attribute: 'speed',
-        rationale: 'Easily reshaped materials speed up processing',
-    },
-    {
-        stat: 'Plasticity',
-        capability: 'Movement',
-        attribute: 'thrust',
-        rationale: 'Flexible polymer seals reduce friction in propulsion',
-    },
-    {
-        stat: 'Plasticity',
-        capability: 'Loader',
-        attribute: 'thrust',
-        rationale: 'Flexible joints improve loader force transfer',
-    },
-    {
-        stat: 'Insulation',
-        capability: 'Movement',
-        attribute: 'drain',
-        rationale: 'Better insulation reduces energy loss during movement',
-    },
-    {
-        stat: 'Insulation',
-        capability: 'Gathering',
-        attribute: 'drain',
-        rationale: 'Better insulation reduces energy loss during gathering',
-    },
-    {
-        stat: 'Insulation',
-        capability: 'Crafter',
-        attribute: 'drain',
-        rationale: 'Better insulation reduces energy loss during crafting',
+const invertedAttributes = new Set(['drain', 'mass']);
+function isInvertedAttribute(attribute) {
+    return invertedAttributes.has(attribute);
+}
+function getCapabilityAttributes(capability) {
+    if (capability) {
+        return capabilityAttributes.filter((a) => a.capability === capability);
+    }
+    return capabilityAttributes;
+}
+
+const ENTITY_HULL_SLOTS = {
+    0: { capability: 'Storage', attribute: 'capacity' },
+    1: { capability: 'Hull', attribute: 'mass' },
+    2: { capability: 'Storage', attribute: 'capacity' },
+    3: { capability: 'Storage', attribute: 'capacity' },
+};
+const SLOT_FORMULAS = {
+    engine: {
+        0: { capability: 'Movement', attribute: 'thrust' },
+        1: { capability: 'Movement', attribute: 'drain' },
     },
-    {
-        stat: 'Insulation',
-        capability: 'Launch',
-        attribute: 'drain',
-        rationale: 'Better insulation reduces energy loss during launch',
+    generator: {
+        0: { capability: 'Energy', attribute: 'capacity' },
+        1: { capability: 'Energy', attribute: 'recharge' },
     },
-    {
-        stat: 'Purity',
-        capability: 'Storage',
-        attribute: 'capacity',
-        rationale: 'Purer composites make better containers',
+    gatherer: {
+        0: { capability: 'Gathering', attribute: 'yield' },
+        1: { capability: 'Gathering', attribute: 'depth' },
+        3: { capability: 'Gathering', attribute: 'drain' },
+        4: { capability: 'Gathering', attribute: 'speed' },
     },
-    {
-        stat: 'Purity',
-        capability: 'Gathering',
-        attribute: 'speed',
-        rationale: 'Purer bio-lubricants reduce friction during gathering',
+    loader: {
+        0: { capability: 'Loader', attribute: 'mass' },
+        1: { capability: 'Loader', attribute: 'thrust' },
     },
-    {
-        stat: 'Purity',
-        capability: 'Energy',
-        attribute: 'capacity',
-        rationale: 'Purer organic electrolytes store more charge',
+    crafter: {
+        0: { capability: 'Crafter', attribute: 'speed' },
+        1: { capability: 'Crafter', attribute: 'drain' },
     },
-    {
-        stat: 'Resonance',
-        capability: 'Hauler',
-        attribute: 'capacity',
-        rationale: 'Resonant field strength determines how many targets the haul beam can lock onto simultaneously.',
+    storage: {
+        0: { capability: 'Storage', attribute: 'bonus' },
+        1: { capability: 'Storage', attribute: 'bonus' },
+        2: { capability: 'Storage', attribute: 'bonus' },
+        3: { capability: 'Storage', attribute: 'bonus' },
     },
-    {
-        stat: 'Conductivity',
-        capability: 'Hauler',
-        attribute: 'efficiency',
-        rationale: 'Energy-transfer efficiency reduces the thrust penalty from each hauled target.',
+    hauler: {
+        0: { capability: 'Hauler', attribute: 'capacity' },
+        1: { capability: 'Hauler', attribute: 'efficiency' },
+        2: { capability: 'Hauler', attribute: 'drain' },
     },
-    {
-        stat: 'Clarity',
-        capability: 'Hauler',
-        attribute: 'drain',
-        rationale: 'Clarity-focused energy routing reduces per-target drain during haul-beam operation.',
+    warp: {
+        0: { capability: 'Warp', attribute: 'range' },
     },
-];
-const invertedAttributes = new Set(['drain', 'mass']);
-function isInvertedAttribute(attribute) {
-    return invertedAttributes.has(attribute);
+    'ship-t1': ENTITY_HULL_SLOTS,
+    'container-t1': ENTITY_HULL_SLOTS,
+    'warehouse-t1': ENTITY_HULL_SLOTS,
+    'container-t2': ENTITY_HULL_SLOTS,
+};
+
+const KIND_TO_ITEM_ID = {
+    engine: ITEM_ENGINE_T1,
+    generator: ITEM_GENERATOR_T1,
+    gatherer: ITEM_GATHERER_T1,
+    loader: ITEM_LOADER_T1,
+    crafter: ITEM_CRAFTER_T1,
+    storage: ITEM_STORAGE_T1,
+    hauler: ITEM_HAULER_T1,
+    warp: ITEM_WARP_T1,
+    'ship-t1': ITEM_SHIP_T1_PACKED,
+    'container-t1': ITEM_CONTAINER_T1_PACKED,
+    'warehouse-t1': ITEM_WAREHOUSE_T1_PACKED,
+    'container-t2': ITEM_CONTAINER_T2_PACKED,
+};
+function isCategoryInput(input) {
+    return 'category' in input;
 }
-function getCapabilityAttributes(capability) {
-    if (capability) {
-        return capabilityAttributes.filter((a) => a.capability === capability);
+function traceToRawCategoryStat(recipe, source, visited = new Set()) {
+    const input = recipe.inputs[source.inputIndex];
+    if (!input)
+        return undefined;
+    if (isCategoryInput(input)) {
+        const defs = getStatDefinitions(input.category);
+        return defs[source.statIndex];
     }
-    return capabilityAttributes;
+    if (visited.has(input.itemId))
+        return undefined;
+    const subRecipe = getRecipe(input.itemId);
+    if (!subRecipe)
+        return undefined;
+    const subSlot = subRecipe.statSlots[source.statIndex];
+    if (!subSlot)
+        return undefined;
+    const subSource = subSlot.sources[0];
+    if (!subSource)
+        return undefined;
+    const nextVisited = new Set(visited);
+    nextVisited.add(input.itemId);
+    return traceToRawCategoryStat(subRecipe, subSource, nextVisited);
+}
+let cached;
+function deriveStatMappings() {
+    if (cached)
+        return cached;
+    const out = [];
+    const seen = new Set();
+    for (const [kind, slots] of Object.entries(SLOT_FORMULAS)) {
+        const itemId = KIND_TO_ITEM_ID[kind];
+        const recipe = getRecipe(itemId);
+        if (!recipe)
+            continue;
+        for (const [slotIdxStr, consumer] of Object.entries(slots)) {
+            const slotIdx = Number(slotIdxStr);
+            const slot = recipe.statSlots[slotIdx];
+            if (!slot)
+                continue;
+            for (const source of slot.sources) {
+                const stat = traceToRawCategoryStat(recipe, source);
+                if (!stat)
+                    continue;
+                const key = `${stat.label}|${consumer.capability}|${consumer.attribute}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                out.push({
+                    stat: stat.label,
+                    capability: consumer.capability,
+                    attribute: consumer.attribute,
+                });
+            }
+        }
+    }
+    cached = out;
+    return out;
 }
 function getStatMappings() {
-    return statMappings;
+    return deriveStatMappings();
 }
 function getStatMappingsForStat(stat) {
-    return statMappings.filter((m) => m.stat === stat);
+    return deriveStatMappings().filter((m) => m.stat === stat);
 }
 function getStatMappingsForCapability(capability) {
-    return statMappings.filter((m) => m.capability === capability);
+    return deriveStatMappings().filter((m) => m.capability === capability);
 }
 
 function toNum(v) {
@@ -10637,10 +10446,11 @@ function computeCapabilityGroup(moduleType, stats) {
             };
         }
         case MODULE_STORAGE: {
-            const str = stats.strength ?? 500;
-            const hrd = stats.hardness ?? 500;
-            const sat = stats.saturation ?? 500;
-            const statSum = str + hrd + sat;
+            const str = stats.strength;
+            const den = stats.density;
+            const hrd = stats.hardness;
+            const sat = stats.saturation;
+            const statSum = str + den + hrd + sat;
             const pct = 10 + Math.floor((statSum * 10) / 2997);
             return { capability: 'Storage', attributes: [{ label: 'Capacity Bonus', value: pct }] };
         }
@@ -10945,16 +10755,16 @@ function computeBaseCapacityWarehouse(stats) {
 }
 const computeEngineThrust = (vol) => 400 + idiv(vol * 3, 4);
 const computeEngineDrain = (thm) => Math.max(30, 50 - idiv(thm, 70));
-const computeGeneratorCap = (res) => 300 + idiv(res, 6);
-const computeGeneratorRech = (ref) => 1 + idiv(ref * 3, 1000);
+const computeGeneratorCap = (com) => 300 + idiv(com, 6);
+const computeGeneratorRech = (fin) => 1 + idiv(fin * 3, 1000);
 const computeGathererYield = (str) => 200 + str;
 const computeGathererDrain = (con) => Math.max(250, 1250 - idiv(con * 25, 20));
 const computeGathererDepth = (tol) => 200 + idiv(tol * 3, 2);
 const computeGathererSpeed = (ref) => 100 + idiv(ref * 4, 5);
-const computeLoaderMass = (fin) => Math.max(200, 2000 - fin * 2);
+const computeLoaderMass = (ins) => Math.max(200, 2000 - ins * 2);
 const computeLoaderThrust = (pla) => 1 + idiv(pla, 500);
 const computeCrafterSpeed = (rea) => 100 + idiv(rea * 4, 5);
-const computeCrafterDrain = (com) => Math.max(5, 30 - idiv(com, 33));
+const computeCrafterDrain = (fin) => Math.max(5, 30 - idiv(fin, 33));
 const computeWarpRange = (stat) => 100 + stat * 3;
 function entityDisplayName(itemId) {
     switch (itemId) {
@@ -11339,6 +11149,7 @@ exports.SHIP_NOT_IDLE = SHIP_NOT_IDLE;
 exports.SHIP_NOT_OWNED = SHIP_NOT_OWNED;
 exports.SHIP_NO_COMPLETED_TASKS = SHIP_NO_COMPLETED_TASKS;
 exports.SHIP_NO_TASKS_TO_CANCEL = SHIP_NO_TASKS_TO_CANCEL;
+exports.SLOT_FORMULAS = SLOT_FORMULAS;
 exports.STARTER_ALREADY_CLAIMED = STARTER_ALREADY_CLAIMED;
 exports.ScheduleAccessor = ScheduleAccessor;
 exports.ServerContract = server;
@@ -11444,6 +11255,7 @@ exports.computeShipHullCapabilities = computeShipHullCapabilities;
 exports.computeStorageCapabilities = computeStorageCapabilities;
 exports.computeWarehouseCapabilities = computeWarehouseCapabilities;
 exports.computeWarehouseHullCapabilities = computeWarehouseHullCapabilities;
+exports.computeWarpRange = computeWarpRange;
 exports.coordsToLocationId = coordsToLocationId;
 exports.createInventoryAccessor = createInventoryAccessor;
 exports.createProjectedEntity = createProjectedEntity;
@@ -11457,6 +11269,7 @@ exports.deriveLocationEpoch = deriveLocationEpoch;
 exports.deriveLocationSize = deriveLocationSize;
 exports.deriveLocationStatic = deriveLocationStatic;
 exports.deriveResourceStats = deriveResourceStats;
+exports.deriveStatMappings = deriveStatMappings;
 exports.deriveStrata = deriveStrata;
 exports.deriveStratum = deriveStratum;
 exports.describeItem = describeItem;
@@ -11571,7 +11384,6 @@ exports.setSubscriptionsDebug = setSubscriptionsDebug;
 exports.stackKey = stackKey;
 exports.stackToCargoItem = stackToCargoItem;
 exports.stacksEqual = stacksEqual;
-exports.statMappings = statMappings;
 exports.tierColors = tierColors;
 exports.tierLabel = tierLabel;
 exports.tierLabels = tierLabels;