@shipload/sdk 2.0.0-rc11 → 2.0.0-rc13

package/lib/shipload.js

@@ -2140,6 +2140,11 @@ const SHIP_CARGO_NOT_LOADED = 'Cannot unload cargo that is not loaded.';
 const WAREHOUSE_NOT_FOUND = 'Cannot find warehouse for given id.';
 const WAREHOUSE_ALREADY_AT_LOCATION = 'Warehouse already exists at this location.';
 const WAREHOUSE_CAPACITY_EXCEEDED = 'Warehouse capacity would be exceeded.';
+const ENTITY_CAPACITY_EXCEEDED = 'Entity cargo capacity would be exceeded.';
+const RECIPE_INPUTS_INSUFFICIENT = 'Insufficient inputs for recipe.';
+const RECIPE_INPUTS_INVALID = 'Input cargo does not match recipe requirements.';
+const RECIPE_INPUTS_EXCESS = 'Provided inputs exceed recipe requirements.';
+const RECIPE_INPUTS_MIXED = 'All stacks for a recipe input must be the same resource.';
 
 const PRECISION$1 = 10000;
 const CRAFT_ENERGY_DIVISOR = 150000;
@@ -2163,7 +2168,8 @@ exports.TaskType = void 0;
     TaskType[TaskType["WARP"] = 6] = "WARP";
     TaskType[TaskType["CRAFT"] = 7] = "CRAFT";
     TaskType[TaskType["DEPLOY"] = 8] = "DEPLOY";
-    TaskType[TaskType["DEPLOY_SHIP"] = 9] = "DEPLOY_SHIP";
+    TaskType[TaskType["WRAP"] = 9] = "WRAP";
+    TaskType[TaskType["UNWRAP"] = 10] = "UNWRAP";
 })(exports.TaskType || (exports.TaskType = {}));
 exports.LocationType = void 0;
 (function (LocationType) {
@@ -2264,7 +2270,7 @@ const DEPTH_THRESHOLD_T4 = 30000;
 const DEPTH_THRESHOLD_T5 = 55000;
 const LOCATION_MIN_DEPTH = 500;
 const LOCATION_MAX_DEPTH = 65535;
-const YIELD_THRESHOLD = Math.floor(0.003 * 0xffffffff);
+const YIELD_THRESHOLD = Math.floor(0.001 * 0xffffffff);
 const PLANET_SUBTYPE_GAS_GIANT = 0;
 const PLANET_SUBTYPE_ROCKY = 1;
 const PLANET_SUBTYPE_TERRESTRIAL = 2;
@@ -2382,12 +2388,6 @@ function getEligibleResources(locationType, subtype, stratum) {
         return stratum >= threshold;
     });
 }
-function depthScaleFactor(stratum) {
-    if (stratum <= 1)
-        return 1.0;
-    const logScale = Math.log(stratum) / Math.log(65535);
-    return 1.0 + logScale * 2.0;
-}
 
 function deriveLocationSize(loc) {
     if (loc.type.toNumber() === exports.LocationType.EMPTY)
@@ -4576,10 +4576,14 @@ function isGatherableLocation(locationType) {
 }
 function getLocationTypeName(type) {
     switch (type) {
-        case exports.LocationType.EMPTY: return 'Empty';
-        case exports.LocationType.PLANET: return 'Planet';
-        case exports.LocationType.ASTEROID: return 'Asteroid';
-        case exports.LocationType.NEBULA: return 'Nebula';
+        case exports.LocationType.EMPTY:
+            return 'Empty';
+        case exports.LocationType.PLANET:
+            return 'Planet';
+        case exports.LocationType.ASTEROID:
+            return 'Asteroid';
+        case exports.LocationType.NEBULA:
+            return 'Nebula';
     }
 }
 function uint16(hash, offset) {
@@ -4909,1930 +4913,48 @@ var itemsData = [
 	}
 ];
 
-const items = itemsData.map((g) => exports.Item.from({
-    id: g.id,
-    name: g.name,
-    description: g.description,
-    mass: g.mass,
-    category: g.category,
-    tier: g.tier,
-    color: g.color,
-}));
-const itemIds = items.map((i) => i.id);
-function getItem(itemId) {
-    const id = antelope.UInt16.from(itemId);
-    const item = items.find((i) => i.id.equals(id));
-    if (!item) {
-        throw new Error(`Item with id ${id} not found`);
-    }
-    return item;
-}
-function getItems() {
-    return items;
-}
-
-function calc_orbital_altitude(mass) {
-    if (mass <= BASE_ORBITAL_MASS) {
-        return MIN_ORBITAL_ALTITUDE;
-    }
-    const ratio = mass / BASE_ORBITAL_MASS;
-    const capRatio = 10.0;
-    let scale = Math.log(ratio) / Math.log(capRatio);
-    scale = Math.min(scale, 1.0);
-    return MIN_ORBITAL_ALTITUDE + Math.floor((MAX_ORBITAL_ALTITUDE - MIN_ORBITAL_ALTITUDE) * scale);
-}
-function distanceBetweenCoordinates(origin, destination) {
-    return distanceBetweenPoints(origin.x, origin.y, destination.x, destination.y);
-}
-function distanceBetweenPoints(x1, y1, x2, y2) {
-    const x = Math.pow(x1 - x2, 2);
-    const y = Math.pow(y1 - y2, 2);
-    return antelope.UInt64.from(Math.sqrt(x + y) * PRECISION$1);
-}
-function lerp(origin, destination, time) {
-    return {
-        x: (1 - time) * Number(origin.x) + time * Number(destination.x),
-        y: (1 - time) * Number(origin.y) + time * Number(destination.y),
-    };
-}
-function rotation(origin, destination) {
-    return Math.atan2(destination.y - origin.y, destination.x - origin.x) * (180 / Math.PI) + 90;
-}
-function findNearbyPlanets(seed, origin, maxDistance = 20 * PRECISION$1) {
-    const nearbySystems = [];
-    const max = antelope.UInt64.from(maxDistance / PRECISION$1);
-    const xMin = antelope.Int64.from(origin.x).subtracting(max);
-    const xMax = antelope.Int64.from(origin.x).adding(max);
-    const yMin = antelope.Int64.from(origin.y).subtracting(max);
-    const yMax = antelope.Int64.from(origin.y).adding(max);
-    for (let x = Number(xMin); x <= Number(xMax); x++) {
-        for (let y = Number(yMin); y <= Number(yMax); y++) {
-            const samePlace = x === Number(origin.x) && y === Number(origin.y);
-            if (!samePlace) {
-                const distance = distanceBetweenPoints(origin.x, origin.y, x, y);
-                if (Number(distance) <= Number(maxDistance)) {
-                    const system = hasSystem(seed, { x, y });
-                    if (system) {
-                        nearbySystems.push({ origin, destination: { x, y }, distance });
-                    }
-                }
-            }
-        }
-    }
-    return nearbySystems;
-}
-function calc_rechargetime(capacity, energy, recharge) {
-    const cap = antelope.UInt32.from(capacity);
-    const eng = antelope.UInt32.from(energy);
-    if (eng.gte(cap))
-        return antelope.UInt32.zero;
-    return cap.subtracting(eng).dividing(recharge);
-}
-function calc_ship_rechargetime(ship) {
-    if (!ship.generator)
-        return antelope.UInt32.from(0);
-    return calc_rechargetime(ship.generator.capacity, ship.energy ?? antelope.UInt16.from(0), ship.generator.recharge);
-}
-function calc_flighttime(distance, acceleration) {
-    return antelope.UInt32.from(2 * Math.sqrt(Number(distance) / acceleration));
-}
-function calc_loader_flighttime(ship, mass, altitude) {
-    const z = altitude ?? ship.coordinates.z?.toNumber() ?? calc_orbital_altitude(Number(mass));
-    return calc_flighttime(z, calc_loader_acceleration(ship, mass));
-}
-function calc_loader_acceleration(ship, mass) {
-    const thrust = ship.loaders ? Number(ship.loaders.thrust) : 0;
-    const loaderMass = ship.loaders ? Number(ship.loaders.mass) : 0;
-    return calc_acceleration(thrust, Number(mass) + loaderMass);
-}
-function calc_ship_flighttime(ship, mass, distance) {
-    const acceleration = calc_ship_acceleration(ship, mass);
-    return calc_flighttime(distance, acceleration);
-}
-function calc_ship_acceleration(ship, mass) {
-    const thrust = ship.engines ? Number(ship.engines.thrust) : 0;
-    return calc_acceleration(thrust, Number(mass));
-}
-function calc_acceleration(thrust, mass) {
-    return (thrust / mass) * PRECISION$1;
-}
-function calc_ship_mass(ship, cargos) {
-    const mass = antelope.UInt64.from(0);
-    mass.add(ship.hullmass);
-    if (ship.loaders && ship.loaders.quantity.gt(antelope.UInt32.zero)) {
-        mass.add(ship.loaders.mass.multiplying(ship.loaders.quantity));
-    }
-    for (const cargo of cargos) {
-        mass.add(getItem(cargo.item_id).mass.multiplying(cargo.quantity));
-    }
-    return mass;
-}
-function calc_energyusage(distance, drain) {
-    return antelope.UInt64.from(distance).dividing(PRECISION$1).multiplying(drain);
-}
-function calculateTransferTime(ship, cargos, quantities) {
-    let mass = antelope.UInt64.from(0);
-    for (const cargo of cargos) {
-        const qty = quantities?.get(Number(cargo.item_id)) ?? 0;
-        if (qty > 0) {
-            const good_mass = getItem(cargo.item_id).mass;
-            const cargo_mass = good_mass.multiplying(qty);
-            mass = antelope.UInt64.from(mass).adding(cargo_mass);
-        }
-    }
-    if (mass.equals(antelope.UInt64.zero)) {
-        return antelope.UInt32.from(0);
-    }
-    if (!ship.loaders)
-        return antelope.UInt32.from(0);
-    mass = antelope.UInt64.from(mass).adding(ship.loaders.mass);
-    const transfer_time = calc_loader_flighttime(ship, mass);
-    return transfer_time.dividing(ship.loaders.quantity);
-}
-function calculateRefuelingTime(ship) {
-    return calc_ship_rechargetime(ship);
-}
-function calculateFlightTime(ship, cargos, distance) {
-    const mass = calc_ship_mass(ship, cargos);
-    return calc_ship_flighttime(ship, mass, distance);
-}
-function calculateLoadTimeBreakdown(ship, cargos, loadQuantities, unloadQuantities) {
-    let mass_unload = antelope.UInt64.from(0);
-    let mass_load = antelope.UInt64.from(0);
-    for (const cargo of cargos) {
-        const goodId = Number(cargo.item_id);
-        const loadQty = loadQuantities?.get(goodId) ?? 0;
-        const unloadQty = unloadQuantities?.get(goodId) ?? 0;
-        if (loadQty > 0 || unloadQty > 0) {
-            const good = getItem(cargo.item_id);
-            if (loadQty > 0) {
-                const cargo_mass = good.mass.multiplying(loadQty);
-                mass_load = antelope.UInt64.from(mass_load).adding(cargo_mass);
-            }
-            if (unloadQty > 0) {
-                const cargo_mass = good.mass.multiplying(unloadQty);
-                mass_unload = antelope.UInt64.from(mass_unload).adding(cargo_mass);
-            }
-        }
-    }
-    let unloadTime = 0;
-    let loadTime = 0;
-    if (mass_unload.gt(antelope.UInt64.zero) && ship.loaders) {
-        const totalMass = antelope.UInt64.from(mass_unload).adding(ship.loaders.mass);
-        unloadTime = Number(calc_loader_flighttime(ship, totalMass));
-    }
-    if (mass_load.gt(antelope.UInt64.zero) && ship.loaders) {
-        const totalMass = antelope.UInt64.from(mass_load).adding(ship.loaders.mass);
-        loadTime = Number(calc_loader_flighttime(ship, totalMass));
-    }
-    const numLoaders = ship.loaders ? Number(ship.loaders.quantity) : 0;
-    const totalTime = numLoaders > 0 ? (unloadTime + loadTime) / numLoaders : 0;
-    const unloadTimePerLoader = numLoaders > 0 ? unloadTime / numLoaders : 0;
-    const loadTimePerLoader = numLoaders > 0 ? loadTime / numLoaders : 0;
-    return {
-        unloadTime: unloadTimePerLoader,
-        loadTime: loadTimePerLoader,
-        totalTime,
-        unloadMass: Number(mass_unload),
-        loadMass: Number(mass_load),
-    };
+const ITEM_ENGINE_T1 = 10100;
+const ITEM_GENERATOR_T1 = 10101;
+const ITEM_GATHERER_T1 = 10102;
+const ITEM_LOADER_T1 = 10103;
+const ITEM_MANUFACTURING_T1 = 10104;
+const ITEM_STORAGE_T1 = 10105;
+const ITEM_HAULER_T1 = 10106;
+const MODULE_ANY = 0;
+const MODULE_ENGINE = 1;
+const MODULE_GENERATOR = 2;
+const MODULE_GATHERER = 3;
+const MODULE_LOADER = 4;
+const MODULE_WARP = 5;
+const MODULE_CRAFTER = 6;
+const MODULE_LAUNCHER = 7;
+const MODULE_STORAGE = 8;
+const MODULE_HAULER = 9;
+function moduleAccepts(slotType, moduleType) {
+    return slotType === MODULE_ANY || slotType === moduleType;
 }
-function estimateTravelTime(ship, travelMass, distance, options = {}) {
-    const { needsRecharge = false, loadMass, unloadMass } = options;
-    const flightTime = calc_ship_flighttime(ship, antelope.UInt64.from(travelMass), antelope.UInt64.from(distance));
-    const rechargeTime = needsRecharge ? calc_ship_rechargetime(ship) : antelope.UInt32.zero;
-    let loadTime = antelope.UInt32.zero;
-    let unloadTime = antelope.UInt32.zero;
-    if (loadMass &&
-        antelope.UInt32.from(loadMass).gt(antelope.UInt32.zero) &&
-        ship.loaders &&
-        ship.loaders.quantity.gt(antelope.UInt32.zero)) {
-        const totalMass = antelope.UInt64.from(loadMass).adding(ship.loaders.mass);
-        loadTime = calc_loader_flighttime(ship, totalMass).dividing(ship.loaders.quantity);
-    }
-    if (unloadMass &&
-        antelope.UInt32.from(unloadMass).gt(antelope.UInt32.zero) &&
-        ship.loaders &&
-        ship.loaders.quantity.gt(antelope.UInt32.zero)) {
-        const totalMass = antelope.UInt64.from(unloadMass).adding(ship.loaders.mass);
-        unloadTime = calc_loader_flighttime(ship, totalMass).dividing(ship.loaders.quantity);
+function getModuleCapabilityType(itemId) {
+    switch (itemId) {
+        case ITEM_ENGINE_T1:
+            return MODULE_ENGINE;
+        case ITEM_GENERATOR_T1:
+            return MODULE_GENERATOR;
+        case ITEM_GATHERER_T1:
+            return MODULE_GATHERER;
+        case ITEM_LOADER_T1:
+            return MODULE_LOADER;
+        case ITEM_MANUFACTURING_T1:
+            return MODULE_CRAFTER;
+        case ITEM_STORAGE_T1:
+            return MODULE_STORAGE;
+        case ITEM_HAULER_T1:
+            return MODULE_HAULER;
+        default:
+            return 0xff;
     }
-    return {
-        flightTime,
-        rechargeTime,
-        loadTime,
-        unloadTime,
-        total: flightTime.adding(rechargeTime).adding(loadTime).adding(unloadTime),
-    };
-}
-function estimateDealTravelTime(ship, shipMass, distance, loadMass) {
-    const needsRecharge = !hasEnergyForDistance$1(ship, distance);
-    const estimate = estimateTravelTime(ship, shipMass, distance, {
-        needsRecharge,
-        loadMass,
-    });
-    return estimate.total;
 }
-function hasEnergyForDistance$1(ship, distance) {
-    if (!ship.engines)
-        return false;
-    const energyNeeded = antelope.UInt64.from(distance).dividing(PRECISION$1).multiplying(ship.engines.drain);
-    return antelope.UInt64.from(ship.energy ?? 0).gte(energyNeeded);
-}
-function getFlightOrigin(entity, flightTaskIndex) {
-    if (!entity.schedule)
-        return entity.coordinates;
-    let origin = entity.coordinates;
-    for (let i = 0; i < flightTaskIndex && i < entity.schedule.tasks.length; i++) {
-        const task = entity.schedule.tasks[i];
-        if (task.type.equals(exports.TaskType.TRAVEL) && task.coordinates) {
-            origin = task.coordinates;
-        }
-    }
-    return origin;
-}
-function getDestinationLocation(entity) {
-    if (!entity.schedule)
-        return undefined;
-    for (let i = entity.schedule.tasks.length - 1; i >= 0; i--) {
-        const task = entity.schedule.tasks[i];
-        if (task.type.equals(exports.TaskType.TRAVEL) && task.coordinates) {
-            return task.coordinates;
-        }
-    }
-    return undefined;
-}
-function getPositionAt(entity, taskIndex, taskProgress) {
-    if (!entity.schedule || entity.schedule.tasks.length === 0 || taskIndex < 0) {
-        return entity.coordinates;
-    }
-    const task = entity.schedule.tasks[taskIndex];
-    if (!task.type.equals(exports.TaskType.TRAVEL) || !task.coordinates) {
-        return getFlightOrigin(entity, taskIndex);
-    }
-    const origin = getFlightOrigin(entity, taskIndex);
-    const destination = task.coordinates;
-    const interpolated = lerp(origin, destination, taskProgress);
-    return {
-        x: Math.round(interpolated.x),
-        y: Math.round(interpolated.y),
-    };
-}
-function calc_transfer_duration(source, dest, cargoMass) {
-    if (cargoMass === 0) {
-        return 0;
-    }
-    let totalThrust = 0;
-    let totalLoaderMass = 0;
-    let totalQuantity = 0;
-    if (source.loaders) {
-        const thrust = typeof source.loaders.thrust === 'number'
-            ? source.loaders.thrust
-            : source.loaders.thrust.toNumber();
-        const mass = typeof source.loaders.mass === 'number'
-            ? source.loaders.mass
-            : source.loaders.mass.toNumber();
-        const qty = typeof source.loaders.quantity === 'number'
-            ? source.loaders.quantity
-            : source.loaders.quantity.toNumber();
-        totalThrust += thrust * qty;
-        totalLoaderMass += mass * qty;
-        totalQuantity += qty;
-    }
-    if (dest.loaders) {
-        const thrust = typeof dest.loaders.thrust === 'number'
-            ? dest.loaders.thrust
-            : dest.loaders.thrust.toNumber();
-        const mass = typeof dest.loaders.mass === 'number' ? dest.loaders.mass : dest.loaders.mass.toNumber();
-        const qty = typeof dest.loaders.quantity === 'number'
-            ? dest.loaders.quantity
-            : dest.loaders.quantity.toNumber();
-        totalThrust += thrust * qty;
-        totalLoaderMass += mass * qty;
-        totalQuantity += qty;
-    }
-    if (totalThrust === 0 || totalQuantity === 0) {
-        return 0;
-    }
-    const sourceZ = typeof source.location.z === 'number'
-        ? source.location.z
-        : source.location.z?.toNumber() ?? 0;
-    const destZ = typeof dest.location.z === 'number' ? dest.location.z : dest.location.z?.toNumber() ?? 0;
-    const distance = Math.abs(sourceZ - destZ);
-    const totalMass = cargoMass + totalLoaderMass;
-    const acceleration = calc_acceleration(totalThrust, totalMass);
-    const flightTime = 2 * Math.sqrt(distance / acceleration);
-    return Math.floor(flightTime / totalQuantity);
-}
-
-function capsHasMovement(caps) {
-    return caps.engines !== undefined && caps.generator !== undefined;
-}
-function capsHasStorage(caps) {
-    return caps.capacity !== undefined;
-}
-function capsHasLoaders(caps) {
-    return caps.loaders !== undefined;
-}
-function capsHasGatherer(caps) {
-    return caps.gatherer !== undefined;
-}
-function capsHasMass(caps) {
-    return caps.hullmass !== undefined;
-}
-
-function calcCargoItemMass(item) {
-    const itemDef = getItem(item.item_id);
-    let mass = antelope.UInt64.from(itemDef.mass).multiplying(item.quantity);
-    for (const mod of item.modules) {
-        if (mod.installed) {
-            const modDef = getItem(mod.installed.item_id);
-            mass = mass.adding(modDef.mass);
-        }
-    }
-    return mass;
-}
-function calcCargoMass(entity) {
-    let mass = antelope.UInt64.from(0);
-    for (const item of entity.cargo) {
-        mass = mass.adding(calcCargoItemMass(item));
-    }
-    return mass;
-}
-function availableCapacity$1(entity) {
-    const cargoMass = calcCargoMass(entity);
-    return entity.capacity.gt(cargoMass)
-        ? antelope.UInt64.from(entity.capacity).subtracting(cargoMass)
-        : antelope.UInt64.from(0);
-}
-function availableCapacityFromMass(capacity, cargoMass) {
-    const cap = antelope.UInt64.from(capacity);
-    const mass = antelope.UInt64.from(cargoMass);
-    return cap.gt(mass) ? cap.subtracting(mass) : antelope.UInt64.from(0);
-}
-function hasSpace$1(entity, goodMass, quantity) {
-    const additional = goodMass.multiplying(quantity);
-    return availableCapacity$1(entity).gte(additional);
-}
-function hasSpaceForMass(capacity, currentMass, additionalMass) {
-    return antelope.UInt64.from(currentMass).adding(additionalMass).lte(capacity);
-}
-function isFull$1(entity) {
-    return antelope.UInt64.from(entity.cargomass).gte(entity.capacity);
-}
-function isFullFromMass(capacity, cargoMass) {
-    return antelope.UInt64.from(cargoMass).gte(capacity);
-}
-
-function hasSchedule$1(entity) {
-    return !!entity.schedule && entity.schedule.tasks.length > 0;
-}
-function isIdle(entity) {
-    return !hasSchedule$1(entity);
-}
-function getTasks(entity) {
-    return entity.schedule?.tasks || [];
-}
-function scheduleDuration(entity) {
-    if (!entity.schedule)
-        return 0;
-    return entity.schedule.tasks.reduce((sum, task) => sum + task.duration.toNumber(), 0);
-}
-function scheduleElapsed(entity, now) {
-    if (!entity.schedule)
-        return 0;
-    const started = entity.schedule.started.toDate();
-    const elapsed = Math.floor((now.getTime() - started.getTime()) / 1000);
-    return Math.max(0, elapsed);
-}
-function scheduleRemaining(entity, now) {
-    if (!entity.schedule)
-        return 0;
-    const duration = scheduleDuration(entity);
-    const elapsed = scheduleElapsed(entity, now);
-    return Math.max(0, duration - elapsed);
-}
-function scheduleComplete(entity, now) {
-    return hasSchedule$1(entity) && scheduleRemaining(entity, now) === 0;
-}
-function currentTaskIndex(entity, now) {
-    if (!entity.schedule || entity.schedule.tasks.length === 0)
-        return -1;
-    const elapsed = scheduleElapsed(entity, now);
-    let timeAccum = 0;
-    for (let i = 0; i < entity.schedule.tasks.length; i++) {
-        const taskDuration = entity.schedule.tasks[i].duration.toNumber();
-        if (elapsed < timeAccum + taskDuration) {
-            return i;
-        }
-        timeAccum += taskDuration;
-    }
-    return entity.schedule.tasks.length - 1;
-}
-function currentTask(entity, now) {
-    const index = currentTaskIndex(entity, now);
-    if (index < 0 || !entity.schedule)
-        return undefined;
-    return entity.schedule.tasks[index];
-}
-function currentTaskType(entity, now) {
-    const task = currentTask(entity, now);
-    if (!task)
-        return undefined;
-    return task.type.toNumber();
-}
-function getTaskStartTime(entity, index) {
-    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length)
-        return 0;
-    let timeAccum = 0;
-    for (let i = 0; i < index; i++) {
-        timeAccum += entity.schedule.tasks[i].duration.toNumber();
-    }
-    return timeAccum;
-}
-function getTaskElapsed(entity, index, now) {
-    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length)
-        return 0;
-    const elapsed = scheduleElapsed(entity, now);
-    const taskStart = getTaskStartTime(entity, index);
-    const taskDuration = entity.schedule.tasks[index].duration.toNumber();
-    if (elapsed <= taskStart)
-        return 0;
-    const elapsedInTask = elapsed - taskStart;
-    return Math.min(elapsedInTask, taskDuration);
-}
-function getTaskRemaining(entity, index, now) {
-    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length)
-        return 0;
-    const taskDuration = entity.schedule.tasks[index].duration.toNumber();
-    const taskElapsed = getTaskElapsed(entity, index, now);
-    return Math.max(0, taskDuration - taskElapsed);
-}
-function isTaskComplete(entity, index, now) {
-    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length)
-        return false;
-    const taskDuration = entity.schedule.tasks[index].duration.toNumber();
-    const taskElapsed = getTaskElapsed(entity, index, now);
-    return taskElapsed >= taskDuration;
-}
-function isTaskInProgress(entity, index, now) {
-    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length)
-        return false;
-    const taskElapsed = getTaskElapsed(entity, index, now);
-    const taskDuration = entity.schedule.tasks[index].duration.toNumber();
-    return taskElapsed > 0 && taskElapsed < taskDuration;
-}
-function currentTaskProgress(entity, now) {
-    const task = currentTask(entity, now);
-    if (!task)
-        return 0;
-    const index = currentTaskIndex(entity, now);
-    const elapsed = getTaskElapsed(entity, index, now);
-    const duration = task.duration.toNumber();
-    if (duration === 0)
-        return 1;
-    return Math.min(1, elapsed / duration);
-}
-function scheduleProgress(entity, now) {
-    const duration = scheduleDuration(entity);
-    if (duration === 0)
-        return hasSchedule$1(entity) ? 1 : 0;
-    const elapsed = scheduleElapsed(entity, now);
-    return Math.min(1, elapsed / duration);
-}
-function isTaskType(entity, taskType, now) {
-    return currentTaskType(entity, now) === taskType;
-}
-function isInFlight(entity, now) {
-    return isTaskType(entity, exports.TaskType.TRAVEL, now);
-}
-function isRecharging(entity, now) {
-    return isTaskType(entity, exports.TaskType.RECHARGE, now);
-}
-function isLoading(entity, now) {
-    return isTaskType(entity, exports.TaskType.LOAD, now);
-}
-function isUnloading(entity, now) {
-    return isTaskType(entity, exports.TaskType.UNLOAD, now);
-}
-function isGathering(entity, now) {
-    return isTaskType(entity, exports.TaskType.GATHER, now);
-}
-
-var schedule = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    hasSchedule: hasSchedule$1,
-    isIdle: isIdle,
-    getTasks: getTasks,
-    scheduleDuration: scheduleDuration,
-    scheduleElapsed: scheduleElapsed,
-    scheduleRemaining: scheduleRemaining,
-    scheduleComplete: scheduleComplete,
-    currentTaskIndex: currentTaskIndex,
-    currentTask: currentTask,
-    currentTaskType: currentTaskType,
-    getTaskStartTime: getTaskStartTime,
-    getTaskElapsed: getTaskElapsed,
-    getTaskRemaining: getTaskRemaining,
-    isTaskComplete: isTaskComplete,
-    isTaskInProgress: isTaskInProgress,
-    currentTaskProgress: currentTaskProgress,
-    scheduleProgress: scheduleProgress,
-    isTaskType: isTaskType,
-    isInFlight: isInFlight,
-    isRecharging: isRecharging,
-    isLoading: isLoading,
-    isUnloading: isUnloading,
-    isGathering: isGathering
-});
-
-function getHullMass(entity) {
-    return antelope.UInt32.from(entity.hullmass ?? 0);
-}
-function createProjectedEntity(entity) {
-    const cargoMass = calcCargoMass(entity);
-    const shipMass = getHullMass(entity);
-    const loaders = entity.loaders;
-    const engines = entity.engines;
-    const generator = entity.generator;
-    const hauler = entity.hauler;
-    const capacity = entity.capacity;
-    const projected = {
-        location: Coordinates.from(entity.coordinates),
-        energy: antelope.UInt16.from(entity.energy ?? 0),
-        cargoMass,
-        shipMass,
-        capacity: capacity ? antelope.UInt64.from(capacity) : undefined,
-        engines,
-        generator,
-        hauler,
-        loaders,
-        get totalMass() {
-            let mass = antelope.UInt64.from(this.shipMass).adding(this.cargoMass);
-            if (this.loaders) {
-                mass = mass.adding(this.loaders.mass.multiplying(this.loaders.quantity));
-            }
-            return mass;
-        },
-        hasMovement() {
-            return capsHasMovement(this.capabilities());
-        },
-        hasStorage() {
-            return capsHasStorage(this.capabilities());
-        },
-        hasLoaders() {
-            return capsHasLoaders(this.capabilities());
-        },
-        capabilities() {
-            return {
-                hullmass: this.shipMass,
-                capacity: this.capacity ? antelope.UInt32.from(this.capacity) : undefined,
-                engines: this.engines,
-                generator: this.generator,
-                loaders: this.loaders,
-            };
-        },
-        state() {
-            return {
-                owner: entity.owner ?? antelope.Name.from(''),
-                location: Types.coordinates.from(this.location),
-                energy: this.energy,
-                cargomass: antelope.UInt32.from(this.cargoMass),
-                cargo: entity.cargo,
-            };
-        },
-    };
-    return projected;
-}
-function applyRechargeTask(projected, _task, options) {
-    if (!projected.generator)
-        return;
-    if (options.complete) {
-        projected.energy = antelope.UInt16.from(projected.generator.capacity);
-    }
-    else if (options.progress !== undefined) {
-        const capacity = Number(projected.generator.capacity);
-        const currentEnergy = Number(projected.energy);
-        const rechargeAmount = (capacity - currentEnergy) * options.progress;
-        projected.energy = antelope.UInt16.from(Math.min(capacity, currentEnergy + rechargeAmount));
-    }
-}
-function applyFlightTask(projected, task, options) {
-    if (!task.coordinates || !projected.engines)
-        return;
-    const origin = projected.location;
-    const destination = Coordinates.from(task.coordinates);
-    const distance = distanceBetweenCoordinates(origin, task.coordinates);
-    const energyUsage = distance.dividing(PRECISION$1).multiplying(projected.engines.drain);
-    if (options.complete) {
-        projected.energy = projected.energy.gt(energyUsage)
-            ? antelope.UInt16.from(projected.energy.subtracting(energyUsage))
-            : antelope.UInt16.from(0);
-        projected.location = destination;
-    }
-    else if (options.progress !== undefined) {
-        const interpolated = lerp(origin, destination, options.progress);
-        projected.location = Coordinates.from({
-            x: Math.round(interpolated.x),
-            y: Math.round(interpolated.y),
-        });
-        const partialEnergy = antelope.UInt64.from(Math.floor(Number(energyUsage) * options.progress));
-        projected.energy = projected.energy.gt(partialEnergy)
-            ? antelope.UInt16.from(projected.energy.subtracting(partialEnergy))
-            : antelope.UInt16.from(0);
-    }
-}
-function applyLoadTask(projected, task) {
-    for (const item of task.cargo) {
-        projected.cargoMass = projected.cargoMass.adding(calcCargoItemMass(item));
-    }
-}
-function applyUnloadTask(projected, task) {
-    for (const item of task.cargo) {
-        const cargoMass = calcCargoItemMass(item);
-        projected.cargoMass = projected.cargoMass.gt(cargoMass)
-            ? projected.cargoMass.subtracting(cargoMass)
-            : antelope.UInt64.from(0);
-    }
-}
-function applyEnergyCost(projected, task) {
-    if (!task.energy_cost)
-        return;
-    const energyCost = antelope.UInt16.from(task.energy_cost);
-    projected.energy = projected.energy.gt(energyCost)
-        ? antelope.UInt16.from(projected.energy.subtracting(energyCost))
-        : antelope.UInt16.from(0);
-}
-function applyGatherTask(projected, task, options) {
-    if (!options.complete)
-        return;
-    applyEnergyCost(projected, task);
-    for (const item of task.cargo) {
-        projected.cargoMass = projected.cargoMass.adding(calcCargoItemMass(item));
-    }
-}
-function applyCraftTask(projected, task) {
-    applyEnergyCost(projected, task);
-    if (task.cargo.length > 0) {
-        for (let i = 0; i < task.cargo.length - 1; i++) {
-            const inputMass = calcCargoItemMass(task.cargo[i]);
-            projected.cargoMass = projected.cargoMass.gt(inputMass)
-                ? projected.cargoMass.subtracting(inputMass)
-                : antelope.UInt64.from(0);
-        }
-        const output = task.cargo[task.cargo.length - 1];
-        projected.cargoMass = projected.cargoMass.adding(calcCargoItemMass(output));
-    }
-}
-function applyDeployTask(projected, task) {
-    applyEnergyCost(projected, task);
-    if (task.cargo.length > 0) {
-        const mass = calcCargoItemMass(task.cargo[0]);
-        projected.cargoMass = projected.cargoMass.gt(mass)
-            ? projected.cargoMass.subtracting(mass)
-            : antelope.UInt64.from(0);
-    }
-}
-function projectEntity(entity) {
-    const projected = createProjectedEntity(entity);
-    if (!entity.schedule) {
-        return projected;
-    }
-    for (const task of entity.schedule.tasks) {
-        switch (task.type.toNumber()) {
-            case exports.TaskType.RECHARGE:
-                applyRechargeTask(projected, task, { complete: true });
-                break;
-            case exports.TaskType.TRAVEL:
-                applyFlightTask(projected, task, { complete: true });
-                break;
-            case exports.TaskType.LOAD:
-                applyLoadTask(projected, task);
-                break;
-            case exports.TaskType.UNLOAD:
-                applyUnloadTask(projected, task);
-                break;
-            case exports.TaskType.GATHER:
-                applyGatherTask(projected, task, { complete: true });
-                break;
-            case exports.TaskType.CRAFT:
-                applyCraftTask(projected, task);
-                break;
-            case exports.TaskType.DEPLOY:
-            case exports.TaskType.DEPLOY_SHIP:
-                applyDeployTask(projected, task);
-                break;
-        }
-    }
-    return projected;
-}
-function projectEntityAt(entity, now) {
-    const projected = createProjectedEntity(entity);
-    if (!entity.schedule || entity.schedule.tasks.length === 0) {
-        return projected;
-    }
-    for (let i = 0; i < entity.schedule.tasks.length; i++) {
-        const task = entity.schedule.tasks[i];
-        const taskComplete = isTaskComplete(entity, i, now);
-        const taskInProgress = isTaskInProgress(entity, i, now);
-        if (!taskComplete && !taskInProgress) {
-            break;
-        }
-        const progress = taskInProgress
-            ? getTaskElapsed(entity, i, now) / task.duration.toNumber()
-            : undefined;
-        switch (task.type.toNumber()) {
-            case exports.TaskType.RECHARGE:
-                applyRechargeTask(projected, task, { complete: taskComplete, progress });
-                break;
-            case exports.TaskType.TRAVEL:
-                applyFlightTask(projected, task, { complete: taskComplete, progress });
-                break;
-            case exports.TaskType.LOAD:
-                if (taskComplete) {
-                    applyLoadTask(projected, task);
-                }
-                break;
-            case exports.TaskType.UNLOAD:
-                if (taskComplete) {
-                    applyUnloadTask(projected, task);
-                }
-                break;
-            case exports.TaskType.GATHER:
-                if (taskComplete) {
-                    applyGatherTask(projected, task, { complete: true });
-                }
-                break;
-            case exports.TaskType.CRAFT:
-                if (taskComplete) {
-                    applyCraftTask(projected, task);
-                }
-                break;
-            case exports.TaskType.DEPLOY:
-            case exports.TaskType.DEPLOY_SHIP:
-                if (taskComplete) {
-                    applyDeployTask(projected, task);
-                }
-                break;
-        }
-    }
-    return projected;
-}
-
-class Location {
-    constructor(coordinates) {
-        this.coordinates = Coordinates.from(coordinates);
-    }
-    static from(coordinates) {
-        return new Location(Coordinates.from(coordinates));
-    }
-    hasSystemAt(gameSeed) {
-        const seed = antelope.Checksum256.from(gameSeed);
-        if (this._hasSystem === undefined || !this._gameSeed?.equals(seed)) {
-            this._gameSeed = seed;
-            this._hasSystem = hasSystem(seed, this.coordinates);
-        }
-        return this._hasSystem;
-    }
-    getLocationTypeAt(gameSeed) {
-        return getLocationType(gameSeed, this.coordinates);
-    }
-    isGatherableAt(gameSeed) {
-        return isGatherableLocation(this.getLocationTypeAt(gameSeed));
-    }
-    findNearby(gameSeed, maxDistance = 20) {
-        return findNearbyPlanets(antelope.Checksum256.from(gameSeed), this.coordinates, maxDistance);
-    }
-    equals(other) {
-        const otherCoords = other instanceof Location ? other.coordinates : Coordinates.from(other);
-        return this.coordinates.equals(otherCoords);
-    }
-    get epoch() {
-        return this._epoch;
-    }
-    clearCache() {
-        this._epoch = undefined;
-    }
-}
-function toLocation(coords) {
-    if (coords instanceof Location) {
-        return coords;
-    }
-    return Location.from(coords);
-}
-
-class ScheduleAccessor {
-    constructor(entity) {
-        this.entity = entity;
-    }
-    get hasSchedule() {
-        return hasSchedule$1(this.entity);
-    }
-    get isIdle() {
-        return isIdle(this.entity);
-    }
-    get tasks() {
-        return getTasks(this.entity);
-    }
-    duration() {
-        return scheduleDuration(this.entity);
-    }
-    elapsed(now) {
-        return scheduleElapsed(this.entity, now);
-    }
-    remaining(now) {
-        return scheduleRemaining(this.entity, now);
-    }
-    complete(now) {
-        return scheduleComplete(this.entity, now);
-    }
-    currentTaskIndex(now) {
-        return currentTaskIndex(this.entity, now);
-    }
-    currentTask(now) {
-        return currentTask(this.entity, now);
-    }
-    currentTaskType(now) {
-        return currentTaskType(this.entity, now);
-    }
-    taskStartTime(index) {
-        return getTaskStartTime(this.entity, index);
-    }
-    taskElapsed(index, now) {
-        return getTaskElapsed(this.entity, index, now);
-    }
-    taskRemaining(index, now) {
-        return getTaskRemaining(this.entity, index, now);
-    }
-    taskComplete(index, now) {
-        return isTaskComplete(this.entity, index, now);
-    }
-    taskInProgress(index, now) {
-        return isTaskInProgress(this.entity, index, now);
-    }
-    currentTaskProgress(now) {
-        return currentTaskProgress(this.entity, now);
-    }
-    progress(now) {
-        return scheduleProgress(this.entity, now);
-    }
-}
-function createScheduleAccessor(entity) {
-    return new ScheduleAccessor(entity);
-}
-
-class EntityInventory extends Types.cargo_item {
-    get item() {
-        if (!this._item) {
-            this._item = getItem(this.item_id);
-        }
-        return this._item;
-    }
-    get good() {
-        return this.item;
-    }
-    get name() {
-        return this.item.name;
-    }
-    get unitMass() {
-        return this.item.mass;
-    }
-    get totalMass() {
-        return antelope.UInt64.from(this.unitMass).multiplying(this.quantity);
-    }
-    get hasCargo() {
-        return antelope.UInt32.from(this.quantity).gt(antelope.UInt32.from(0));
-    }
-    get isEmpty() {
-        return antelope.UInt32.from(this.quantity).equals(antelope.UInt32.from(0));
-    }
-}
-
-class InventoryAccessor {
-    constructor(entity) {
-        this.entity = entity;
-    }
-    get items() {
-        if (!this._items) {
-            this._items = this.entity.cargo.map((item) => new EntityInventory(item));
-        }
-        return this._items;
-    }
-    get totalMass() {
-        return this.items.reduce((sum, c) => sum.adding(c.totalMass), antelope.UInt64.from(0));
-    }
-    forItem(goodId) {
-        return this.items.find((c) => c.item_id.equals(goodId));
-    }
-    get sellable() {
-        return this.items.filter((c) => c.hasCargo);
-    }
-    get hasSellable() {
-        return this.items.some((c) => c.hasCargo);
-    }
-    get sellableCount() {
-        return this.items.filter((c) => c.hasCargo).length;
-    }
-}
-function createInventoryAccessor(entity) {
-    return new InventoryAccessor(entity);
-}
-
-function maxTravelDistance(entity) {
-    return antelope.UInt32.from(entity.generator.capacity)
-        .dividing(entity.engines.drain)
-        .multiplying(PRECISION$1);
-}
-function calcEnergyUsage(entity, distance) {
-    return distance.dividing(PRECISION$1).multiplying(entity.engines.drain);
-}
-function hasEnergyForDistance(entity, distance) {
-    const usage = calcEnergyUsage(entity, distance);
-    return antelope.UInt64.from(entity.energy).gte(usage);
-}
-function energyPercent(entity) {
-    return (Number(entity.energy) / Number(entity.generator.capacity)) * 100;
-}
-function needsRecharge(entity) {
-    return antelope.UInt64.from(entity.energy).lt(entity.generator.capacity);
-}
-
-class Ship extends Types.entity_info {
-    get name() {
-        return this.entity_name;
-    }
-    get inv() {
-        return (this._inv ?? (this._inv = new InventoryAccessor(this)));
-    }
-    get inventory() {
-        return this.inv.items;
-    }
-    get sched() {
-        return (this._sched ?? (this._sched = new ScheduleAccessor(this)));
-    }
-    get maxDistance() {
-        if (!this.generator || !this.engines)
-            return antelope.UInt32.from(0);
-        return maxTravelDistance(this);
-    }
-    get isIdle() {
-        return this.is_idle;
-    }
-    getFlightOrigin(flightTaskIndex) {
-        return Coordinates.from(getFlightOrigin(this, flightTaskIndex));
-    }
-    destinationLocation() {
-        const dest = getDestinationLocation(this);
-        return dest ? Coordinates.from(dest) : undefined;
-    }
-    positionAt(now) {
-        const taskIndex = this.sched.currentTaskIndex(now);
-        const progress = this.sched.currentTaskProgress(now);
-        return Coordinates.from(getPositionAt(this, taskIndex, progress));
-    }
-    isInFlight(now) {
-        return isInFlight(this, now);
-    }
-    isRecharging(now) {
-        return isRecharging(this, now);
-    }
-    isLoading(now) {
-        return isLoading(this, now);
-    }
-    isUnloading(now) {
-        return isUnloading(this, now);
-    }
-    isGathering(now) {
-        return isGathering(this, now);
-    }
-    get hasEngines() {
-        return this.engines !== undefined;
-    }
-    get hasGenerator() {
-        return this.generator !== undefined;
-    }
-    get hasGatherer() {
-        return this.gatherer !== undefined;
-    }
-    get hasWarp() {
-        return this.warp !== undefined;
-    }
-    project() {
-        return projectEntity(this);
-    }
-    projectAt(now) {
-        return projectEntityAt(this, now);
-    }
-    get location() {
-        return Location.from(this.coordinates);
-    }
-    get totalCargoMass() {
-        return this.inv.totalMass;
-    }
-    get totalMass() {
-        let mass = antelope.UInt64.from(this.hullmass ?? 0).adding(this.totalCargoMass);
-        if (this.loaders) {
-            mass = mass.adding(antelope.UInt64.from(this.loaders.mass).multiplying(this.loaders.quantity));
-        }
-        return mass;
-    }
-    get maxCapacity() {
-        return antelope.UInt64.from(this.capacity);
-    }
-    hasSpace(goodMass, quantity) {
-        return this.totalMass.adding(goodMass.multiplying(quantity)).lte(this.maxCapacity);
-    }
-    get availableCapacity() {
-        return this.totalMass.gte(this.maxCapacity)
-            ? antelope.UInt64.from(0)
-            : this.maxCapacity.subtracting(this.totalMass);
-    }
-    getCargoForItem(goodId) {
-        return this.inv.forItem(goodId);
-    }
-    get sellableCargo() {
-        return this.inv.sellable;
-    }
-    get hasSellableCargo() {
-        return this.inv.hasSellable;
-    }
-    get sellableGoodsCount() {
-        return this.inv.sellableCount;
-    }
-    get isFull() {
-        return this.totalMass.gte(this.maxCapacity);
-    }
-    get energyPercent() {
-        if (!this.generator || this.energy === undefined)
-            return 0;
-        return energyPercent(this);
-    }
-    get needsRecharge() {
-        if (!this.generator || this.energy === undefined)
-            return false;
-        return needsRecharge(this);
-    }
-    hasEnergyFor(distance) {
-        if (!this.engines || !this.generator || this.energy === undefined)
-            return false;
-        return hasEnergyForDistance(this, distance);
-    }
-}
-
-class Warehouse extends Types.entity_info {
-    get name() {
-        return this.entity_name;
-    }
-    get inv() {
-        return (this._inv ?? (this._inv = new InventoryAccessor(this)));
-    }
-    get inventory() {
-        return this.inv.items;
-    }
-    get sched() {
-        return (this._sched ?? (this._sched = new ScheduleAccessor(this)));
-    }
-    get isIdle() {
-        return this.is_idle;
-    }
-    isLoading(now) {
-        return isLoading(this, now);
-    }
-    isUnloading(now) {
-        return isUnloading(this, now);
-    }
-    get location() {
-        return Location.from(this.coordinates);
-    }
-    get totalCargoMass() {
-        return this.inv.totalMass;
-    }
-    get maxCapacity() {
-        return antelope.UInt64.from(this.capacity);
-    }
-    get availableCapacity() {
-        const cargo = this.totalCargoMass;
-        return cargo.gte(this.maxCapacity) ? antelope.UInt64.from(0) : this.maxCapacity.subtracting(cargo);
-    }
-    hasSpace(goodMass, quantity) {
-        return this.totalCargoMass.adding(goodMass.multiplying(quantity)).lte(this.maxCapacity);
-    }
-    get isFull() {
-        return this.totalCargoMass.gte(this.maxCapacity);
-    }
-    getCargoForItem(goodId) {
-        return this.inv.forItem(goodId);
-    }
-    get orbitalAltitude() {
-        return this.coordinates.z?.toNumber() || 0;
-    }
-    get totalMass() {
-        const hull = this.hullmass ? antelope.UInt64.from(this.hullmass) : antelope.UInt64.from(0);
-        return hull.adding(this.totalCargoMass);
-    }
-}
-
-class Container extends Types.entity_info {
-    get name() {
-        return this.entity_name;
-    }
-    get sched() {
-        return (this._sched ?? (this._sched = new ScheduleAccessor(this)));
-    }
-    get isIdle() {
-        return this.is_idle;
-    }
-    isLoading(now) {
-        return isLoading(this, now);
-    }
-    isUnloading(now) {
-        return isUnloading(this, now);
-    }
-    get location() {
-        return Location.from(this.coordinates);
-    }
-    get totalMass() {
-        return antelope.UInt64.from(this.hullmass ?? 0).adding(this.cargomass);
-    }
-    get maxCapacity() {
-        return antelope.UInt64.from(this.capacity);
-    }
-    get availableCapacity() {
-        const cargo = antelope.UInt64.from(this.cargomass);
-        return cargo.gte(this.maxCapacity) ? antelope.UInt64.from(0) : this.maxCapacity.subtracting(cargo);
-    }
-    hasSpace(additionalMass) {
-        return antelope.UInt64.from(this.cargomass).adding(additionalMass).lte(this.maxCapacity);
-    }
-    get isFull() {
-        return antelope.UInt64.from(this.cargomass).gte(this.maxCapacity);
-    }
-    get orbitalAltitude() {
-        return this.coordinates.z?.toNumber() || 0;
-    }
-}
-function computeContainerCapabilities(stats) {
-    const density = stats['density'] ?? 500;
-    const strength = stats['strength'] ?? 500;
-    const ductility = stats['ductility'] ?? 500;
-    const purity = stats['purity'] ?? 500;
-    const hullmass = 25000 + 75 * density;
-    const statSum = strength + ductility + purity;
-    const exponent = statSum / 2997;
-    const capacity = Math.floor(1000000 * Math.pow(10, exponent));
-    return { hullmass, capacity };
-}
-function computeContainerT2Capabilities(stats) {
-    const strength = stats['strength'] ?? 0;
-    const density = stats['density'] ?? 0;
-    const ductility = stats['ductility'] ?? 0;
-    const purity = stats['purity'] ?? 0;
-    const hullmass = 20000 + 50 * density;
-    const statSum = strength + ductility + purity;
-    const exponent = statSum / 2500;
-    const capacity = Math.floor(1500000 * Math.pow(10, exponent));
-    return { hullmass, capacity };
-}
-
-class EntitiesManager extends BaseManager {
-    async getEntity(type, id) {
-        const result = await this.server.readonly('getentity', {
-            entity_type: antelope.Name.from(type),
-            entity_id: id,
-        });
-        const entityInfo = result;
-        return this.wrapEntity(entityInfo);
-    }
-    async getEntities(owner, type) {
-        const ownerName = this.resolveOwner(owner);
-        const result = await this.server.readonly('getentities', {
-            owner: ownerName,
-            entity_type: type ? antelope.Name.from(type) : null,
-        });
-        const entities = result;
-        return entities.map((entity) => this.wrapEntity(entity));
-    }
-    async getSummaries(owner, type) {
-        const ownerName = this.resolveOwner(owner);
-        const result = await this.server.readonly('getsummaries', {
-            owner: ownerName,
-            entity_type: type ? antelope.Name.from(type) : null,
-        });
-        return result;
-    }
-    async getShip(id) {
-        return (await this.getEntity('ship', id));
-    }
-    async getWarehouse(id) {
-        return (await this.getEntity('warehouse', id));
-    }
-    async getContainer(id) {
-        return (await this.getEntity('container', id));
-    }
-    async getShips(owner) {
-        return (await this.getEntities(owner, 'ship'));
-    }
-    async getWarehouses(owner) {
-        return (await this.getEntities(owner, 'warehouse'));
-    }
-    async getContainers(owner) {
-        return (await this.getEntities(owner, 'container'));
-    }
-    async getShipSummaries(owner) {
-        return this.getSummaries(owner, 'ship');
-    }
-    async getWarehouseSummaries(owner) {
-        return this.getSummaries(owner, 'warehouse');
-    }
-    async getContainerSummaries(owner) {
-        return this.getSummaries(owner, 'container');
-    }
-    wrapEntity(entity) {
-        if (entity.type.equals('ship')) {
-            return new Ship(entity);
-        }
-        else if (entity.type.equals('warehouse')) {
-            return new Warehouse(entity);
-        }
-        else {
-            return new Container(entity);
-        }
-    }
-    resolveOwner(owner) {
-        if (typeof owner === 'object' && owner !== null && 'owner' in owner) {
-            return owner.owner;
-        }
-        return antelope.Name.from(owner);
-    }
-}
-
-class Player extends Types.player_row {
-    static fromState(state) {
-        const playerRow = Types.player_row.from({
-            owner: antelope.Name.from(state.owner),
-        });
-        return new Player(playerRow);
-    }
-}
-
-class PlayersManager extends BaseManager {
-    async getPlayer(account) {
-        const playerRow = await this.server.table('player').get(antelope.Name.from(account));
-        if (!playerRow) {
-            return undefined;
-        }
-        return new Player(playerRow);
-    }
-}
-
-class LocationsManager extends BaseManager {
-    async hasSystem(location) {
-        const game = await this.getGame();
-        return hasSystem(game.config.seed, location);
-    }
-    async findNearbyPlanets(origin, maxDistance = 20) {
-        const game = await this.getGame();
-        return findNearbyPlanets(game.config.seed, origin, maxDistance);
-    }
-    async getLocationEntity(id) {
-        const row = await this.server.table('location').get(antelope.UInt64.from(id));
-        return row ?? undefined;
-    }
-    async getLocationEntityAt(coords) {
-        const id = coordsToLocationId(coords);
-        return this.getLocationEntity(id);
-    }
-    async getAllLocationEntities() {
-        return this.server.table('location').all();
-    }
-}
-
-class EpochsManager extends BaseManager {
-    async getCurrentHeight() {
-        const game = await this.getGame();
-        return getCurrentEpoch(game);
-    }
-    async getCurrent() {
-        const game = await this.getGame();
-        const epoch = await this.getCurrentHeight();
-        return getEpochInfo(game, epoch);
-    }
-    async getByHeight(height) {
-        const game = await this.getGame();
-        return getEpochInfo(game, antelope.UInt64.from(height));
-    }
-    async getTimeRemaining() {
-        const epochInfo = await this.getCurrent();
-        const now = Date.now();
-        const endTime = epochInfo.end.getTime();
-        return Math.max(0, endTime - now);
-    }
-    async getProgress() {
-        const epochInfo = await this.getCurrent();
-        const now = Date.now();
-        const startTime = epochInfo.start.getTime();
-        const endTime = epochInfo.end.getTime();
-        const duration = endTime - startTime;
-        const elapsed = now - startTime;
-        if (elapsed <= 0)
-            return 0;
-        if (elapsed >= duration)
-            return 1;
-        return elapsed / duration;
-    }
-    async fitsInCurrentEpoch(durationMs) {
-        const remaining = await this.getTimeRemaining();
-        return durationMs <= remaining;
-    }
-}
-
-class ActionsManager extends BaseManager {
-    travel(shipId, destination, recharge = true) {
-        const x = antelope.Int64.from(destination.x);
-        const y = antelope.Int64.from(destination.y);
-        return this.server.action('travel', {
-            entity_type: EntityType.SHIP,
-            id: antelope.UInt64.from(shipId),
-            x,
-            y,
-            recharge,
-        });
-    }
-    grouptravel(entities, destination, recharge = true) {
-        const entityRefs = entities.map((e) => Types.entity_ref.from({
-            entity_type: e.entityType,
-            entity_id: antelope.UInt64.from(e.entityId),
-        }));
-        const x = antelope.Int64.from(destination.x);
-        const y = antelope.Int64.from(destination.y);
-        return this.server.action('grouptravel', {
-            entities: entityRefs,
-            x,
-            y,
-            recharge,
-        });
-    }
-    resolve(entityId, entityType = EntityType.SHIP) {
-        return this.server.action('resolve', {
-            entity_type: entityType,
-            id: antelope.UInt64.from(entityId),
-        });
-    }
-    cancel(entityId, count, entityType = EntityType.SHIP) {
-        return this.server.action('cancel', {
-            entity_type: entityType,
-            id: antelope.UInt64.from(entityId),
-            count: antelope.UInt64.from(count),
-        });
-    }
-    recharge(shipId) {
-        return this.server.action('recharge', {
-            entity_type: EntityType.SHIP,
-            id: antelope.UInt64.from(shipId),
-        });
-    }
-    transfer(sourceType, sourceId, destType, destId, goodId, quantity) {
-        return this.server.action('transfer', {
-            source_type: sourceType,
-            source_id: antelope.UInt64.from(sourceId),
-            dest_type: destType,
-            dest_id: antelope.UInt64.from(destId),
-            item_id: antelope.UInt16.from(goodId),
-            quantity: antelope.UInt32.from(quantity),
-        });
-    }
-    foundCompany(account, name) {
-        return this.platform.action('foundcompany', {
-            account: antelope.Name.from(account),
-            name,
-        });
-    }
-    join(account) {
-        return this.server.action('join', {
-            account: antelope.Name.from(account),
-        });
-    }
-    gather(shipId, stratum, quantity) {
-        return this.server.action('gather', {
-            entity_type: EntityType.SHIP,
-            id: antelope.UInt64.from(shipId),
-            stratum: antelope.UInt16.from(stratum),
-            quantity: antelope.UInt32.from(quantity),
-        });
-    }
-    warp(shipId, destination) {
-        const x = antelope.Int64.from(destination.x);
-        const y = antelope.Int64.from(destination.y);
-        return this.server.action('warp', {
-            entity_type: EntityType.SHIP,
-            id: antelope.UInt64.from(shipId),
-            x,
-            y,
-        });
-    }
-    craft(entityType, entityId, recipeId, quantity, inputs) {
-        const cargoInputs = inputs.map((i) => Types.cargo_item.from(i));
-        return this.server.action('craft', {
-            entity_type: entityType,
-            id: antelope.UInt64.from(entityId),
-            recipe_id: antelope.UInt16.from(recipeId),
-            quantity: antelope.UInt32.from(quantity),
-            inputs: cargoInputs,
-        });
-    }
-    blend(entityType, entityId, inputs) {
-        const cargoInputs = inputs.map((i) => Types.cargo_item.from(i));
-        return this.server.action('blend', {
-            entity_type: entityType,
-            id: antelope.UInt64.from(entityId),
-            inputs: cargoInputs,
-        });
-    }
-    deploy(entityType, entityId, packedItemId, seed, entityName) {
-        return this.server.action('deploy', {
-            entity_type: entityType,
-            id: antelope.UInt64.from(entityId),
-            packed_item_id: antelope.UInt16.from(packedItemId),
-            seed: antelope.UInt64.from(seed),
-            entity_name: entityName,
-        });
-    }
-    addmodule(entityType, entityId, moduleIndex, moduleCargoId, targetCargoId = antelope.UInt64.from(0)) {
-        return this.server.action('addmodule', {
-            entity_type: entityType,
-            entity_id: antelope.UInt64.from(entityId),
-            module_index: moduleIndex,
-            module_cargo_id: antelope.UInt64.from(moduleCargoId),
-            target_cargo_id: antelope.UInt64.from(targetCargoId),
-        });
-    }
-    rmmodule(entityType, entityId, moduleIndex, targetCargoId = antelope.UInt64.from(0)) {
-        return this.server.action('rmmodule', {
-            entity_type: entityType,
-            entity_id: antelope.UInt64.from(entityId),
-            module_index: moduleIndex,
-            target_cargo_id: antelope.UInt64.from(targetCargoId),
-        });
-    }
-    joinGame(account, companyName) {
-        return [this.foundCompany(account, companyName), this.join(account)];
-    }
-}
-
-class GameContext {
-    constructor(client, server, platform) {
-        this.client = client;
-        this.server = server;
-        this.platform = platform;
-    }
-    get entities() {
-        if (!this._entities) {
-            this._entities = new EntitiesManager(this);
-        }
-        return this._entities;
-    }
-    get players() {
-        if (!this._players) {
-            this._players = new PlayersManager(this);
-        }
-        return this._players;
-    }
-    get locations() {
-        if (!this._locations) {
-            this._locations = new LocationsManager(this);
-        }
-        return this._locations;
-    }
-    get epochs() {
-        if (!this._epochs) {
-            this._epochs = new EpochsManager(this);
-        }
-        return this._epochs;
-    }
-    get actions() {
-        if (!this._actions) {
-            this._actions = new ActionsManager(this);
-        }
-        return this._actions;
-    }
-    async getGame(reload = false) {
-        if (!reload && this._gameCache) {
-            return this._gameCache;
-        }
-        const game = await this.platform.table('games').get();
-        if (!game) {
-            throw new Error('Game not initialized');
-        }
-        this._gameCache = game;
-        return game;
-    }
-    async getState(reload = false) {
-        if (!reload && this._stateCache) {
-            return this._stateCache;
-        }
-        const state = await this.server.table('state').get();
-        if (!state) {
-            throw new Error('Game state not initialized');
-        }
-        const game = this._gameCache;
-        this._stateCache = GameState.from(state, game);
-        return this._stateCache;
-    }
-    get cachedGame() {
-        return this._gameCache;
-    }
-    get cachedState() {
-        return this._stateCache;
-    }
-}
-
-class Shipload {
-    constructor(chain, constructorOptions) {
-        const { client, platformContract, serverContract } = constructorOptions || {};
-        const apiClient = client || new antelope.APIClient({ url: chain.url });
-        const platform$1 = platformContract
-            ? platformContract
-            : new Contract$1({ client: apiClient });
-        const server$1 = serverContract
-            ? serverContract
-            : new Contract({ client: apiClient });
-        this._context = new GameContext(apiClient, server$1, platform$1);
-    }
-    static async load(chain, shiploadOptions) {
-        let platform$1 = new Contract$1({
-            client: new antelope.APIClient({ url: chain.url }),
-        });
-        if (shiploadOptions?.platformContractName) {
-            const client = shiploadOptions.client || new antelope.APIClient({ url: chain.url });
-            const contractKit = new ContractKit__default["default"]({ client });
-            platform$1 = await contractKit.load(shiploadOptions.platformContractName);
-        }
-        let server$1 = new Contract({
-            client: new antelope.APIClient({ url: chain.url }),
-        });
-        if (shiploadOptions?.serverContractName) {
-            const client = shiploadOptions.client || new antelope.APIClient({ url: chain.url });
-            const contractKit = new ContractKit__default["default"]({ client });
-            server$1 = await contractKit.load(shiploadOptions.serverContractName);
-        }
-        return new Shipload(chain, {
-            ...shiploadOptions,
-            platformContract: platform$1,
-            serverContract: server$1,
-        });
-    }
-    get client() {
-        return this._context.client;
-    }
-    get server() {
-        return this._context.server;
-    }
-    get platform() {
-        return this._context.platform;
-    }
-    get entities() {
-        return this._context.entities;
-    }
-    get players() {
-        return this._context.players;
-    }
-    get locations() {
-        return this._context.locations;
-    }
-    get epochs() {
-        return this._context.epochs;
-    }
-    get actions() {
-        return this._context.actions;
-    }
-    async getGame(reload = false) {
-        return this._context.getGame(reload);
-    }
-    async getState(reload = false) {
-        return this._context.getState(reload);
-    }
-}
-
-function makeShip(state) {
-    const info = {
-        type: antelope.Name.from('ship'),
-        id: antelope.UInt64.from(state.id),
-        owner: antelope.Name.from(state.owner),
-        entity_name: state.name,
-        coordinates: Types.coordinates.from(state.coordinates),
-        cargomass: antelope.UInt32.from(0),
-        cargo: state.cargo || [],
-        is_idle: !state.schedule,
-        current_task_elapsed: antelope.UInt32.from(0),
-        current_task_remaining: antelope.UInt32.from(0),
-        pending_tasks: [],
-    };
-    if (state.hullmass !== undefined)
-        info.hullmass = antelope.UInt32.from(state.hullmass);
-    if (state.capacity !== undefined)
-        info.capacity = antelope.UInt32.from(state.capacity);
-    if (state.energy !== undefined)
-        info.energy = antelope.UInt16.from(state.energy);
-    if (state.engines)
-        info.engines = state.engines;
-    if (state.generator)
-        info.generator = state.generator;
-    if (state.loaders)
-        info.loaders = state.loaders;
-    if (state.schedule)
-        info.schedule = state.schedule;
-    const entityInfo = Types.entity_info.from(info);
-    return new Ship(entityInfo);
-}
-function makeWarehouse(state) {
-    const info = {
-        type: antelope.Name.from('warehouse'),
-        id: antelope.UInt64.from(state.id),
-        owner: antelope.Name.from(state.owner),
-        entity_name: state.name,
-        coordinates: Types.coordinates.from(state.coordinates),
-        capacity: antelope.UInt32.from(state.capacity),
-        cargomass: antelope.UInt32.from(0),
-        cargo: state.cargo || [],
-        is_idle: !state.schedule,
-        current_task_elapsed: antelope.UInt32.from(0),
-        current_task_remaining: antelope.UInt32.from(0),
-        pending_tasks: [],
-    };
-    if (state.hullmass !== undefined)
-        info.hullmass = antelope.UInt32.from(state.hullmass);
-    if (state.loaders)
-        info.loaders = state.loaders;
-    if (state.schedule)
-        info.schedule = state.schedule;
-    const entityInfo = Types.entity_info.from(info);
-    return new Warehouse(entityInfo);
-}
-function makeContainer(state) {
-    const entityInfo = Types.entity_info.from({
-        type: antelope.Name.from('container'),
-        id: antelope.UInt64.from(state.id),
-        owner: antelope.Name.from(state.owner),
-        entity_name: state.name,
-        coordinates: Types.coordinates.from(state.coordinates),
-        hullmass: antelope.UInt32.from(state.hullmass),
-        capacity: antelope.UInt32.from(state.capacity),
-        cargomass: antelope.UInt32.from(state.cargomass || 0),
-        cargo: [],
-        is_idle: !state.schedule,
-        current_task_elapsed: antelope.UInt32.from(0),
-        current_task_remaining: antelope.UInt32.from(0),
-        pending_tasks: [],
-        schedule: state.schedule,
-    });
-    return new Container(entityInfo);
-}
-
-function deriveStratum(epochSeed, coords, stratum, locationType, subtype, _maxDepth) {
-    const seed = antelope.Checksum256.from(epochSeed);
-    const c = Coordinates.from(coords);
-    const input = `stratum-${c.x}-${c.y}-${stratum}`;
-    const hashResult = hash512(seed, input);
-    const bytes = hashResult.array;
-    const rawReserve = ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0;
-    let reserve = 0;
-    if (rawReserve <= YIELD_THRESHOLD) {
-        const baseReserve = (rawReserve % 333) + 1;
-        const scale = depthScaleFactor(stratum);
-        reserve = Math.floor(baseReserve * scale);
-    }
-    if (reserve === 0)
-        return { itemId: 0, seed: 0n, richness: 0, reserve: 0 };
-    const eligible = getEligibleResources(locationType, subtype, stratum);
-    if (eligible.length === 0)
-        return { itemId: 0, seed: 0n, richness: 0, reserve: 0 };
-    const resourceRoll = ((bytes[4] << 24) | (bytes[5] << 16) | (bytes[6] << 8) | bytes[7]) >>> 0;
-    let totalWeight = 0;
-    for (const id of eligible) {
-        totalWeight += getResourceWeight(id, stratum);
-    }
-    let selectedItemId = eligible[0];
-    if (totalWeight > 0) {
-        const roll = resourceRoll % totalWeight;
-        let cumulative = 0;
-        for (const id of eligible) {
-            cumulative += getResourceWeight(id, stratum);
-            if (roll < cumulative) {
-                selectedItemId = id;
-                break;
-            }
-        }
-    }
-    const seedBigInt = (BigInt(bytes[8]) << 56n) |
-        (BigInt(bytes[9]) << 48n) |
-        (BigInt(bytes[10]) << 40n) |
-        (BigInt(bytes[11]) << 32n) |
-        (BigInt(bytes[12]) << 24n) |
-        (BigInt(bytes[13]) << 16n) |
-        (BigInt(bytes[14]) << 8n) |
-        BigInt(bytes[15]);
-    const rawRichness = (bytes[16] << 8) | bytes[17];
-    const normalized = rawRichness / 65535;
-    const baseRichness = Math.floor(normalized * normalized * 999) + 1;
-    let depthBonus = 0;
-    if (stratum > 1) {
-        depthBonus = (50 * Math.log(stratum)) / Math.log(65535);
-    }
-    const richness = Math.min(Math.floor(baseRichness + depthBonus), 1000);
-    return { itemId: selectedItemId, seed: seedBigInt, richness, reserve };
-}
-function deriveResourceStats(seed) {
-    const seedBytes = new Uint8Array(8);
-    for (let i = 0; i < 8; i++) {
-        seedBytes[i] = Number(seed & 0xffn);
-        seed >>= 8n;
-    }
-    const hashResult = antelope.Checksum256.hash(antelope.Bytes.from(seedBytes));
-    const hashBytes = hashResult.array;
-    const extractU32 = (offset) => (hashBytes[offset] * 0x1000000 +
-        (hashBytes[offset + 1] << 16) +
-        (hashBytes[offset + 2] << 8) +
-        hashBytes[offset + 3]) >>> 0;
-    const weibull = (raw) => {
-        const u = raw / 4294967296;
-        let x = 0.27 * Math.sqrt(-Math.log(1 - u));
-        if (x > 1)
-            x = 1;
-        let val = Math.floor(x * 999) + 1;
-        if (val > 999)
-            val = 999;
-        return val;
-    };
-    return {
-        stat1: weibull(extractU32(0)),
-        stat2: weibull(extractU32(4)),
-        stat3: weibull(extractU32(8)),
-    };
-}
-
-const METAL_STATS = [
-    {
-        key: 'strength',
-        label: 'Strength',
-        abbreviation: 'STR',
-        purpose: 'Raw structural/mechanical force',
-    },
-    {
-        key: 'tolerance',
-        label: 'Tolerance',
-        abbreviation: 'TOL',
-        purpose: 'Ability to withstand heat, pressure, and stress extremes',
-    },
-    {
-        key: 'density',
-        label: 'Density',
-        abbreviation: 'DEN',
-        purpose: 'Mass per unit',
-        inverted: true,
-    },
-];
-const PRECIOUS_STATS = [
-    {
-        key: 'conductivity',
-        label: 'Conductivity',
-        abbreviation: 'CON',
-        purpose: 'Efficiency of energy/signal transfer',
-    },
-    {
-        key: 'ductility',
-        label: 'Ductility',
-        abbreviation: 'DUC',
-        purpose: 'Ability to be worked into fine, precise shapes',
-    },
-    {
-        key: 'reflectivity',
-        label: 'Reflectivity',
-        abbreviation: 'REF',
-        purpose: 'Surface quality for heat management and precision optics',
-    },
-];
-const GAS_STATS = [
-    {
-        key: 'volatility',
-        label: 'Volatility',
-        abbreviation: 'VOL',
-        purpose: 'Energy release potential for propulsion and force',
-    },
-    {
-        key: 'reactivity',
-        label: 'Reactivity',
-        abbreviation: 'REA',
-        purpose: 'Chemical interaction speed for processing and penetration',
-    },
-    {
-        key: 'thermal',
-        label: 'Thermal',
-        abbreviation: 'THM',
-        purpose: 'Heat capacity for thermal management',
-    },
-];
-const MINERAL_STATS = [
-    {
-        key: 'resonance',
-        label: 'Resonance',
-        abbreviation: 'RES',
-        purpose: 'Energy field interaction — storage, focusing, projection',
-    },
-    {
-        key: 'hardness',
-        label: 'Hardness',
-        abbreviation: 'HRD',
-        purpose: 'Resistance to wear — cutting surfaces, penetration',
-    },
-    {
-        key: 'clarity',
-        label: 'Clarity',
-        abbreviation: 'CLR',
-        purpose: 'Crystalline perfection — precision optics',
-    },
-];
-const ORGANIC_STATS = [
-    {
-        key: 'plasticity',
-        label: 'Plasticity',
-        abbreviation: 'PLA',
-        purpose: 'Ease of reshaping — speeds processing',
-    },
-    {
-        key: 'insulation',
-        label: 'Insulation',
-        abbreviation: 'INS',
-        purpose: 'Energy containment — reduces energy loss',
-    },
-    {
-        key: 'purity',
-        label: 'Purity',
-        abbreviation: 'PUR',
-        purpose: 'Biological cleanliness — better composites and lubricants',
-    },
-];
-const STAT_MAP = {
-    metal: METAL_STATS,
-    precious: PRECIOUS_STATS,
-    gas: GAS_STATS,
-    mineral: MINERAL_STATS,
-    organic: ORGANIC_STATS,
-};
-function getStatDefinitions(category) {
-    return STAT_MAP[category];
-}
-function getStatName(category, index) {
-    return STAT_MAP[category][index];
-}
-function resolveStats(category, stats) {
-    return {
-        definitions: STAT_MAP[category],
-        values: [stats.stat1, stats.stat2, stats.stat3],
-    };
-}
-
-const ITEM_ENGINE_T1 = 10100;
-const ITEM_GENERATOR_T1 = 10101;
-const ITEM_GATHERER_T1 = 10102;
-const ITEM_LOADER_T1 = 10103;
-const ITEM_MANUFACTURING_T1 = 10104;
-const ITEM_STORAGE_T1 = 10105;
-const ITEM_HAULER_T1 = 10106;
-const MODULE_ANY = 0;
-const MODULE_ENGINE = 1;
-const MODULE_GENERATOR = 2;
-const MODULE_GATHERER = 3;
-const MODULE_LOADER = 4;
-const MODULE_WARP = 5;
-const MODULE_CRAFTER = 6;
-const MODULE_LAUNCHER = 7;
-const MODULE_STORAGE = 8;
-const MODULE_HAULER = 9;
-function moduleAccepts(slotType, moduleType) {
-    return slotType === MODULE_ANY || slotType === moduleType;
-}
-function getModuleCapabilityType(itemId) {
-    switch (itemId) {
-        case ITEM_ENGINE_T1:
-            return MODULE_ENGINE;
-        case ITEM_GENERATOR_T1:
-            return MODULE_GENERATOR;
-        case ITEM_GATHERER_T1:
-            return MODULE_GATHERER;
-        case ITEM_LOADER_T1:
-            return MODULE_LOADER;
-        case ITEM_MANUFACTURING_T1:
-            return MODULE_CRAFTER;
-        case ITEM_STORAGE_T1:
-            return MODULE_STORAGE;
-        case ITEM_HAULER_T1:
-            return MODULE_HAULER;
-        default:
-            return 0xff;
-    }
-}
-function isModuleItem(itemId) {
-    return getModuleCapabilityType(itemId) !== 0xff;
+function isModuleItem(itemId) {
+    return getModuleCapabilityType(itemId) !== 0xff;
 }
 
 const ITEM_MATTER_CONDUIT = 10005;
@@ -7249,211 +5371,2320 @@ const moduleRecipes = [
 function getModuleRecipe(id) {
     return moduleRecipes.find((r) => r.id === id);
 }
-function getModuleRecipeByItemId(itemId) {
-    return moduleRecipes.find((r) => r.itemId === itemId);
+function getModuleRecipeByItemId(itemId) {
+    return moduleRecipes.find((r) => r.itemId === itemId);
+}
+function getComponentById(id) {
+    return components.find((c) => c.id === id);
+}
+function getEntityRecipe(id) {
+    return entityRecipes.find((r) => r.id === id);
+}
+function getEntityRecipeByItemId(itemId) {
+    return entityRecipes.find((r) => r.packedItemId === itemId);
+}
+function getEntitySlotLayout(packedItemId) {
+    const recipe = getEntityRecipeByItemId(packedItemId);
+    return recipe?.moduleSlots ?? [];
+}
+function getAllCraftableItems() {
+    const items = [];
+    for (const comp of components) {
+        items.push({
+            type: 'component',
+            id: comp.id,
+            name: comp.name,
+            description: comp.description,
+            color: comp.color,
+        });
+    }
+    for (const entity of entityRecipes) {
+        items.push({
+            type: 'entity',
+            id: entity.id,
+            name: entity.name,
+            description: entity.description,
+            color: entity.color,
+        });
+    }
+    for (const mod of moduleRecipes) {
+        items.push({
+            type: 'module',
+            id: mod.id,
+            name: mod.name,
+            description: mod.description,
+            color: mod.color,
+        });
+    }
+    return items;
+}
+function getComponentsForCategory(category) {
+    return components.filter((c) => c.recipe.some((r) => r.category === category));
+}
+function getComponentsForStat(statKey) {
+    return components.filter((c) => c.stats.some((s) => s.key === statKey));
+}
+
+const METAL_STATS = [
+    {
+        key: 'strength',
+        label: 'Strength',
+        abbreviation: 'STR',
+        purpose: 'Raw structural/mechanical force',
+    },
+    {
+        key: 'tolerance',
+        label: 'Tolerance',
+        abbreviation: 'TOL',
+        purpose: 'Ability to withstand heat, pressure, and stress extremes',
+    },
+    {
+        key: 'density',
+        label: 'Density',
+        abbreviation: 'DEN',
+        purpose: 'Mass per unit',
+        inverted: true,
+    },
+];
+const PRECIOUS_STATS = [
+    {
+        key: 'conductivity',
+        label: 'Conductivity',
+        abbreviation: 'CON',
+        purpose: 'Efficiency of energy/signal transfer',
+    },
+    {
+        key: 'ductility',
+        label: 'Ductility',
+        abbreviation: 'DUC',
+        purpose: 'Ability to be worked into fine, precise shapes',
+    },
+    {
+        key: 'reflectivity',
+        label: 'Reflectivity',
+        abbreviation: 'REF',
+        purpose: 'Surface quality for heat management and precision optics',
+    },
+];
+const GAS_STATS = [
+    {
+        key: 'volatility',
+        label: 'Volatility',
+        abbreviation: 'VOL',
+        purpose: 'Energy release potential for propulsion and force',
+    },
+    {
+        key: 'reactivity',
+        label: 'Reactivity',
+        abbreviation: 'REA',
+        purpose: 'Chemical interaction speed for processing and penetration',
+    },
+    {
+        key: 'thermal',
+        label: 'Thermal',
+        abbreviation: 'THM',
+        purpose: 'Heat capacity for thermal management',
+    },
+];
+const MINERAL_STATS = [
+    {
+        key: 'resonance',
+        label: 'Resonance',
+        abbreviation: 'RES',
+        purpose: 'Energy field interaction — storage, focusing, projection',
+    },
+    {
+        key: 'hardness',
+        label: 'Hardness',
+        abbreviation: 'HRD',
+        purpose: 'Resistance to wear — cutting surfaces, penetration',
+    },
+    {
+        key: 'clarity',
+        label: 'Clarity',
+        abbreviation: 'CLR',
+        purpose: 'Crystalline perfection — precision optics',
+    },
+];
+const ORGANIC_STATS = [
+    {
+        key: 'plasticity',
+        label: 'Plasticity',
+        abbreviation: 'PLA',
+        purpose: 'Ease of reshaping — speeds processing',
+    },
+    {
+        key: 'insulation',
+        label: 'Insulation',
+        abbreviation: 'INS',
+        purpose: 'Energy containment — reduces energy loss',
+    },
+    {
+        key: 'purity',
+        label: 'Purity',
+        abbreviation: 'PUR',
+        purpose: 'Biological cleanliness — better composites and lubricants',
+    },
+];
+const STAT_MAP = {
+    metal: METAL_STATS,
+    precious: PRECIOUS_STATS,
+    gas: GAS_STATS,
+    mineral: MINERAL_STATS,
+    organic: ORGANIC_STATS,
+};
+function getStatDefinitions(category) {
+    return STAT_MAP[category];
+}
+function getStatName(category, index) {
+    return STAT_MAP[category][index];
+}
+function resolveStats(category, stats) {
+    return {
+        definitions: STAT_MAP[category],
+        values: [stats.stat1, stats.stat2, stats.stat3],
+    };
+}
+
+const RESERVE_TIERS = {
+    small: { min: 15, max: 60 },
+    medium: { min: 100, max: 200 },
+    large: { min: 400, max: 700 },
+    massive: { min: 1000, max: 2500 },
+    motherlode: { min: 4000, max: 10000 },
+};
+const SHALLOW_THRESHOLDS = {
+    small: 0.8,
+    medium: 0.991946,
+    large: 0.999946,
+    massive: 0.999996,
+};
+const DEEP_THRESHOLDS = {
+    small: 0.5,
+    medium: 0.95892,
+    large: 0.99892,
+    massive: 0.99992,
+};
+const TIER_ROLL_MAX = 0x10000;
+function lerp$1(a, b, t) {
+    return a + (b - a) * t;
+}
+function rollTier(tierRoll, stratum) {
+    const d = Math.min(stratum, 65535) / 65535;
+    const smallMax = lerp$1(SHALLOW_THRESHOLDS.small, DEEP_THRESHOLDS.small, d) * TIER_ROLL_MAX;
+    const mediumMax = lerp$1(SHALLOW_THRESHOLDS.medium, DEEP_THRESHOLDS.medium, d) * TIER_ROLL_MAX;
+    const largeMax = lerp$1(SHALLOW_THRESHOLDS.large, DEEP_THRESHOLDS.large, d) * TIER_ROLL_MAX;
+    const massiveMax = lerp$1(SHALLOW_THRESHOLDS.massive, DEEP_THRESHOLDS.massive, d) * TIER_ROLL_MAX;
+    if (tierRoll < smallMax)
+        return 'small';
+    if (tierRoll < mediumMax)
+        return 'medium';
+    if (tierRoll < largeMax)
+        return 'large';
+    if (tierRoll < massiveMax)
+        return 'massive';
+    return 'motherlode';
+}
+function rollWithinTier(withinRoll, range) {
+    const u = withinRoll / 65535;
+    const skewed = u * u;
+    return Math.floor(range.min + skewed * (range.max - range.min));
+}
+
+function deriveStratum(epochSeed, coords, stratum, locationType, subtype, _maxDepth) {
+    const seed = antelope.Checksum256.from(epochSeed);
+    const c = Coordinates.from(coords);
+    const input = `stratum-${c.x}-${c.y}-${stratum}`;
+    const hashResult = hash512(seed, input);
+    const bytes = hashResult.array;
+    const rawReserve = ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0;
+    let reserve = 0;
+    if (rawReserve <= YIELD_THRESHOLD) {
+        const tierRoll = ((bytes[18] << 8) | bytes[19]) >>> 0;
+        const withinRoll = ((bytes[20] << 8) | bytes[21]) >>> 0;
+        const tier = rollTier(tierRoll, stratum);
+        reserve = rollWithinTier(withinRoll, RESERVE_TIERS[tier]);
+    }
+    if (reserve === 0)
+        return { itemId: 0, seed: 0n, richness: 0, reserve: 0 };
+    const eligible = getEligibleResources(locationType, subtype, stratum);
+    if (eligible.length === 0)
+        return { itemId: 0, seed: 0n, richness: 0, reserve: 0 };
+    const resourceRoll = ((bytes[4] << 24) | (bytes[5] << 16) | (bytes[6] << 8) | bytes[7]) >>> 0;
+    let totalWeight = 0;
+    for (const id of eligible) {
+        totalWeight += getResourceWeight(id, stratum);
+    }
+    let selectedItemId = eligible[0];
+    if (totalWeight > 0) {
+        const roll = resourceRoll % totalWeight;
+        let cumulative = 0;
+        for (const id of eligible) {
+            cumulative += getResourceWeight(id, stratum);
+            if (roll < cumulative) {
+                selectedItemId = id;
+                break;
+            }
+        }
+    }
+    const seedBigInt = (BigInt(bytes[8]) << 56n) |
+        (BigInt(bytes[9]) << 48n) |
+        (BigInt(bytes[10]) << 40n) |
+        (BigInt(bytes[11]) << 32n) |
+        (BigInt(bytes[12]) << 24n) |
+        (BigInt(bytes[13]) << 16n) |
+        (BigInt(bytes[14]) << 8n) |
+        BigInt(bytes[15]);
+    const rawRichness = (bytes[16] << 8) | bytes[17];
+    const normalized = rawRichness / 65535;
+    const baseRichness = Math.floor(normalized * normalized * 999) + 1;
+    let depthBonus = 0;
+    if (stratum > 1) {
+        depthBonus = (50 * Math.log(stratum)) / Math.log(65535);
+    }
+    const richness = Math.min(Math.floor(baseRichness + depthBonus), 1000);
+    return { itemId: selectedItemId, seed: seedBigInt, richness, reserve };
+}
+function deriveResourceStats(seed) {
+    const seedBytes = new Uint8Array(8);
+    for (let i = 0; i < 8; i++) {
+        seedBytes[i] = Number(seed & 0xffn);
+        seed >>= 8n;
+    }
+    const hashResult = antelope.Checksum256.hash(antelope.Bytes.from(seedBytes));
+    const hashBytes = hashResult.array;
+    const extractU32 = (offset) => (hashBytes[offset] * 0x1000000 +
+        (hashBytes[offset + 1] << 16) +
+        (hashBytes[offset + 2] << 8) +
+        hashBytes[offset + 3]) >>>
+        0;
+    const weibull = (raw) => {
+        const u = raw / 4294967296;
+        let x = 0.24 * Math.sqrt(-Math.log(1 - u));
+        if (x > 1)
+            x = 1;
+        let val = Math.floor(x * 999) + 1;
+        if (val > 999)
+            val = 999;
+        return val;
+    };
+    return {
+        stat1: weibull(extractU32(0)),
+        stat2: weibull(extractU32(4)),
+        stat3: weibull(extractU32(8)),
+    };
+}
+
+function encodeStats(values) {
+    let seed = 0n;
+    for (let i = 0; i < values.length && i < 6; i++) {
+        seed |= BigInt(values[i] & 0x3ff) << BigInt(i * 10);
+    }
+    return seed;
+}
+function decodeStat(seed, index) {
+    return Number((seed >> BigInt(index * 10)) & 0x3ffn);
+}
+function decodeStats(seed, count) {
+    const stats = [];
+    for (let i = 0; i < count; i++) {
+        stats.push(decodeStat(seed, i));
+    }
+    return stats;
+}
+function mapStatsToKeys(seed, statDefs) {
+    const values = decodeStats(seed, statDefs.length);
+    const result = {};
+    for (let i = 0; i < statDefs.length; i++) {
+        result[statDefs[i].key] = values[i];
+    }
+    return result;
+}
+function decodeCraftedItemStats(itemId, seed) {
+    const comp = getComponentById(itemId);
+    if (comp)
+        return mapStatsToKeys(seed, comp.stats);
+    const entityRecipe = entityRecipes.find((r) => r.packedItemId === itemId);
+    if (entityRecipe)
+        return mapStatsToKeys(seed, entityRecipe.stats);
+    const moduleRecipe = moduleRecipes.find((r) => r.itemId === itemId);
+    if (moduleRecipe)
+        return mapStatsToKeys(seed, moduleRecipe.stats);
+    return {};
+}
+function blendStacks(stacks, statKey) {
+    let totalQty = 0;
+    let weightedSum = 0;
+    for (const stack of stacks) {
+        const val = stack.stats[statKey] ?? 0;
+        weightedSum += val * stack.quantity;
+        totalQty += stack.quantity;
+    }
+    if (totalQty === 0)
+        return 0;
+    return Math.floor(weightedSum / totalQty);
+}
+function computeComponentStats(componentId, categoryStacks) {
+    const comp = getComponentById(componentId);
+    if (!comp)
+        return [];
+    return comp.stats.map((statDef) => {
+        const matching = categoryStacks.find((cs) => cs.category === statDef.source);
+        const value = matching ? blendStacks(matching.stacks, statDef.key) : 0;
+        return { key: statDef.key, value: Math.max(1, Math.min(999, value)) };
+    });
+}
+function blendComponentStacks(stacks) {
+    if (stacks.length === 0)
+        return {};
+    const allKeys = new Set();
+    for (const s of stacks) {
+        for (const k of Object.keys(s.stats))
+            allKeys.add(k);
+    }
+    const result = {};
+    for (const key of allKeys) {
+        result[key] = blendStacks(stacks.map((s) => ({ quantity: s.quantity, stats: s.stats })), key);
+    }
+    return result;
+}
+function computeEntityStats(entityRecipeId, componentStacks) {
+    const recipe = getEntityRecipe(entityRecipeId) ?? getModuleRecipe(entityRecipeId);
+    if (!recipe)
+        return [];
+    const blendedByComponent = {};
+    for (const [compId, stacks] of Object.entries(componentStacks)) {
+        blendedByComponent[Number(compId)] = blendComponentStacks(stacks);
+    }
+    return recipe.stats.map((stat) => {
+        const blended = blendedByComponent[stat.sourceComponentId] ?? {};
+        const value = blended[stat.sourceStatKey] ?? 0;
+        return { key: stat.key, value: Math.max(1, Math.min(999, value)) };
+    });
+}
+function decodeStackStats(itemId, seed) {
+    if (itemId >= 10000) {
+        return decodeCraftedItemStats(itemId, BigInt(seed.toString()));
+    }
+    const raw = deriveResourceStats(BigInt(seed.toString()));
+    return { stat1: raw.stat1, stat2: raw.stat2, stat3: raw.stat3 };
+}
+const categoryItemMass = {
+    metal: 30000,
+    precious: 40000,
+    gas: 15000,
+    mineral: 22000,
+    organic: 15000,
+};
+function computeInputMass(itemId, itemType) {
+    if (itemType === 'component') {
+        const comp = getComponentById(itemId);
+        if (!comp)
+            return 0;
+        return comp.recipe.reduce((sum, input) => {
+            const mass = input.category ? categoryItemMass[input.category] ?? 0 : 0;
+            return sum + mass * input.quantity;
+        }, 0);
+    }
+    if (itemType === 'module') {
+        const mod = getModuleRecipe(itemId);
+        if (!mod)
+            return 0;
+        return mod.recipe.reduce((sum, input) => {
+            const comp = input.itemId ? getComponentById(input.itemId) : undefined;
+            return sum + (comp?.mass ?? 0) * input.quantity;
+        }, 0);
+    }
+    if (itemType === 'entity') {
+        const ent = getEntityRecipe(itemId);
+        if (!ent)
+            return 0;
+        return ent.recipe.reduce((sum, input) => {
+            const comp = input.itemId ? getComponentById(input.itemId) : undefined;
+            return sum + (comp?.mass ?? 0) * input.quantity;
+        }, 0);
+    }
+    return 0;
+}
+function blendCrossGroup(sources) {
+    let weightedSum = 0;
+    let totalWeight = 0;
+    for (const src of sources) {
+        weightedSum += src.value * src.weight;
+        totalWeight += src.weight;
+    }
+    if (totalWeight === 0)
+        return 1;
+    const result = Math.floor(weightedSum / totalWeight);
+    return Math.max(1, Math.min(999, result));
+}
+function blendCargoStacks(itemId, stacks) {
+    const decoded = stacks.map((s) => ({
+        quantity: s.quantity,
+        stats: decodeStackStats(itemId, s.seed),
+    }));
+    const allKeys = Object.keys(decoded[0]?.stats ?? {});
+    const blended = allKeys.map((key) => Math.max(1, Math.min(999, blendStacks(decoded, key))));
+    return antelope.UInt64.from(encodeStats(blended));
+}
+function decodeRawStackToCategoryStats(seed, category) {
+    const raw = deriveResourceStats(seed);
+    const defs = getStatDefinitions(category);
+    const result = {};
+    if (defs[0])
+        result[defs[0].key] = raw.stat1;
+    if (defs[1])
+        result[defs[1].key] = raw.stat2;
+    if (defs[2])
+        result[defs[2].key] = raw.stat3;
+    return result;
+}
+function computeCraftedOutputSeed(outputItemId, slotInputs) {
+    var _a;
+    const component = getComponentById(outputItemId);
+    if (component) {
+        const categoryStacks = [];
+        for (const slot of slotInputs) {
+            if (!slot.category)
+                continue;
+            const slotIsComponent = getComponentById(slot.itemId) !== undefined;
+            const stacks = slot.stacks.map((s) => ({
+                quantity: s.quantity,
+                stats: slotIsComponent
+                    ? decodeCraftedItemStats(slot.itemId, s.seed)
+                    : decodeRawStackToCategoryStats(s.seed, slot.category),
+            }));
+            categoryStacks.push({ category: slot.category, stacks });
+        }
+        const stats = computeComponentStats(outputItemId, categoryStacks);
+        const ordered = component.stats.map((statDef) => {
+            const found = stats.find((s) => s.key === statDef.key);
+            return found ? found.value : 0;
+        });
+        return antelope.UInt64.from(encodeStats(ordered));
+    }
+    const entityRecipe = getEntityRecipeByItemId(outputItemId);
+    if (entityRecipe) {
+        const componentStacks = {};
+        for (const slot of slotInputs) {
+            if (slot.category !== undefined) {
+                throw new Error(`entity recipe ${entityRecipe.id} expects component inputs but slot itemId=${slot.itemId} has category=${slot.category}`);
+            }
+            const list = (componentStacks[_a = slot.itemId] ?? (componentStacks[_a] = []));
+            for (const s of slot.stacks) {
+                list.push({
+                    quantity: s.quantity,
+                    stats: decodeCraftedItemStats(slot.itemId, s.seed),
+                });
+            }
+        }
+        const stats = computeEntityStats(entityRecipe.id, componentStacks);
+        const ordered = entityRecipe.stats.map((statDef) => {
+            const found = stats.find((s) => s.key === statDef.key);
+            return found ? found.value : 0;
+        });
+        return antelope.UInt64.from(encodeStats(ordered));
+    }
+    throw new Error(`computeCraftedOutputSeed: no recipe found for outputItemId=${outputItemId}`);
+}
+
+const itemsById = new Map();
+const synthesizedCache = new Map();
+for (const g of itemsData) {
+    const item = exports.Item.from({
+        id: g.id,
+        name: g.name,
+        description: g.description,
+        mass: g.mass,
+        category: g.category,
+        tier: g.tier,
+        color: g.color,
+    });
+    itemsById.set(item.id.toNumber(), item);
+}
+const itemIds = Array.from(itemsById.values(), (i) => i.id);
+function synthesizeItem(id, source) {
+    return exports.Item.from({
+        id,
+        name: source.name,
+        description: source.description,
+        mass: source.mass,
+        category: 'metal',
+        tier: 't1',
+        color: source.color,
+    });
+}
+function synthesizeFromRecipes(id) {
+    const component = getComponentById(id);
+    if (component)
+        return synthesizeItem(id, component);
+    const entityRecipe = getEntityRecipeByItemId(id);
+    if (entityRecipe) {
+        return synthesizeItem(id, {
+            ...entityRecipe,
+            mass: computeInputMass(entityRecipe.id, 'entity'),
+        });
+    }
+    const moduleRecipe = getModuleRecipeByItemId(id);
+    if (moduleRecipe) {
+        return synthesizeItem(id, {
+            ...moduleRecipe,
+            mass: computeInputMass(moduleRecipe.id, 'module'),
+        });
+    }
+    return undefined;
+}
+function getItem(itemId) {
+    const id = antelope.UInt16.from(itemId).toNumber();
+    const existing = itemsById.get(id) ?? synthesizedCache.get(id);
+    if (existing)
+        return existing;
+    const synthesized = synthesizeFromRecipes(id);
+    if (synthesized) {
+        synthesizedCache.set(id, synthesized);
+        return synthesized;
+    }
+    throw new Error(`Item with id ${id} not found`);
+}
+function getItems() {
+    return Array.from(itemsById.values());
+}
+
+function calc_orbital_altitude(mass) {
+    if (mass <= BASE_ORBITAL_MASS) {
+        return MIN_ORBITAL_ALTITUDE;
+    }
+    const ratio = mass / BASE_ORBITAL_MASS;
+    const capRatio = 10.0;
+    let scale = Math.log(ratio) / Math.log(capRatio);
+    scale = Math.min(scale, 1.0);
+    return MIN_ORBITAL_ALTITUDE + Math.floor((MAX_ORBITAL_ALTITUDE - MIN_ORBITAL_ALTITUDE) * scale);
+}
+function distanceBetweenCoordinates(origin, destination) {
+    return distanceBetweenPoints(origin.x, origin.y, destination.x, destination.y);
+}
+function distanceBetweenPoints(x1, y1, x2, y2) {
+    const x = Math.pow(x1 - x2, 2);
+    const y = Math.pow(y1 - y2, 2);
+    return antelope.UInt64.from(Math.sqrt(x + y) * PRECISION$1);
+}
+function lerp(origin, destination, time) {
+    return {
+        x: (1 - time) * Number(origin.x) + time * Number(destination.x),
+        y: (1 - time) * Number(origin.y) + time * Number(destination.y),
+    };
+}
+function rotation(origin, destination) {
+    return Math.atan2(destination.y - origin.y, destination.x - origin.x) * (180 / Math.PI) + 90;
+}
+function findNearbyPlanets(seed, origin, maxDistance = 20 * PRECISION$1) {
+    const nearbySystems = [];
+    const max = antelope.UInt64.from(maxDistance / PRECISION$1);
+    const xMin = antelope.Int64.from(origin.x).subtracting(max);
+    const xMax = antelope.Int64.from(origin.x).adding(max);
+    const yMin = antelope.Int64.from(origin.y).subtracting(max);
+    const yMax = antelope.Int64.from(origin.y).adding(max);
+    for (let x = Number(xMin); x <= Number(xMax); x++) {
+        for (let y = Number(yMin); y <= Number(yMax); y++) {
+            const samePlace = x === Number(origin.x) && y === Number(origin.y);
+            if (!samePlace) {
+                const distance = distanceBetweenPoints(origin.x, origin.y, x, y);
+                if (Number(distance) <= Number(maxDistance)) {
+                    const system = hasSystem(seed, { x, y });
+                    if (system) {
+                        nearbySystems.push({ origin, destination: { x, y }, distance });
+                    }
+                }
+            }
+        }
+    }
+    return nearbySystems;
+}
+function calc_rechargetime(capacity, energy, recharge) {
+    const cap = antelope.UInt32.from(capacity);
+    const eng = antelope.UInt32.from(energy);
+    if (eng.gte(cap))
+        return antelope.UInt32.zero;
+    return cap.subtracting(eng).dividing(recharge);
+}
+function calc_ship_rechargetime(ship) {
+    if (!ship.generator)
+        return antelope.UInt32.from(0);
+    return calc_rechargetime(ship.generator.capacity, ship.energy ?? antelope.UInt16.from(0), ship.generator.recharge);
+}
+function calc_flighttime(distance, acceleration) {
+    return antelope.UInt32.from(2 * Math.sqrt(Number(distance) / acceleration));
+}
+function calc_loader_flighttime(ship, mass, altitude) {
+    const z = altitude ?? ship.coordinates.z?.toNumber() ?? calc_orbital_altitude(Number(mass));
+    return calc_flighttime(z, calc_loader_acceleration(ship, mass));
+}
+function calc_loader_acceleration(ship, mass) {
+    const thrust = ship.loaders ? Number(ship.loaders.thrust) : 0;
+    const loaderMass = ship.loaders ? Number(ship.loaders.mass) : 0;
+    return calc_acceleration(thrust, Number(mass) + loaderMass);
+}
+function calc_ship_flighttime(ship, mass, distance) {
+    const acceleration = calc_ship_acceleration(ship, mass);
+    return calc_flighttime(distance, acceleration);
+}
+function calc_ship_acceleration(ship, mass) {
+    const thrust = ship.engines ? Number(ship.engines.thrust) : 0;
+    return calc_acceleration(thrust, Number(mass));
+}
+function calc_acceleration(thrust, mass) {
+    return (thrust / mass) * PRECISION$1;
+}
+function calc_ship_mass(ship, cargos) {
+    const mass = antelope.UInt64.from(0);
+    mass.add(ship.hullmass);
+    if (ship.loaders && ship.loaders.quantity.gt(antelope.UInt32.zero)) {
+        mass.add(ship.loaders.mass.multiplying(ship.loaders.quantity));
+    }
+    for (const cargo of cargos) {
+        mass.add(getItem(cargo.item_id).mass.multiplying(cargo.quantity));
+    }
+    return mass;
+}
+function calc_energyusage(distance, drain) {
+    return antelope.UInt64.from(distance).dividing(PRECISION$1).multiplying(drain);
+}
+function calculateTransferTime(ship, cargos, quantities) {
+    let mass = antelope.UInt64.from(0);
+    for (const cargo of cargos) {
+        const qty = quantities?.get(Number(cargo.item_id)) ?? 0;
+        if (qty > 0) {
+            const good_mass = getItem(cargo.item_id).mass;
+            const cargo_mass = good_mass.multiplying(qty);
+            mass = antelope.UInt64.from(mass).adding(cargo_mass);
+        }
+    }
+    if (mass.equals(antelope.UInt64.zero)) {
+        return antelope.UInt32.from(0);
+    }
+    if (!ship.loaders)
+        return antelope.UInt32.from(0);
+    mass = antelope.UInt64.from(mass).adding(ship.loaders.mass);
+    const transfer_time = calc_loader_flighttime(ship, mass);
+    return transfer_time.dividing(ship.loaders.quantity);
+}
+function calculateRefuelingTime(ship) {
+    return calc_ship_rechargetime(ship);
+}
+function calculateFlightTime(ship, cargos, distance) {
+    const mass = calc_ship_mass(ship, cargos);
+    return calc_ship_flighttime(ship, mass, distance);
+}
+function calculateLoadTimeBreakdown(ship, cargos, loadQuantities, unloadQuantities) {
+    let mass_unload = antelope.UInt64.from(0);
+    let mass_load = antelope.UInt64.from(0);
+    for (const cargo of cargos) {
+        const goodId = Number(cargo.item_id);
+        const loadQty = loadQuantities?.get(goodId) ?? 0;
+        const unloadQty = unloadQuantities?.get(goodId) ?? 0;
+        if (loadQty > 0 || unloadQty > 0) {
+            const good = getItem(cargo.item_id);
+            if (loadQty > 0) {
+                const cargo_mass = good.mass.multiplying(loadQty);
+                mass_load = antelope.UInt64.from(mass_load).adding(cargo_mass);
+            }
+            if (unloadQty > 0) {
+                const cargo_mass = good.mass.multiplying(unloadQty);
+                mass_unload = antelope.UInt64.from(mass_unload).adding(cargo_mass);
+            }
+        }
+    }
+    let unloadTime = 0;
+    let loadTime = 0;
+    if (mass_unload.gt(antelope.UInt64.zero) && ship.loaders) {
+        const totalMass = antelope.UInt64.from(mass_unload).adding(ship.loaders.mass);
+        unloadTime = Number(calc_loader_flighttime(ship, totalMass));
+    }
+    if (mass_load.gt(antelope.UInt64.zero) && ship.loaders) {
+        const totalMass = antelope.UInt64.from(mass_load).adding(ship.loaders.mass);
+        loadTime = Number(calc_loader_flighttime(ship, totalMass));
+    }
+    const numLoaders = ship.loaders ? Number(ship.loaders.quantity) : 0;
+    const totalTime = numLoaders > 0 ? (unloadTime + loadTime) / numLoaders : 0;
+    const unloadTimePerLoader = numLoaders > 0 ? unloadTime / numLoaders : 0;
+    const loadTimePerLoader = numLoaders > 0 ? loadTime / numLoaders : 0;
+    return {
+        unloadTime: unloadTimePerLoader,
+        loadTime: loadTimePerLoader,
+        totalTime,
+        unloadMass: Number(mass_unload),
+        loadMass: Number(mass_load),
+    };
+}
+function estimateTravelTime(ship, travelMass, distance, options = {}) {
+    const { needsRecharge = false, loadMass, unloadMass } = options;
+    const flightTime = calc_ship_flighttime(ship, antelope.UInt64.from(travelMass), antelope.UInt64.from(distance));
+    const rechargeTime = needsRecharge ? calc_ship_rechargetime(ship) : antelope.UInt32.zero;
+    let loadTime = antelope.UInt32.zero;
+    let unloadTime = antelope.UInt32.zero;
+    if (loadMass &&
+        antelope.UInt32.from(loadMass).gt(antelope.UInt32.zero) &&
+        ship.loaders &&
+        ship.loaders.quantity.gt(antelope.UInt32.zero)) {
+        const totalMass = antelope.UInt64.from(loadMass).adding(ship.loaders.mass);
+        loadTime = calc_loader_flighttime(ship, totalMass).dividing(ship.loaders.quantity);
+    }
+    if (unloadMass &&
+        antelope.UInt32.from(unloadMass).gt(antelope.UInt32.zero) &&
+        ship.loaders &&
+        ship.loaders.quantity.gt(antelope.UInt32.zero)) {
+        const totalMass = antelope.UInt64.from(unloadMass).adding(ship.loaders.mass);
+        unloadTime = calc_loader_flighttime(ship, totalMass).dividing(ship.loaders.quantity);
+    }
+    return {
+        flightTime,
+        rechargeTime,
+        loadTime,
+        unloadTime,
+        total: flightTime.adding(rechargeTime).adding(loadTime).adding(unloadTime),
+    };
+}
+function estimateDealTravelTime(ship, shipMass, distance, loadMass) {
+    const needsRecharge = !hasEnergyForDistance$1(ship, distance);
+    const estimate = estimateTravelTime(ship, shipMass, distance, {
+        needsRecharge,
+        loadMass,
+    });
+    return estimate.total;
+}
+function hasEnergyForDistance$1(ship, distance) {
+    if (!ship.engines)
+        return false;
+    const energyNeeded = antelope.UInt64.from(distance).dividing(PRECISION$1).multiplying(ship.engines.drain);
+    return antelope.UInt64.from(ship.energy ?? 0).gte(energyNeeded);
+}
+function getFlightOrigin(entity, flightTaskIndex) {
+    if (!entity.schedule)
+        return entity.coordinates;
+    let origin = entity.coordinates;
+    for (let i = 0; i < flightTaskIndex && i < entity.schedule.tasks.length; i++) {
+        const task = entity.schedule.tasks[i];
+        if (task.type.equals(exports.TaskType.TRAVEL) && task.coordinates) {
+            origin = task.coordinates;
+        }
+    }
+    return origin;
+}
+function getDestinationLocation(entity) {
+    if (!entity.schedule)
+        return undefined;
+    for (let i = entity.schedule.tasks.length - 1; i >= 0; i--) {
+        const task = entity.schedule.tasks[i];
+        if (task.type.equals(exports.TaskType.TRAVEL) && task.coordinates) {
+            return task.coordinates;
+        }
+    }
+    return undefined;
+}
+function getPositionAt(entity, taskIndex, taskProgress) {
+    if (!entity.schedule || entity.schedule.tasks.length === 0 || taskIndex < 0) {
+        return entity.coordinates;
+    }
+    const task = entity.schedule.tasks[taskIndex];
+    if (!task.type.equals(exports.TaskType.TRAVEL) || !task.coordinates) {
+        return getFlightOrigin(entity, taskIndex);
+    }
+    const origin = getFlightOrigin(entity, taskIndex);
+    const destination = task.coordinates;
+    const interpolated = lerp(origin, destination, taskProgress);
+    return {
+        x: Math.round(interpolated.x),
+        y: Math.round(interpolated.y),
+    };
+}
+function calc_transfer_duration(source, dest, cargoMass) {
+    if (cargoMass === 0) {
+        return 0;
+    }
+    let totalThrust = 0;
+    let totalLoaderMass = 0;
+    let totalQuantity = 0;
+    if (source.loaders) {
+        const thrust = typeof source.loaders.thrust === 'number'
+            ? source.loaders.thrust
+            : source.loaders.thrust.toNumber();
+        const mass = typeof source.loaders.mass === 'number'
+            ? source.loaders.mass
+            : source.loaders.mass.toNumber();
+        const qty = typeof source.loaders.quantity === 'number'
+            ? source.loaders.quantity
+            : source.loaders.quantity.toNumber();
+        totalThrust += thrust * qty;
+        totalLoaderMass += mass * qty;
+        totalQuantity += qty;
+    }
+    if (dest.loaders) {
+        const thrust = typeof dest.loaders.thrust === 'number'
+            ? dest.loaders.thrust
+            : dest.loaders.thrust.toNumber();
+        const mass = typeof dest.loaders.mass === 'number' ? dest.loaders.mass : dest.loaders.mass.toNumber();
+        const qty = typeof dest.loaders.quantity === 'number'
+            ? dest.loaders.quantity
+            : dest.loaders.quantity.toNumber();
+        totalThrust += thrust * qty;
+        totalLoaderMass += mass * qty;
+        totalQuantity += qty;
+    }
+    if (totalThrust === 0 || totalQuantity === 0) {
+        return 0;
+    }
+    const sourceZ = typeof source.location.z === 'number'
+        ? source.location.z
+        : source.location.z?.toNumber() ?? 0;
+    const destZ = typeof dest.location.z === 'number' ? dest.location.z : dest.location.z?.toNumber() ?? 0;
+    const distance = Math.abs(sourceZ - destZ);
+    const totalMass = cargoMass + totalLoaderMass;
+    const acceleration = calc_acceleration(totalThrust, totalMass);
+    const flightTime = 2 * Math.sqrt(distance / acceleration);
+    return Math.floor(flightTime / totalQuantity);
+}
+
+function capsHasMovement(caps) {
+    return caps.engines !== undefined && caps.generator !== undefined;
+}
+function capsHasStorage(caps) {
+    return caps.capacity !== undefined;
+}
+function capsHasLoaders(caps) {
+    return caps.loaders !== undefined;
+}
+function capsHasGatherer(caps) {
+    return caps.gatherer !== undefined;
+}
+function capsHasMass(caps) {
+    return caps.hullmass !== undefined;
+}
+
+function calcCargoItemMass(item) {
+    const itemDef = getItem(item.item_id);
+    let mass = antelope.UInt64.from(itemDef.mass).multiplying(item.quantity);
+    for (const mod of item.modules) {
+        if (mod.installed) {
+            const modDef = getItem(mod.installed.item_id);
+            mass = mass.adding(modDef.mass);
+        }
+    }
+    return mass;
+}
+function calcCargoMass(entity) {
+    let mass = antelope.UInt64.from(0);
+    for (const item of entity.cargo) {
+        mass = mass.adding(calcCargoItemMass(item));
+    }
+    return mass;
+}
+function calcStacksMass(stacks) {
+    let mass = antelope.UInt64.from(0);
+    for (const s of stacks) {
+        mass = mass.adding(calcCargoItemMass(s));
+    }
+    return mass;
+}
+function availableCapacity$1(entity) {
+    const cargoMass = calcCargoMass(entity);
+    return entity.capacity.gt(cargoMass)
+        ? antelope.UInt64.from(entity.capacity).subtracting(cargoMass)
+        : antelope.UInt64.from(0);
+}
+function availableCapacityFromMass(capacity, cargoMass) {
+    const cap = antelope.UInt64.from(capacity);
+    const mass = antelope.UInt64.from(cargoMass);
+    return cap.gt(mass) ? cap.subtracting(mass) : antelope.UInt64.from(0);
+}
+function hasSpace$1(entity, goodMass, quantity) {
+    const additional = goodMass.multiplying(quantity);
+    return availableCapacity$1(entity).gte(additional);
+}
+function hasSpaceForMass(capacity, currentMass, additionalMass) {
+    return antelope.UInt64.from(currentMass).adding(additionalMass).lte(capacity);
+}
+function isFull$1(entity) {
+    return antelope.UInt64.from(entity.cargomass).gte(entity.capacity);
+}
+function isFullFromMass(capacity, cargoMass) {
+    return antelope.UInt64.from(cargoMass).gte(capacity);
+}
+function cargoItemToStack(item) {
+    return {
+        item_id: antelope.UInt16.from(item.item_id),
+        quantity: antelope.UInt32.from(item.quantity),
+        seed: item.seed,
+        modules: item.modules ?? [],
+    };
+}
+function stackToCargoItem(stack) {
+    return Types.cargo_item.from({
+        item_id: stack.item_id,
+        quantity: stack.quantity,
+        seed: stack.seed,
+        modules: stack.modules,
+    });
+}
+function seedEquals(a, b) {
+    if (!a && !b)
+        return true;
+    if (!a || !b)
+        return false;
+    return a.equals(b);
+}
+function stackIdentityEqual(a, b) {
+    return a.item_id.equals(b.item_id) && seedEquals(a.seed, b.seed);
+}
+function stackKey(s) {
+    const seedVal = s.seed ? s.seed.toString() : '0';
+    return `${s.item_id.toNumber()}:${seedVal}`;
+}
+function stacksEqual(a, b) {
+    return stackIdentityEqual(a, b) && a.quantity.equals(b.quantity);
+}
+function mergeStacks(stacks, add) {
+    const idx = stacks.findIndex((s) => stackIdentityEqual(s, add));
+    if (idx === -1) {
+        return [...stacks, { ...add }];
+    }
+    const result = stacks.slice();
+    result[idx] = {
+        ...result[idx],
+        quantity: antelope.UInt32.from(result[idx].quantity.adding(add.quantity)),
+    };
+    return result;
+}
+function removeFromStacks(stacks, remove) {
+    const idx = stacks.findIndex((s) => stackIdentityEqual(s, remove));
+    if (idx === -1) {
+        throw new Error(INSUFFICIENT_ITEM_QUANTITY);
+    }
+    const target = stacks[idx];
+    if (target.quantity.lt(remove.quantity)) {
+        throw new Error(INSUFFICIENT_ITEM_QUANTITY);
+    }
+    const remaining = antelope.UInt32.from(target.quantity.subtracting(remove.quantity));
+    if (remaining.equals(antelope.UInt32.from(0))) {
+        return [...stacks.slice(0, idx), ...stacks.slice(idx + 1)];
+    }
+    const result = stacks.slice();
+    result[idx] = { ...target, quantity: remaining };
+    return result;
+}
+
+function hasSchedule$1(entity) {
+    return !!entity.schedule && entity.schedule.tasks.length > 0;
+}
+function isIdle(entity) {
+    return !hasSchedule$1(entity);
+}
+function getTasks(entity) {
+    return entity.schedule?.tasks || [];
+}
+function scheduleDuration(entity) {
+    if (!entity.schedule)
+        return 0;
+    return entity.schedule.tasks.reduce((sum, task) => sum + task.duration.toNumber(), 0);
+}
+function scheduleElapsed(entity, now) {
+    if (!entity.schedule)
+        return 0;
+    const started = entity.schedule.started.toDate();
+    const elapsed = Math.floor((now.getTime() - started.getTime()) / 1000);
+    return Math.max(0, elapsed);
+}
+function scheduleRemaining(entity, now) {
+    if (!entity.schedule)
+        return 0;
+    const duration = scheduleDuration(entity);
+    const elapsed = scheduleElapsed(entity, now);
+    return Math.max(0, duration - elapsed);
+}
+function scheduleComplete(entity, now) {
+    return hasSchedule$1(entity) && scheduleRemaining(entity, now) === 0;
+}
+function currentTaskIndex(entity, now) {
+    if (!entity.schedule || entity.schedule.tasks.length === 0)
+        return -1;
+    const elapsed = scheduleElapsed(entity, now);
+    let timeAccum = 0;
+    for (let i = 0; i < entity.schedule.tasks.length; i++) {
+        const taskDuration = entity.schedule.tasks[i].duration.toNumber();
+        if (elapsed < timeAccum + taskDuration) {
+            return i;
+        }
+        timeAccum += taskDuration;
+    }
+    return entity.schedule.tasks.length - 1;
+}
+function currentTask(entity, now) {
+    const index = currentTaskIndex(entity, now);
+    if (index < 0 || !entity.schedule)
+        return undefined;
+    return entity.schedule.tasks[index];
+}
+function currentTaskType(entity, now) {
+    const task = currentTask(entity, now);
+    if (!task)
+        return undefined;
+    return task.type.toNumber();
+}
+function getTaskStartTime(entity, index) {
+    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length)
+        return 0;
+    let timeAccum = 0;
+    for (let i = 0; i < index; i++) {
+        timeAccum += entity.schedule.tasks[i].duration.toNumber();
+    }
+    return timeAccum;
+}
+function getTaskElapsed(entity, index, now) {
+    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length)
+        return 0;
+    const elapsed = scheduleElapsed(entity, now);
+    const taskStart = getTaskStartTime(entity, index);
+    const taskDuration = entity.schedule.tasks[index].duration.toNumber();
+    if (elapsed <= taskStart)
+        return 0;
+    const elapsedInTask = elapsed - taskStart;
+    return Math.min(elapsedInTask, taskDuration);
+}
+function getTaskRemaining(entity, index, now) {
+    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length)
+        return 0;
+    const taskDuration = entity.schedule.tasks[index].duration.toNumber();
+    const taskElapsed = getTaskElapsed(entity, index, now);
+    return Math.max(0, taskDuration - taskElapsed);
+}
+function isTaskComplete(entity, index, now) {
+    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length)
+        return false;
+    const taskDuration = entity.schedule.tasks[index].duration.toNumber();
+    const taskElapsed = getTaskElapsed(entity, index, now);
+    return taskElapsed >= taskDuration;
+}
+function isTaskInProgress(entity, index, now) {
+    if (!entity.schedule || index < 0 || index >= entity.schedule.tasks.length)
+        return false;
+    const taskElapsed = getTaskElapsed(entity, index, now);
+    const taskDuration = entity.schedule.tasks[index].duration.toNumber();
+    return taskElapsed > 0 && taskElapsed < taskDuration;
+}
+function currentTaskProgress(entity, now) {
+    const task = currentTask(entity, now);
+    if (!task)
+        return 0;
+    const index = currentTaskIndex(entity, now);
+    const elapsed = getTaskElapsed(entity, index, now);
+    const duration = task.duration.toNumber();
+    if (duration === 0)
+        return 1;
+    return Math.min(1, elapsed / duration);
+}
+function scheduleProgress(entity, now) {
+    const duration = scheduleDuration(entity);
+    if (duration === 0)
+        return hasSchedule$1(entity) ? 1 : 0;
+    const elapsed = scheduleElapsed(entity, now);
+    return Math.min(1, elapsed / duration);
+}
+function isTaskType(entity, taskType, now) {
+    return currentTaskType(entity, now) === taskType;
+}
+function isInFlight(entity, now) {
+    return isTaskType(entity, exports.TaskType.TRAVEL, now);
+}
+function isRecharging(entity, now) {
+    return isTaskType(entity, exports.TaskType.RECHARGE, now);
+}
+function isLoading(entity, now) {
+    return isTaskType(entity, exports.TaskType.LOAD, now);
+}
+function isUnloading(entity, now) {
+    return isTaskType(entity, exports.TaskType.UNLOAD, now);
+}
+function isGathering(entity, now) {
+    return isTaskType(entity, exports.TaskType.GATHER, now);
+}
+
+var schedule = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    hasSchedule: hasSchedule$1,
+    isIdle: isIdle,
+    getTasks: getTasks,
+    scheduleDuration: scheduleDuration,
+    scheduleElapsed: scheduleElapsed,
+    scheduleRemaining: scheduleRemaining,
+    scheduleComplete: scheduleComplete,
+    currentTaskIndex: currentTaskIndex,
+    currentTask: currentTask,
+    currentTaskType: currentTaskType,
+    getTaskStartTime: getTaskStartTime,
+    getTaskElapsed: getTaskElapsed,
+    getTaskRemaining: getTaskRemaining,
+    isTaskComplete: isTaskComplete,
+    isTaskInProgress: isTaskInProgress,
+    currentTaskProgress: currentTaskProgress,
+    scheduleProgress: scheduleProgress,
+    isTaskType: isTaskType,
+    isInFlight: isInFlight,
+    isRecharging: isRecharging,
+    isLoading: isLoading,
+    isUnloading: isUnloading,
+    isGathering: isGathering
+});
+
+function getHullMass(entity) {
+    return antelope.UInt32.from(entity.hullmass ?? 0);
+}
+function createProjectedEntity(entity) {
+    const shipMass = getHullMass(entity);
+    const loaders = entity.loaders;
+    const engines = entity.engines;
+    const generator = entity.generator;
+    const hauler = entity.hauler;
+    const capacity = entity.capacity;
+    const cargo = entity.cargo.map(cargoItemToStack);
+    const projected = {
+        location: Coordinates.from(entity.coordinates),
+        energy: antelope.UInt16.from(entity.energy ?? 0),
+        cargo,
+        shipMass,
+        capacity: capacity ? antelope.UInt64.from(capacity) : undefined,
+        engines,
+        generator,
+        hauler,
+        loaders,
+        get cargoMass() {
+            return calcStacksMass(this.cargo);
+        },
+        get totalMass() {
+            let mass = antelope.UInt64.from(this.shipMass).adding(this.cargoMass);
+            if (this.loaders) {
+                mass = mass.adding(this.loaders.mass.multiplying(this.loaders.quantity));
+            }
+            return mass;
+        },
+        hasMovement() {
+            return capsHasMovement(this.capabilities());
+        },
+        hasStorage() {
+            return capsHasStorage(this.capabilities());
+        },
+        hasLoaders() {
+            return capsHasLoaders(this.capabilities());
+        },
+        capabilities() {
+            return {
+                hullmass: this.shipMass,
+                capacity: this.capacity ? antelope.UInt32.from(this.capacity) : undefined,
+                engines: this.engines,
+                generator: this.generator,
+                loaders: this.loaders,
+            };
+        },
+        state() {
+            return {
+                owner: entity.owner ?? antelope.Name.from(''),
+                location: Types.coordinates.from(this.location),
+                energy: this.energy,
+                cargomass: antelope.UInt32.from(this.cargoMass),
+                cargo: this.cargo.map(stackToCargoItem),
+            };
+        },
+    };
+    return projected;
+}
+function applyRechargeTask(projected, _task, options) {
+    if (!projected.generator)
+        return;
+    if (options.complete) {
+        projected.energy = antelope.UInt16.from(projected.generator.capacity);
+    }
+    else if (options.progress !== undefined) {
+        const capacity = Number(projected.generator.capacity);
+        const currentEnergy = Number(projected.energy);
+        const rechargeAmount = (capacity - currentEnergy) * options.progress;
+        projected.energy = antelope.UInt16.from(Math.min(capacity, currentEnergy + rechargeAmount));
+    }
+}
+function applyFlightTask(projected, task, options) {
+    if (!task.coordinates || !projected.engines)
+        return;
+    const origin = projected.location;
+    const destination = Coordinates.from(task.coordinates);
+    const distance = distanceBetweenCoordinates(origin, task.coordinates);
+    const energyUsage = distance.dividing(PRECISION$1).multiplying(projected.engines.drain);
+    if (options.complete) {
+        projected.energy = projected.energy.gt(energyUsage)
+            ? antelope.UInt16.from(projected.energy.subtracting(energyUsage))
+            : antelope.UInt16.from(0);
+        projected.location = destination;
+    }
+    else if (options.progress !== undefined) {
+        const interpolated = lerp(origin, destination, options.progress);
+        projected.location = Coordinates.from({
+            x: Math.round(interpolated.x),
+            y: Math.round(interpolated.y),
+        });
+        const partialEnergy = antelope.UInt64.from(Math.floor(Number(energyUsage) * options.progress));
+        projected.energy = projected.energy.gt(partialEnergy)
+            ? antelope.UInt16.from(projected.energy.subtracting(partialEnergy))
+            : antelope.UInt16.from(0);
+    }
+}
+function addCargoItem(projected, item) {
+    projected.cargo = mergeStacks(projected.cargo, cargoItemToStack(item));
+}
+function removeCargoItem(projected, item) {
+    projected.cargo = removeFromStacks(projected.cargo, cargoItemToStack(item));
+}
+function applyAddCargoTask(projected, task) {
+    for (const item of task.cargo) {
+        addCargoItem(projected, item);
+    }
+}
+function applyRemoveCargoTask(projected, task) {
+    for (const item of task.cargo) {
+        removeCargoItem(projected, item);
+    }
+}
+function applyEnergyCost(projected, task) {
+    if (!task.energy_cost)
+        return;
+    const energyCost = antelope.UInt16.from(task.energy_cost);
+    projected.energy = projected.energy.gt(energyCost)
+        ? antelope.UInt16.from(projected.energy.subtracting(energyCost))
+        : antelope.UInt16.from(0);
+}
+function applyGatherTask(projected, task, options) {
+    if (!options.complete)
+        return;
+    applyEnergyCost(projected, task);
+    applyAddCargoTask(projected, task);
+}
+function applyCraftTask(projected, task) {
+    applyEnergyCost(projected, task);
+    if (task.cargo.length === 0)
+        return;
+    for (let i = 0; i < task.cargo.length - 1; i++) {
+        removeCargoItem(projected, task.cargo[i]);
+    }
+    addCargoItem(projected, task.cargo[task.cargo.length - 1]);
+}
+function applyDeployTask(projected, task) {
+    applyEnergyCost(projected, task);
+    if (task.cargo.length > 0) {
+        removeCargoItem(projected, task.cargo[0]);
+    }
+}
+function applyTask(projected, task) {
+    switch (task.type.toNumber()) {
+        case exports.TaskType.RECHARGE:
+            applyRechargeTask(projected, task, { complete: true });
+            break;
+        case exports.TaskType.TRAVEL:
+            applyFlightTask(projected, task, { complete: true });
+            break;
+        case exports.TaskType.LOAD:
+        case exports.TaskType.UNWRAP:
+            applyAddCargoTask(projected, task);
+            break;
+        case exports.TaskType.UNLOAD:
+        case exports.TaskType.WRAP:
+            applyRemoveCargoTask(projected, task);
+            break;
+        case exports.TaskType.GATHER:
+            applyGatherTask(projected, task, { complete: true });
+            break;
+        case exports.TaskType.CRAFT:
+            applyCraftTask(projected, task);
+            break;
+        case exports.TaskType.DEPLOY:
+            applyDeployTask(projected, task);
+            break;
+    }
+}
+function projectEntity(entity, options) {
+    const projected = createProjectedEntity(entity);
+    if (!entity.schedule || entity.schedule.tasks.length === 0)
+        return projected;
+    const tasks = entity.schedule.tasks;
+    const taskCount = options?.upToTaskIndex !== undefined
+        ? Math.max(0, Math.min(options.upToTaskIndex, tasks.length))
+        : tasks.length;
+    for (let i = 0; i < taskCount; i++) {
+        applyTask(projected, tasks[i]);
+    }
+    return projected;
+}
+function validateSchedule(entity) {
+    if (!entity.schedule || entity.schedule.tasks.length === 0)
+        return;
+    const projected = createProjectedEntity(entity);
+    for (const task of entity.schedule.tasks) {
+        applyTask(projected, task);
+        if (projected.capacity && projected.cargoMass.gt(projected.capacity)) {
+            throw new Error(ENTITY_CAPACITY_EXCEEDED);
+        }
+    }
+}
+function projectEntityAt(entity, now) {
+    const projected = createProjectedEntity(entity);
+    if (!entity.schedule || entity.schedule.tasks.length === 0) {
+        return projected;
+    }
+    for (let i = 0; i < entity.schedule.tasks.length; i++) {
+        const task = entity.schedule.tasks[i];
+        const taskComplete = isTaskComplete(entity, i, now);
+        const taskInProgress = isTaskInProgress(entity, i, now);
+        if (!taskComplete && !taskInProgress) {
+            break;
+        }
+        const progress = taskInProgress
+            ? getTaskElapsed(entity, i, now) / task.duration.toNumber()
+            : undefined;
+        switch (task.type.toNumber()) {
+            case exports.TaskType.RECHARGE:
+                applyRechargeTask(projected, task, { complete: taskComplete, progress });
+                break;
+            case exports.TaskType.TRAVEL:
+                applyFlightTask(projected, task, { complete: taskComplete, progress });
+                break;
+            case exports.TaskType.LOAD:
+            case exports.TaskType.UNWRAP:
+                if (taskComplete)
+                    applyAddCargoTask(projected, task);
+                break;
+            case exports.TaskType.UNLOAD:
+            case exports.TaskType.WRAP:
+                if (taskComplete)
+                    applyRemoveCargoTask(projected, task);
+                break;
+            case exports.TaskType.GATHER:
+                if (taskComplete)
+                    applyGatherTask(projected, task, { complete: true });
+                break;
+            case exports.TaskType.CRAFT:
+                if (taskComplete)
+                    applyCraftTask(projected, task);
+                break;
+            case exports.TaskType.DEPLOY:
+                if (taskComplete)
+                    applyDeployTask(projected, task);
+                break;
+        }
+    }
+    return projected;
+}
+
+class Location {
+    constructor(coordinates) {
+        this.coordinates = Coordinates.from(coordinates);
+    }
+    static from(coordinates) {
+        return new Location(Coordinates.from(coordinates));
+    }
+    hasSystemAt(gameSeed) {
+        const seed = antelope.Checksum256.from(gameSeed);
+        if (this._hasSystem === undefined || !this._gameSeed?.equals(seed)) {
+            this._gameSeed = seed;
+            this._hasSystem = hasSystem(seed, this.coordinates);
+        }
+        return this._hasSystem;
+    }
+    getLocationTypeAt(gameSeed) {
+        return getLocationType(gameSeed, this.coordinates);
+    }
+    isGatherableAt(gameSeed) {
+        return isGatherableLocation(this.getLocationTypeAt(gameSeed));
+    }
+    findNearby(gameSeed, maxDistance = 20) {
+        return findNearbyPlanets(antelope.Checksum256.from(gameSeed), this.coordinates, maxDistance);
+    }
+    equals(other) {
+        const otherCoords = other instanceof Location ? other.coordinates : Coordinates.from(other);
+        return this.coordinates.equals(otherCoords);
+    }
+    get epoch() {
+        return this._epoch;
+    }
+    clearCache() {
+        this._epoch = undefined;
+    }
+}
+function toLocation(coords) {
+    if (coords instanceof Location) {
+        return coords;
+    }
+    return Location.from(coords);
+}
+
+class ScheduleAccessor {
+    constructor(entity) {
+        this.entity = entity;
+    }
+    get hasSchedule() {
+        return hasSchedule$1(this.entity);
+    }
+    get isIdle() {
+        return isIdle(this.entity);
+    }
+    get tasks() {
+        return getTasks(this.entity);
+    }
+    duration() {
+        return scheduleDuration(this.entity);
+    }
+    elapsed(now) {
+        return scheduleElapsed(this.entity, now);
+    }
+    remaining(now) {
+        return scheduleRemaining(this.entity, now);
+    }
+    complete(now) {
+        return scheduleComplete(this.entity, now);
+    }
+    currentTaskIndex(now) {
+        return currentTaskIndex(this.entity, now);
+    }
+    currentTask(now) {
+        return currentTask(this.entity, now);
+    }
+    currentTaskType(now) {
+        return currentTaskType(this.entity, now);
+    }
+    taskStartTime(index) {
+        return getTaskStartTime(this.entity, index);
+    }
+    taskElapsed(index, now) {
+        return getTaskElapsed(this.entity, index, now);
+    }
+    taskRemaining(index, now) {
+        return getTaskRemaining(this.entity, index, now);
+    }
+    taskComplete(index, now) {
+        return isTaskComplete(this.entity, index, now);
+    }
+    taskInProgress(index, now) {
+        return isTaskInProgress(this.entity, index, now);
+    }
+    currentTaskProgress(now) {
+        return currentTaskProgress(this.entity, now);
+    }
+    progress(now) {
+        return scheduleProgress(this.entity, now);
+    }
+}
+function createScheduleAccessor(entity) {
+    return new ScheduleAccessor(entity);
+}
+
+class EntityInventory extends Types.cargo_item {
+    get item() {
+        if (!this._item) {
+            this._item = getItem(this.item_id);
+        }
+        return this._item;
+    }
+    get good() {
+        return this.item;
+    }
+    get name() {
+        return this.item.name;
+    }
+    get unitMass() {
+        return this.item.mass;
+    }
+    get totalMass() {
+        return antelope.UInt64.from(this.unitMass).multiplying(this.quantity);
+    }
+    get hasCargo() {
+        return antelope.UInt32.from(this.quantity).gt(antelope.UInt32.from(0));
+    }
+    get isEmpty() {
+        return antelope.UInt32.from(this.quantity).equals(antelope.UInt32.from(0));
+    }
+}
+
+class InventoryAccessor {
+    constructor(entity) {
+        this.entity = entity;
+    }
+    get items() {
+        if (!this._items) {
+            this._items = this.entity.cargo.map((item) => new EntityInventory(item));
+        }
+        return this._items;
+    }
+    get totalMass() {
+        return this.items.reduce((sum, c) => sum.adding(c.totalMass), antelope.UInt64.from(0));
+    }
+    forItem(goodId) {
+        return this.items.find((c) => c.item_id.equals(goodId));
+    }
+    get sellable() {
+        return this.items.filter((c) => c.hasCargo);
+    }
+    get hasSellable() {
+        return this.items.some((c) => c.hasCargo);
+    }
+    get sellableCount() {
+        return this.items.filter((c) => c.hasCargo).length;
+    }
+}
+function createInventoryAccessor(entity) {
+    return new InventoryAccessor(entity);
+}
+
+function maxTravelDistance(entity) {
+    return antelope.UInt32.from(entity.generator.capacity)
+        .dividing(entity.engines.drain)
+        .multiplying(PRECISION$1);
+}
+function calcEnergyUsage(entity, distance) {
+    return distance.dividing(PRECISION$1).multiplying(entity.engines.drain);
+}
+function hasEnergyForDistance(entity, distance) {
+    const usage = calcEnergyUsage(entity, distance);
+    return antelope.UInt64.from(entity.energy).gte(usage);
+}
+function energyPercent(entity) {
+    return (Number(entity.energy) / Number(entity.generator.capacity)) * 100;
+}
+function needsRecharge(entity) {
+    return antelope.UInt64.from(entity.energy).lt(entity.generator.capacity);
+}
+
+class Ship extends Types.entity_info {
+    get name() {
+        return this.entity_name;
+    }
+    get inv() {
+        return (this._inv ?? (this._inv = new InventoryAccessor(this)));
+    }
+    get inventory() {
+        return this.inv.items;
+    }
+    get sched() {
+        return (this._sched ?? (this._sched = new ScheduleAccessor(this)));
+    }
+    get maxDistance() {
+        if (!this.generator || !this.engines)
+            return antelope.UInt32.from(0);
+        return maxTravelDistance(this);
+    }
+    get isIdle() {
+        return this.is_idle;
+    }
+    getFlightOrigin(flightTaskIndex) {
+        return Coordinates.from(getFlightOrigin(this, flightTaskIndex));
+    }
+    destinationLocation() {
+        const dest = getDestinationLocation(this);
+        return dest ? Coordinates.from(dest) : undefined;
+    }
+    positionAt(now) {
+        const taskIndex = this.sched.currentTaskIndex(now);
+        const progress = this.sched.currentTaskProgress(now);
+        return Coordinates.from(getPositionAt(this, taskIndex, progress));
+    }
+    isInFlight(now) {
+        return isInFlight(this, now);
+    }
+    isRecharging(now) {
+        return isRecharging(this, now);
+    }
+    isLoading(now) {
+        return isLoading(this, now);
+    }
+    isUnloading(now) {
+        return isUnloading(this, now);
+    }
+    isGathering(now) {
+        return isGathering(this, now);
+    }
+    get hasEngines() {
+        return this.engines !== undefined;
+    }
+    get hasGenerator() {
+        return this.generator !== undefined;
+    }
+    get hasGatherer() {
+        return this.gatherer !== undefined;
+    }
+    get hasWarp() {
+        return this.warp !== undefined;
+    }
+    project() {
+        return projectEntity(this);
+    }
+    projectAt(now) {
+        return projectEntityAt(this, now);
+    }
+    get location() {
+        return Location.from(this.coordinates);
+    }
+    get totalCargoMass() {
+        return this.inv.totalMass;
+    }
+    get totalMass() {
+        let mass = antelope.UInt64.from(this.hullmass ?? 0).adding(this.totalCargoMass);
+        if (this.loaders) {
+            mass = mass.adding(antelope.UInt64.from(this.loaders.mass).multiplying(this.loaders.quantity));
+        }
+        return mass;
+    }
+    get maxCapacity() {
+        return antelope.UInt64.from(this.capacity);
+    }
+    hasSpace(goodMass, quantity) {
+        return this.totalMass.adding(goodMass.multiplying(quantity)).lte(this.maxCapacity);
+    }
+    get availableCapacity() {
+        return this.totalMass.gte(this.maxCapacity)
+            ? antelope.UInt64.from(0)
+            : this.maxCapacity.subtracting(this.totalMass);
+    }
+    getCargoForItem(goodId) {
+        return this.inv.forItem(goodId);
+    }
+    get sellableCargo() {
+        return this.inv.sellable;
+    }
+    get hasSellableCargo() {
+        return this.inv.hasSellable;
+    }
+    get sellableGoodsCount() {
+        return this.inv.sellableCount;
+    }
+    get isFull() {
+        return this.totalMass.gte(this.maxCapacity);
+    }
+    get energyPercent() {
+        if (!this.generator || this.energy === undefined)
+            return 0;
+        return energyPercent(this);
+    }
+    get needsRecharge() {
+        if (!this.generator || this.energy === undefined)
+            return false;
+        return needsRecharge(this);
+    }
+    hasEnergyFor(distance) {
+        if (!this.engines || !this.generator || this.energy === undefined)
+            return false;
+        return hasEnergyForDistance(this, distance);
+    }
+}
+
+class Warehouse extends Types.entity_info {
+    get name() {
+        return this.entity_name;
+    }
+    get inv() {
+        return (this._inv ?? (this._inv = new InventoryAccessor(this)));
+    }
+    get inventory() {
+        return this.inv.items;
+    }
+    get sched() {
+        return (this._sched ?? (this._sched = new ScheduleAccessor(this)));
+    }
+    get isIdle() {
+        return this.is_idle;
+    }
+    isLoading(now) {
+        return isLoading(this, now);
+    }
+    isUnloading(now) {
+        return isUnloading(this, now);
+    }
+    get location() {
+        return Location.from(this.coordinates);
+    }
+    get totalCargoMass() {
+        return this.inv.totalMass;
+    }
+    get maxCapacity() {
+        return antelope.UInt64.from(this.capacity);
+    }
+    get availableCapacity() {
+        const cargo = this.totalCargoMass;
+        return cargo.gte(this.maxCapacity) ? antelope.UInt64.from(0) : this.maxCapacity.subtracting(cargo);
+    }
+    hasSpace(goodMass, quantity) {
+        return this.totalCargoMass.adding(goodMass.multiplying(quantity)).lte(this.maxCapacity);
+    }
+    get isFull() {
+        return this.totalCargoMass.gte(this.maxCapacity);
+    }
+    getCargoForItem(goodId) {
+        return this.inv.forItem(goodId);
+    }
+    get orbitalAltitude() {
+        return this.coordinates.z?.toNumber() || 0;
+    }
+    get totalMass() {
+        const hull = this.hullmass ? antelope.UInt64.from(this.hullmass) : antelope.UInt64.from(0);
+        return hull.adding(this.totalCargoMass);
+    }
 }
-function getComponentById(id) {
-    return components.find((c) => c.id === id);
+
+class Container extends Types.entity_info {
+    get name() {
+        return this.entity_name;
+    }
+    get sched() {
+        return (this._sched ?? (this._sched = new ScheduleAccessor(this)));
+    }
+    get isIdle() {
+        return this.is_idle;
+    }
+    isLoading(now) {
+        return isLoading(this, now);
+    }
+    isUnloading(now) {
+        return isUnloading(this, now);
+    }
+    get location() {
+        return Location.from(this.coordinates);
+    }
+    get totalMass() {
+        return antelope.UInt64.from(this.hullmass ?? 0).adding(this.cargomass);
+    }
+    get maxCapacity() {
+        return antelope.UInt64.from(this.capacity);
+    }
+    get availableCapacity() {
+        const cargo = antelope.UInt64.from(this.cargomass);
+        return cargo.gte(this.maxCapacity) ? antelope.UInt64.from(0) : this.maxCapacity.subtracting(cargo);
+    }
+    hasSpace(additionalMass) {
+        return antelope.UInt64.from(this.cargomass).adding(additionalMass).lte(this.maxCapacity);
+    }
+    get isFull() {
+        return antelope.UInt64.from(this.cargomass).gte(this.maxCapacity);
+    }
+    get orbitalAltitude() {
+        return this.coordinates.z?.toNumber() || 0;
+    }
 }
-function getEntityRecipe(id) {
-    return entityRecipes.find((r) => r.id === id);
+function computeContainerCapabilities(stats) {
+    const density = stats['density'] ?? 500;
+    const strength = stats['strength'] ?? 500;
+    const ductility = stats['ductility'] ?? 500;
+    const purity = stats['purity'] ?? 500;
+    const hullmass = 25000 + 75 * density;
+    const statSum = strength + ductility + purity;
+    const exponent = statSum / 2997;
+    const capacity = Math.floor(1000000 * Math.pow(10, exponent));
+    return { hullmass, capacity };
 }
-function getEntityRecipeByItemId(itemId) {
-    return entityRecipes.find((r) => r.packedItemId === itemId);
+function computeContainerT2Capabilities(stats) {
+    const strength = stats['strength'] ?? 0;
+    const density = stats['density'] ?? 0;
+    const ductility = stats['ductility'] ?? 0;
+    const purity = stats['purity'] ?? 0;
+    const hullmass = 20000 + 50 * density;
+    const statSum = strength + ductility + purity;
+    const exponent = statSum / 2500;
+    const capacity = Math.floor(1500000 * Math.pow(10, exponent));
+    return { hullmass, capacity };
 }
-function getEntitySlotLayout(packedItemId) {
-    const recipe = getEntityRecipeByItemId(packedItemId);
-    return recipe?.moduleSlots ?? [];
+
+class EntitiesManager extends BaseManager {
+    async getEntity(type, id) {
+        const result = await this.server.readonly('getentity', {
+            entity_type: antelope.Name.from(type),
+            entity_id: id,
+        });
+        const entityInfo = result;
+        return this.wrapEntity(entityInfo);
+    }
+    async getEntities(owner, type) {
+        const ownerName = this.resolveOwner(owner);
+        const result = await this.server.readonly('getentities', {
+            owner: ownerName,
+            entity_type: type ? antelope.Name.from(type) : null,
+        });
+        const entities = result;
+        return entities.map((entity) => this.wrapEntity(entity));
+    }
+    async getSummaries(owner, type) {
+        const ownerName = this.resolveOwner(owner);
+        const result = await this.server.readonly('getsummaries', {
+            owner: ownerName,
+            entity_type: type ? antelope.Name.from(type) : null,
+        });
+        return result;
+    }
+    async getShip(id) {
+        return (await this.getEntity('ship', id));
+    }
+    async getWarehouse(id) {
+        return (await this.getEntity('warehouse', id));
+    }
+    async getContainer(id) {
+        return (await this.getEntity('container', id));
+    }
+    async getShips(owner) {
+        return (await this.getEntities(owner, 'ship'));
+    }
+    async getWarehouses(owner) {
+        return (await this.getEntities(owner, 'warehouse'));
+    }
+    async getContainers(owner) {
+        return (await this.getEntities(owner, 'container'));
+    }
+    async getShipSummaries(owner) {
+        return this.getSummaries(owner, 'ship');
+    }
+    async getWarehouseSummaries(owner) {
+        return this.getSummaries(owner, 'warehouse');
+    }
+    async getContainerSummaries(owner) {
+        return this.getSummaries(owner, 'container');
+    }
+    wrapEntity(entity) {
+        if (entity.type.equals('ship')) {
+            return new Ship(entity);
+        }
+        else if (entity.type.equals('warehouse')) {
+            return new Warehouse(entity);
+        }
+        else {
+            return new Container(entity);
+        }
+    }
+    resolveOwner(owner) {
+        if (typeof owner === 'object' && owner !== null && 'owner' in owner) {
+            return owner.owner;
+        }
+        return antelope.Name.from(owner);
+    }
+}
+
+class Player extends Types.player_row {
+    static fromState(state) {
+        const playerRow = Types.player_row.from({
+            owner: antelope.Name.from(state.owner),
+        });
+        return new Player(playerRow);
+    }
+}
+
+class PlayersManager extends BaseManager {
+    async getPlayer(account) {
+        const playerRow = await this.server.table('player').get(antelope.Name.from(account));
+        if (!playerRow) {
+            return undefined;
+        }
+        return new Player(playerRow);
+    }
+}
+
+class LocationsManager extends BaseManager {
+    async hasSystem(location) {
+        const game = await this.getGame();
+        return hasSystem(game.config.seed, location);
+    }
+    async findNearbyPlanets(origin, maxDistance = 20) {
+        const game = await this.getGame();
+        return findNearbyPlanets(game.config.seed, origin, maxDistance);
+    }
+    async getLocationEntity(id) {
+        const row = await this.server.table('location').get(antelope.UInt64.from(id));
+        return row ?? undefined;
+    }
+    async getLocationEntityAt(coords) {
+        const id = coordsToLocationId(coords);
+        return this.getLocationEntity(id);
+    }
+    async getAllLocationEntities() {
+        return this.server.table('location').all();
+    }
+}
+
+class EpochsManager extends BaseManager {
+    async getCurrentHeight() {
+        const game = await this.getGame();
+        return getCurrentEpoch(game);
+    }
+    async getCurrent() {
+        const game = await this.getGame();
+        const epoch = await this.getCurrentHeight();
+        return getEpochInfo(game, epoch);
+    }
+    async getByHeight(height) {
+        const game = await this.getGame();
+        return getEpochInfo(game, antelope.UInt64.from(height));
+    }
+    async getTimeRemaining() {
+        const epochInfo = await this.getCurrent();
+        const now = Date.now();
+        const endTime = epochInfo.end.getTime();
+        return Math.max(0, endTime - now);
+    }
+    async getProgress() {
+        const epochInfo = await this.getCurrent();
+        const now = Date.now();
+        const startTime = epochInfo.start.getTime();
+        const endTime = epochInfo.end.getTime();
+        const duration = endTime - startTime;
+        const elapsed = now - startTime;
+        if (elapsed <= 0)
+            return 0;
+        if (elapsed >= duration)
+            return 1;
+        return elapsed / duration;
+    }
+    async fitsInCurrentEpoch(durationMs) {
+        const remaining = await this.getTimeRemaining();
+        return durationMs <= remaining;
+    }
 }
-function getAllCraftableItems() {
-    const items = [];
-    for (const comp of components) {
-        items.push({
-            type: 'component',
-            id: comp.id,
-            name: comp.name,
-            description: comp.description,
-            color: comp.color,
+
+class ActionsManager extends BaseManager {
+    travel(shipId, destination, recharge = true) {
+        const x = antelope.Int64.from(destination.x);
+        const y = antelope.Int64.from(destination.y);
+        return this.server.action('travel', {
+            entity_type: EntityType.SHIP,
+            id: antelope.UInt64.from(shipId),
+            x,
+            y,
+            recharge,
         });
     }
-    for (const entity of entityRecipes) {
-        items.push({
-            type: 'entity',
-            id: entity.id,
-            name: entity.name,
-            description: entity.description,
-            color: entity.color,
+    grouptravel(entities, destination, recharge = true) {
+        const entityRefs = entities.map((e) => Types.entity_ref.from({
+            entity_type: e.entityType,
+            entity_id: antelope.UInt64.from(e.entityId),
+        }));
+        const x = antelope.Int64.from(destination.x);
+        const y = antelope.Int64.from(destination.y);
+        return this.server.action('grouptravel', {
+            entities: entityRefs,
+            x,
+            y,
+            recharge,
         });
     }
-    for (const mod of moduleRecipes) {
-        items.push({
-            type: 'module',
-            id: mod.id,
-            name: mod.name,
-            description: mod.description,
-            color: mod.color,
+    resolve(entityId, entityType = EntityType.SHIP) {
+        return this.server.action('resolve', {
+            entity_type: entityType,
+            id: antelope.UInt64.from(entityId),
+        });
+    }
+    cancel(entityId, count, entityType = EntityType.SHIP) {
+        return this.server.action('cancel', {
+            entity_type: entityType,
+            id: antelope.UInt64.from(entityId),
+            count: antelope.UInt64.from(count),
+        });
+    }
+    recharge(shipId) {
+        return this.server.action('recharge', {
+            entity_type: EntityType.SHIP,
+            id: antelope.UInt64.from(shipId),
+        });
+    }
+    transfer(sourceType, sourceId, destType, destId, goodId, quantity) {
+        return this.server.action('transfer', {
+            source_type: sourceType,
+            source_id: antelope.UInt64.from(sourceId),
+            dest_type: destType,
+            dest_id: antelope.UInt64.from(destId),
+            item_id: antelope.UInt16.from(goodId),
+            quantity: antelope.UInt32.from(quantity),
+        });
+    }
+    foundCompany(account, name) {
+        return this.platform.action('foundcompany', {
+            account: antelope.Name.from(account),
+            name,
+        });
+    }
+    join(account) {
+        return this.server.action('join', {
+            account: antelope.Name.from(account),
+        });
+    }
+    gather(shipId, stratum, quantity) {
+        return this.server.action('gather', {
+            entity_type: EntityType.SHIP,
+            id: antelope.UInt64.from(shipId),
+            stratum: antelope.UInt16.from(stratum),
+            quantity: antelope.UInt32.from(quantity),
+        });
+    }
+    warp(shipId, destination) {
+        const x = antelope.Int64.from(destination.x);
+        const y = antelope.Int64.from(destination.y);
+        return this.server.action('warp', {
+            entity_type: EntityType.SHIP,
+            id: antelope.UInt64.from(shipId),
+            x,
+            y,
+        });
+    }
+    craft(entityType, entityId, recipeId, quantity, inputs) {
+        const cargoInputs = inputs.map((i) => Types.cargo_item.from(i));
+        return this.server.action('craft', {
+            entity_type: entityType,
+            id: antelope.UInt64.from(entityId),
+            recipe_id: antelope.UInt16.from(recipeId),
+            quantity: antelope.UInt32.from(quantity),
+            inputs: cargoInputs,
+        });
+    }
+    blend(entityType, entityId, inputs) {
+        const cargoInputs = inputs.map((i) => Types.cargo_item.from(i));
+        return this.server.action('blend', {
+            entity_type: entityType,
+            id: antelope.UInt64.from(entityId),
+            inputs: cargoInputs,
+        });
+    }
+    deploy(entityType, entityId, packedItemId, seed, entityName) {
+        return this.server.action('deploy', {
+            entity_type: entityType,
+            id: antelope.UInt64.from(entityId),
+            packed_item_id: antelope.UInt16.from(packedItemId),
+            seed: antelope.UInt64.from(seed),
+            entity_name: entityName,
+        });
+    }
+    addmodule(entityType, entityId, moduleIndex, moduleCargoId, targetCargoId = antelope.UInt64.from(0)) {
+        return this.server.action('addmodule', {
+            entity_type: entityType,
+            entity_id: antelope.UInt64.from(entityId),
+            module_index: moduleIndex,
+            module_cargo_id: antelope.UInt64.from(moduleCargoId),
+            target_cargo_id: antelope.UInt64.from(targetCargoId),
+        });
+    }
+    rmmodule(entityType, entityId, moduleIndex, targetCargoId = antelope.UInt64.from(0)) {
+        return this.server.action('rmmodule', {
+            entity_type: entityType,
+            entity_id: antelope.UInt64.from(entityId),
+            module_index: moduleIndex,
+            target_cargo_id: antelope.UInt64.from(targetCargoId),
+        });
+    }
+    joinGame(account, companyName) {
+        return [this.foundCompany(account, companyName), this.join(account)];
+    }
+}
+
+class GameContext {
+    constructor(client, server, platform) {
+        this.client = client;
+        this.server = server;
+        this.platform = platform;
+    }
+    get entities() {
+        if (!this._entities) {
+            this._entities = new EntitiesManager(this);
+        }
+        return this._entities;
+    }
+    get players() {
+        if (!this._players) {
+            this._players = new PlayersManager(this);
+        }
+        return this._players;
+    }
+    get locations() {
+        if (!this._locations) {
+            this._locations = new LocationsManager(this);
+        }
+        return this._locations;
+    }
+    get epochs() {
+        if (!this._epochs) {
+            this._epochs = new EpochsManager(this);
+        }
+        return this._epochs;
+    }
+    get actions() {
+        if (!this._actions) {
+            this._actions = new ActionsManager(this);
+        }
+        return this._actions;
+    }
+    async getGame(reload = false) {
+        if (!reload && this._gameCache) {
+            return this._gameCache;
+        }
+        const game = await this.platform.table('games').get();
+        if (!game) {
+            throw new Error('Game not initialized');
+        }
+        this._gameCache = game;
+        return game;
+    }
+    async getState(reload = false) {
+        if (!reload && this._stateCache) {
+            return this._stateCache;
+        }
+        const state = await this.server.table('state').get();
+        if (!state) {
+            throw new Error('Game state not initialized');
+        }
+        const game = this._gameCache;
+        this._stateCache = GameState.from(state, game);
+        return this._stateCache;
+    }
+    get cachedGame() {
+        return this._gameCache;
+    }
+    get cachedState() {
+        return this._stateCache;
+    }
+}
+
+class Shipload {
+    constructor(chain, constructorOptions) {
+        const { client, platformContract, serverContract } = constructorOptions || {};
+        const apiClient = client || new antelope.APIClient({ url: chain.url });
+        const platform$1 = platformContract
+            ? platformContract
+            : new Contract$1({ client: apiClient });
+        const server$1 = serverContract
+            ? serverContract
+            : new Contract({ client: apiClient });
+        this._context = new GameContext(apiClient, server$1, platform$1);
+    }
+    static async load(chain, shiploadOptions) {
+        let platform$1 = new Contract$1({
+            client: new antelope.APIClient({ url: chain.url }),
+        });
+        if (shiploadOptions?.platformContractName) {
+            const client = shiploadOptions.client || new antelope.APIClient({ url: chain.url });
+            const contractKit = new ContractKit__default["default"]({ client });
+            platform$1 = await contractKit.load(shiploadOptions.platformContractName);
+        }
+        let server$1 = new Contract({
+            client: new antelope.APIClient({ url: chain.url }),
+        });
+        if (shiploadOptions?.serverContractName) {
+            const client = shiploadOptions.client || new antelope.APIClient({ url: chain.url });
+            const contractKit = new ContractKit__default["default"]({ client });
+            server$1 = await contractKit.load(shiploadOptions.serverContractName);
+        }
+        return new Shipload(chain, {
+            ...shiploadOptions,
+            platformContract: platform$1,
+            serverContract: server$1,
         });
     }
-    return items;
-}
-function getComponentsForCategory(category) {
-    return components.filter((c) => c.recipe.some((r) => r.category === category));
-}
-function getComponentsForStat(statKey) {
-    return components.filter((c) => c.stats.some((s) => s.key === statKey));
-}
-
-function encodeStats(values) {
-    let seed = 0n;
-    for (let i = 0; i < values.length && i < 6; i++) {
-        seed |= BigInt(values[i] & 0x3ff) << BigInt(i * 10);
-    }
-    return seed;
-}
-function decodeStat(seed, index) {
-    return Number((seed >> BigInt(index * 10)) & 0x3ffn);
-}
-function decodeStats(seed, count) {
-    const stats = [];
-    for (let i = 0; i < count; i++) {
-        stats.push(decodeStat(seed, i));
+    get client() {
+        return this._context.client;
     }
-    return stats;
-}
-function mapStatsToKeys(seed, statDefs) {
-    const values = decodeStats(seed, statDefs.length);
-    const result = {};
-    for (let i = 0; i < statDefs.length; i++) {
-        result[statDefs[i].key] = values[i];
+    get server() {
+        return this._context.server;
     }
-    return result;
-}
-function decodeCraftedItemStats(itemId, seed) {
-    const comp = getComponentById(itemId);
-    if (comp)
-        return mapStatsToKeys(seed, comp.stats);
-    const entityRecipe = entityRecipes.find((r) => r.packedItemId === itemId);
-    if (entityRecipe)
-        return mapStatsToKeys(seed, entityRecipe.stats);
-    const moduleRecipe = moduleRecipes.find((r) => r.itemId === itemId);
-    if (moduleRecipe)
-        return mapStatsToKeys(seed, moduleRecipe.stats);
-    return {};
-}
-function blendStacks(stacks, statKey) {
-    let totalQty = 0;
-    let weightedSum = 0;
-    for (const stack of stacks) {
-        const val = stack.stats[statKey] ?? 0;
-        weightedSum += val * stack.quantity;
-        totalQty += stack.quantity;
+    get platform() {
+        return this._context.platform;
     }
-    if (totalQty === 0)
-        return 0;
-    return Math.floor(weightedSum / totalQty);
-}
-function computeComponentStats(componentId, categoryStacks) {
-    const comp = getComponentById(componentId);
-    if (!comp)
-        return [];
-    return comp.stats.map((statDef) => {
-        const matching = categoryStacks.find((cs) => cs.category === statDef.source);
-        const value = matching ? blendStacks(matching.stacks, statDef.key) : 0;
-        return { key: statDef.key, value: Math.max(1, Math.min(999, value)) };
-    });
-}
-function blendComponentStacks(stacks) {
-    if (stacks.length === 0)
-        return {};
-    const allKeys = new Set();
-    for (const s of stacks) {
-        for (const k of Object.keys(s.stats))
-            allKeys.add(k);
+    get entities() {
+        return this._context.entities;
     }
-    const result = {};
-    for (const key of allKeys) {
-        result[key] = blendStacks(stacks.map((s) => ({ quantity: s.quantity, stats: s.stats })), key);
+    get players() {
+        return this._context.players;
     }
-    return result;
-}
-function computeEntityStats(entityRecipeId, componentStacks) {
-    const recipe = getEntityRecipe(entityRecipeId) ?? getModuleRecipe(entityRecipeId);
-    if (!recipe)
-        return [];
-    const blendedByComponent = {};
-    for (const [compId, stacks] of Object.entries(componentStacks)) {
-        blendedByComponent[Number(compId)] = blendComponentStacks(stacks);
+    get locations() {
+        return this._context.locations;
     }
-    return recipe.stats.map((stat) => {
-        const blended = blendedByComponent[stat.sourceComponentId] ?? {};
-        const value = blended[stat.sourceStatKey] ?? 0;
-        return { key: stat.key, value: Math.max(1, Math.min(999, value)) };
-    });
-}
-function decodeStackStats(itemId, seed) {
-    if (itemId >= 10000) {
-        return decodeCraftedItemStats(itemId, BigInt(seed.toString()));
+    get epochs() {
+        return this._context.epochs;
     }
-    const raw = deriveResourceStats(BigInt(seed.toString()));
-    return { stat1: raw.stat1, stat2: raw.stat2, stat3: raw.stat3 };
-}
-const categoryItemMass = {
-    metal: 30000,
-    precious: 40000,
-    gas: 15000,
-    mineral: 22000,
-    organic: 15000,
-};
-function computeInputMass(itemId, itemType) {
-    if (itemType === 'component') {
-        const comp = getComponentById(itemId);
-        if (!comp)
-            return 0;
-        return comp.recipe.reduce((sum, input) => {
-            const mass = input.category ? categoryItemMass[input.category] ?? 0 : 0;
-            return sum + mass * input.quantity;
-        }, 0);
+    get actions() {
+        return this._context.actions;
     }
-    if (itemType === 'module') {
-        const mod = getModuleRecipe(itemId);
-        if (!mod)
-            return 0;
-        return mod.recipe.reduce((sum, input) => {
-            const comp = input.itemId ? getComponentById(input.itemId) : undefined;
-            return sum + (comp?.mass ?? 0) * input.quantity;
-        }, 0);
+    async getGame(reload = false) {
+        return this._context.getGame(reload);
     }
-    if (itemType === 'entity') {
-        const ent = getEntityRecipe(itemId);
-        if (!ent)
-            return 0;
-        return ent.recipe.reduce((sum, input) => {
-            const comp = input.itemId ? getComponentById(input.itemId) : undefined;
-            return sum + (comp?.mass ?? 0) * input.quantity;
-        }, 0);
+    async getState(reload = false) {
+        return this._context.getState(reload);
     }
-    return 0;
 }
-function blendCrossGroup(sources) {
-    let weightedSum = 0;
-    let totalWeight = 0;
-    for (const src of sources) {
-        weightedSum += src.value * src.weight;
-        totalWeight += src.weight;
-    }
-    if (totalWeight === 0)
-        return 1;
-    const result = Math.floor(weightedSum / totalWeight);
-    return Math.max(1, Math.min(999, result));
+
+function makeShip(state) {
+    const info = {
+        type: antelope.Name.from('ship'),
+        id: antelope.UInt64.from(state.id),
+        owner: antelope.Name.from(state.owner),
+        entity_name: state.name,
+        coordinates: Types.coordinates.from(state.coordinates),
+        cargomass: antelope.UInt32.from(0),
+        cargo: state.cargo || [],
+        is_idle: !state.schedule,
+        current_task_elapsed: antelope.UInt32.from(0),
+        current_task_remaining: antelope.UInt32.from(0),
+        pending_tasks: [],
+    };
+    if (state.hullmass !== undefined)
+        info.hullmass = antelope.UInt32.from(state.hullmass);
+    if (state.capacity !== undefined)
+        info.capacity = antelope.UInt32.from(state.capacity);
+    if (state.energy !== undefined)
+        info.energy = antelope.UInt16.from(state.energy);
+    if (state.engines)
+        info.engines = state.engines;
+    if (state.generator)
+        info.generator = state.generator;
+    if (state.loaders)
+        info.loaders = state.loaders;
+    if (state.schedule)
+        info.schedule = state.schedule;
+    const entityInfo = Types.entity_info.from(info);
+    return new Ship(entityInfo);
 }
-function blendCargoStacks(itemId, stacks) {
-    const decoded = stacks.map((s) => ({
-        quantity: s.quantity,
-        stats: decodeStackStats(itemId, s.seed),
-    }));
-    const allKeys = Object.keys(decoded[0]?.stats ?? {});
-    const blended = allKeys.map((key) => Math.max(1, Math.min(999, blendStacks(decoded, key))));
-    return antelope.UInt64.from(encodeStats(blended));
+function makeWarehouse(state) {
+    const info = {
+        type: antelope.Name.from('warehouse'),
+        id: antelope.UInt64.from(state.id),
+        owner: antelope.Name.from(state.owner),
+        entity_name: state.name,
+        coordinates: Types.coordinates.from(state.coordinates),
+        capacity: antelope.UInt32.from(state.capacity),
+        cargomass: antelope.UInt32.from(0),
+        cargo: state.cargo || [],
+        is_idle: !state.schedule,
+        current_task_elapsed: antelope.UInt32.from(0),
+        current_task_remaining: antelope.UInt32.from(0),
+        pending_tasks: [],
+    };
+    if (state.hullmass !== undefined)
+        info.hullmass = antelope.UInt32.from(state.hullmass);
+    if (state.loaders)
+        info.loaders = state.loaders;
+    if (state.schedule)
+        info.schedule = state.schedule;
+    const entityInfo = Types.entity_info.from(info);
+    return new Warehouse(entityInfo);
+}
+function makeContainer(state) {
+    const entityInfo = Types.entity_info.from({
+        type: antelope.Name.from('container'),
+        id: antelope.UInt64.from(state.id),
+        owner: antelope.Name.from(state.owner),
+        entity_name: state.name,
+        coordinates: Types.coordinates.from(state.coordinates),
+        hullmass: antelope.UInt32.from(state.hullmass),
+        capacity: antelope.UInt32.from(state.capacity),
+        cargomass: antelope.UInt32.from(state.cargomass || 0),
+        cargo: [],
+        is_idle: !state.schedule,
+        current_task_elapsed: antelope.UInt32.from(0),
+        current_task_remaining: antelope.UInt32.from(0),
+        pending_tasks: [],
+        schedule: state.schedule,
+    });
+    return new Container(entityInfo);
 }
 
 function totalCargoMass(cargo) {
@@ -7694,7 +7925,7 @@ const categories = [
     {
         id: 'precious',
         name: 'Precious Metals',
-        label: 'Precious',
+        label: 'Precious Metal',
         description: 'Conductive, corrosion-resistant — electronics, energy systems, precision components',
         color: categoryColors.precious,
     },
@@ -8778,6 +9009,7 @@ exports.DEPTH_THRESHOLD_T2 = DEPTH_THRESHOLD_T2;
 exports.DEPTH_THRESHOLD_T3 = DEPTH_THRESHOLD_T3;
 exports.DEPTH_THRESHOLD_T4 = DEPTH_THRESHOLD_T4;
 exports.DEPTH_THRESHOLD_T5 = DEPTH_THRESHOLD_T5;
+exports.ENTITY_CAPACITY_EXCEEDED = ENTITY_CAPACITY_EXCEEDED;
 exports.EPOCH_NON_ZERO = EPOCH_NON_ZERO;
 exports.EPOCH_NOT_READY = EPOCH_NOT_READY;
 exports.ERROR_SYSTEM_ALREADY_INITIALIZED = ERROR_SYSTEM_ALREADY_INITIALIZED;
@@ -8857,8 +9089,13 @@ exports.PRECISION = PRECISION$1;
 exports.PlatformContract = platform;
 exports.Player = Player;
 exports.PlayersManager = PlayersManager;
+exports.RECIPE_INPUTS_EXCESS = RECIPE_INPUTS_EXCESS;
+exports.RECIPE_INPUTS_INSUFFICIENT = RECIPE_INPUTS_INSUFFICIENT;
+exports.RECIPE_INPUTS_INVALID = RECIPE_INPUTS_INVALID;
+exports.RECIPE_INPUTS_MIXED = RECIPE_INPUTS_MIXED;
 exports.REQUIRES_MORE_THAN_ONE = REQUIRES_MORE_THAN_ONE;
 exports.REQUIRES_POSITIVE_VALUE = REQUIRES_POSITIVE_VALUE;
+exports.RESERVE_TIERS = RESERVE_TIERS;
 exports.SHIP_ALREADY_THERE = SHIP_ALREADY_THERE;
 exports.SHIP_ALREADY_TRAVELING = SHIP_ALREADY_TRAVELING;
 exports.SHIP_CANNOT_BUY_TRAVELING = SHIP_CANNOT_BUY_TRAVELING;
@@ -8881,6 +9118,7 @@ exports.ScheduleAccessor = ScheduleAccessor;
 exports.ServerContract = server;
 exports.Ship = Ship;
 exports.Shipload = Shipload;
+exports.TIER_ROLL_MAX = TIER_ROLL_MAX;
 exports.TRAVEL_MAX_DURATION = TRAVEL_MAX_DURATION;
 exports.WAREHOUSE_ALREADY_AT_LOCATION = WAREHOUSE_ALREADY_AT_LOCATION;
 exports.WAREHOUSE_CAPACITY_EXCEEDED = WAREHOUSE_CAPACITY_EXCEEDED;
@@ -8898,6 +9136,7 @@ exports.calcCargoItemMass = calcCargoItemMass;
 exports.calcCargoMass = calcCargoMass;
 exports.calcEnergyUsage = calcEnergyUsage;
 exports.calcLoadDuration = calcLoadDuration;
+exports.calcStacksMass = calcStacksMass;
 exports.calc_acceleration = calc_acceleration;
 exports.calc_craft_duration = calc_craft_duration;
 exports.calc_craft_energy = calc_craft_energy;
@@ -8927,6 +9166,7 @@ exports.capsHasLoaders = capsHasLoaders;
 exports.capsHasMass = capsHasMass;
 exports.capsHasMovement = capsHasMovement;
 exports.capsHasStorage = capsHasStorage;
+exports.cargoItemToStack = cargoItemToStack;
 exports.cargoUtils = cargoUtils;
 exports.categoryColors = categoryColors;
 exports.categoryIcons = categoryIcons;
@@ -8939,6 +9179,7 @@ exports.computeBaseHullmass = computeBaseHullmass;
 exports.computeComponentStats = computeComponentStats;
 exports.computeContainerCapabilities = computeContainerCapabilities;
 exports.computeContainerT2Capabilities = computeContainerT2Capabilities;
+exports.computeCraftedOutputSeed = computeCraftedOutputSeed;
 exports.computeCrafterDrain = computeCrafterDrain;
 exports.computeCrafterSpeed = computeCrafterSpeed;
 exports.computeEngineCapabilities = computeEngineCapabilities;
@@ -8973,7 +9214,6 @@ exports.decodeCraftedItemStats = decodeCraftedItemStats;
 exports.decodeStat = decodeStat;
 exports.decodeStats = decodeStats;
 exports["default"] = Shipload;
-exports.depthScaleFactor = depthScaleFactor;
 exports.deriveLocation = deriveLocation;
 exports.deriveLocationEpoch = deriveLocationEpoch;
 exports.deriveLocationSize = deriveLocationSize;
@@ -9059,6 +9299,7 @@ exports.makeContainer = makeContainer;
 exports.makeShip = makeShip;
 exports.makeWarehouse = makeWarehouse;
 exports.maxTravelDistance = maxTravelDistance;
+exports.mergeStacks = mergeStacks;
 exports.moduleAccepts = moduleAccepts;
 exports.moduleDisplayName = moduleDisplayName;
 exports.moduleIcon = moduleIcon;
@@ -9067,11 +9308,18 @@ exports.needsRecharge = needsRecharge;
 exports.projectEntity = projectEntity;
 exports.projectEntityAt = projectEntityAt;
 exports.readCommonBase = readCommonBase;
+exports.removeFromStacks = removeFromStacks;
 exports.resolveItem = resolveItem;
 exports.resolveStats = resolveStats;
+exports.rollTier = rollTier;
+exports.rollWithinTier = rollWithinTier;
 exports.rotation = rotation;
 exports.schedule = schedule;
+exports.stackKey = stackKey;
+exports.stackToCargoItem = stackToCargoItem;
+exports.stacksEqual = stacksEqual;
 exports.statMappings = statMappings;
 exports.tierColors = tierColors;
 exports.toLocation = toLocation;
+exports.validateSchedule = validateSchedule;
 //# sourceMappingURL=shipload.js.map