@shipload/sdk 1.0.0-next.59 → 1.0.0-next.60

package/src/derivation/wormhole.ts

@@ -76,10 +76,23 @@ function dist(a: {x: number; y: number}, b: {x: number; y: number}): number {
 function inBounds(c: {x: number; y: number}): boolean {
     return c.x >= COORD_MIN && c.x <= COORD_MAX && c.y >= COORD_MIN && c.y <= COORD_MAX
 }
-function wormholeOfRegion(
-    seed: Checksum256Type,
-    R: Region
-): {A: {x: number; y: number}; B: {x: number; y: number}} | null {
+type RegionWormhole = {A: {x: number; y: number}; B: {x: number; y: number}} | null
+
+// ~11 sha512 rolls per region; pure in (seed, region), so memoized for A* neighbor probes.
+const regionCache = new Map<string, RegionWormhole>()
+const REGION_CACHE_MAX = 16384
+
+function wormholeOfRegion(seed: Checksum256Type, R: Region): RegionWormhole {
+    const cacheKey = `${seed}:${R.rx}:${R.ry}`
+    const cached = regionCache.get(cacheKey)
+    if (cached !== undefined) return cached
+    const result = deriveWormholeOfRegion(seed, R)
+    if (regionCache.size >= REGION_CACHE_MAX) regionCache.clear()
+    regionCache.set(cacheKey, result)
+    return result
+}
+
+function deriveWormholeOfRegion(seed: Checksum256Type, R: Region): RegionWormhole {
     const P = partnerRegion(seed, R)
     if (P.rx === R.rx && P.ry === R.ry) return null
     const key = pairKey(R, P)

package/src/index-module.ts

@@ -322,9 +322,15 @@ export {
     calcCounterpartDelivery,
     cargoKey,
     cargoInputKey,
+    hasSourceCoupling,
+    hasIncomingCoupling,
 } from './scheduling/availability'
 export type {CargoInput, IncomingSource} from './scheduling/availability'
 
+export {clusterStockAvailable} from './scheduling/cluster-stock'
+
+export {calcClusterIntake, calcClustercraftDuration, INTAKE_RATE} from './capabilities/crafting'
+
 export {maxCraftable} from './capabilities/craftable'
 
 export {energyAtTime} from './scheduling/energy'
@@ -463,6 +469,7 @@ export {
     GATHERER_DEPTH_TABLE,
     GATHERER_DEPTH_MAX_TIER,
     gathererDepthForTier,
+    computeGathererYield,
 } from './derivation/capabilities'
 export type {
     GathererDepthParams,
@@ -577,7 +584,6 @@ export {
     ENGINE_DRAIN_REF_THM,
     computeGeneratorCap,
     computeGeneratorRech,
-    computeGathererYield,
     computeGathererDrain,
     computeGathererDepth,
     computeLoaderMass,

package/src/managers/actions.ts

@@ -472,6 +472,29 @@ export class ActionsManager extends BaseManager {
         return this.server.action('craftjob', params)
     }
 
+    clustercraft(
+        entityId: UInt64Type,
+        recipeId: number,
+        quantity: number,
+        sources: ServerContract.ActionParams.Type.cluster_source[],
+        target?: UInt64Type,
+        slot?: UInt8Type
+    ): Action {
+        const params: ServerContract.ActionParams.clustercraft = {
+            id: UInt64.from(entityId),
+            recipe_id: UInt16.from(recipeId),
+            quantity: UInt32.from(quantity),
+            sources,
+        }
+        if (target !== undefined) {
+            params.target = UInt64.from(target)
+        }
+        if (slot !== undefined) {
+            params.slot = UInt8.from(slot)
+        }
+        return this.server.action('clustercraft', params)
+    }
+
     claimjob(jobId: UInt64Type, shipId: UInt64Type): Action {
         const params: ServerContract.ActionParams.claimjob = {
             job_id: UInt64.from(jobId),

package/src/nft/buildImmutableData.ts

@@ -14,6 +14,7 @@ import {
     MODULE_WARP,
 } from '../capabilities/modules'
 import {decodeStat, decodeCraftedItemStats} from '../derivation/crafting'
+import {computeGathererYield} from '../derivation/capabilities'
 import {computeEffectiveModuleStat} from '../derivation/stat-scaling'
 import {getStatDefinitions} from '../derivation/stats'
 import type {ResourceCategory} from '../types'
@@ -28,7 +29,6 @@ import {
     computeEngineThrust,
     computeGathererDepth,
     computeGathererDrain,
-    computeGathererYield,
     computeGeneratorCap,
     computeGeneratorRech,
     computeCargoBayCapacity,
@@ -194,7 +194,7 @@ export function buildModuleImmutable(
             base.push({first: 'thermal', second: ['uint16', thm]})
             base.push({
                 first: 'thrust',
-                second: ['uint32', computeEngineThrust(computeEffectiveModuleStat(vol))],
+                second: ['uint32', computeEngineThrust(computeEffectiveModuleStat(vol), item.tier)],
             })
             base.push({
                 first: 'drain',
@@ -211,14 +211,14 @@ export function buildModuleImmutable(
                 first: 'capacity',
                 second: [
                     'uint16',
-                    toWholeEnergy(computeGeneratorCap(computeEffectiveModuleStat(res))),
+                    toWholeEnergy(computeGeneratorCap(computeEffectiveModuleStat(res), item.tier)),
                 ],
             })
             base.push({
                 first: 'recharge',
                 second: [
                     'uint16',
-                    toWholeEnergy(computeGeneratorRech(computeEffectiveModuleStat(ref))),
+                    toWholeEnergy(computeGeneratorRech(computeEffectiveModuleStat(ref), item.tier)),
                 ],
             })
             break
@@ -230,7 +230,10 @@ export function buildModuleImmutable(
             base.push({first: 'strength', second: ['uint16', str]})
             base.push({first: 'hardness', second: ['uint16', hrd]})
             base.push({first: 'saturation', second: ['uint16', sat]})
-            base.push({first: 'yield', second: ['uint16', computeGathererYield(str)]})
+            base.push({
+                first: 'yield',
+                second: ['uint16', computeGathererYield(str, item.tier)],
+            })
             base.push({
                 first: 'drain',
                 second: ['uint16', toWholeEnergy(computeGathererDrain(sat))],
@@ -244,13 +247,13 @@ export function buildModuleImmutable(
             base.push({first: 'fineness', second: ['uint16', fin]})
             base.push({first: 'plasticity', second: ['uint16', pla]})
             base.push({first: 'mass', second: ['uint32', computeLoaderMass(fin)]})
-            base.push({first: 'thrust', second: ['uint16', computeLoaderThrust(pla)]})
+            base.push({first: 'thrust', second: ['uint16', computeLoaderThrust(pla, item.tier)]})
             break
         }
         case MODULE_WARP: {
             const ref = decodeStat(stats, 0)
             base.push({first: 'reflectivity', second: ['uint16', ref]})
-            base.push({first: 'range', second: ['uint32', computeWarpRange(ref)]})
+            base.push({first: 'range', second: ['uint32', computeWarpRange(ref, item.tier)]})
             break
         }
         case MODULE_CRAFTER: {
@@ -258,7 +261,7 @@ export function buildModuleImmutable(
             const con = decodeStat(stats, 1)
             base.push({first: 'fineness', second: ['uint16', fin]})
             base.push({first: 'conductivity', second: ['uint16', con]})
-            base.push({first: 'speed', second: ['uint16', computeCrafterSpeed(fin)]})
+            base.push({first: 'speed', second: ['uint16', computeCrafterSpeed(fin, item.tier)]})
             base.push({first: 'drain', second: ['uint16', toWholeEnergy(computeCrafterDrain(con))]})
             break
         }
@@ -267,7 +270,7 @@ export function buildModuleImmutable(
             const fin = decodeStat(stats, 1)
             base.push({first: 'resonance', second: ['uint16', res]})
             base.push({first: 'fineness', second: ['uint16', fin]})
-            base.push({first: 'speed', second: ['uint16', computeBuilderSpeed(res)]})
+            base.push({first: 'speed', second: ['uint16', computeBuilderSpeed(res, item.tier)]})
             base.push({first: 'drain', second: ['uint16', toWholeEnergy(computeBuilderDrain(fin))]})
             break
         }

package/src/nft/description.ts

@@ -16,18 +16,23 @@ import {
     ITEM_CONTAINER_T2_PACKED,
     ITEM_CONSTRUCTION_DOCK_T1_PACKED,
     ITEM_BUILDER_T1,
+    ITEM_BUILDER_T2,
     ITEM_CRAFTER_T1,
+    ITEM_CRAFTER_T2,
     ITEM_ENGINE_T1,
+    ITEM_ENGINE_T2,
     ITEM_EXTRACTOR_T1_PACKED,
     ITEM_FACTORY_T1_PACKED,
     ITEM_GATHERER_T1,
     ITEM_GATHERER_T2,
     ITEM_GENERATOR_T1,
+    ITEM_GENERATOR_T2,
     ITEM_HAULER_T1,
     ITEM_HAULER_T2,
     ITEM_BATTERY_T1,
     ITEM_LAUNCHER_T1,
     ITEM_LOADER_T1,
+    ITEM_LOADER_T2,
     ITEM_PROSPECTOR_T1A_PACKED,
     ITEM_PROSPECTOR_T2A_PACKED,
     ITEM_PROSPECTOR_T2B_PACKED,
@@ -42,9 +47,21 @@ import {
     ITEM_DREDGER_T2A_PACKED,
     ITEM_WAREHOUSE_T1_PACKED,
     ITEM_WARP_T1,
+    ITEM_WARP_T2,
 } from '../data/item-ids'
 import {decodeStat} from '../derivation/crafting'
-import {gathererDepthForTier} from '../derivation/capabilities'
+import {
+    gathererDepthForTier,
+    computeGathererYield,
+    moduleTierPct,
+    ENGINE_THRUST_TIER_PCT,
+    GENERATOR_CAPACITY_TIER_PCT,
+    GENERATOR_RECHARGE_TIER_PCT,
+    CRAFTER_SPEED_TIER_PCT,
+    BUILDER_SPEED_TIER_PCT,
+    WARP_RANGE_TIER_PCT,
+    LOADER_THRUST_TIER_PCT,
+} from '../derivation/capabilities'
 import {getItem} from '../data/catalog'
 import {ENTITY_SHIP, getPackedEntityType} from '../data/kind-registry'
 import {getBaseHullmassFor} from '../derivation/capabilities'
@@ -92,7 +109,8 @@ export function computeBaseCapacityWarehouse(stats: bigint): number {
     return Math.floor(100_000_000 * 6 ** (s / 1998))
 }
 
-export const computeEngineThrust = (vol: number): number => 400 + idiv(vol * 3, 4)
+export const computeEngineThrust = (vol: number, tier: number): number =>
+    idiv((400 + idiv(vol * 3, 4)) * moduleTierPct(ENGINE_THRUST_TIER_PCT, tier), 100)
 export const computeEngineDrain = (thm: number): number => 2 * Math.max(30, 50 - idiv(thm, 70))
 export const ENGINE_DRAIN_BASE = 156
 export const ENGINE_DRAIN_REF_THRUST = 775
@@ -104,19 +122,23 @@ export const computeTravelDrain = (totalThrust: number, avgThm: number): number
     const thrustFactor = Math.sqrt(ENGINE_DRAIN_REF_THRUST / totalThrust)
     return Math.floor(ENGINE_DRAIN_BASE * 1000 * thermalFactor * thrustFactor)
 }
-export const computeGeneratorCap = (com: number): number => 1_300_000 + com * 500
-export const computeGeneratorRech = (fin: number): number => 2000 + fin * 6
-export const computeGathererYield = (str: number): number => 200 + str
+export const computeGeneratorCap = (com: number, tier: number): number =>
+    idiv((1_300_000 + com * 500) * moduleTierPct(GENERATOR_CAPACITY_TIER_PCT, tier), 100)
+export const computeGeneratorRech = (fin: number, tier: number): number =>
+    idiv((2000 + fin * 6) * moduleTierPct(GENERATOR_RECHARGE_TIER_PCT, tier), 100)
 export const computeGathererDrain = (con: number): number =>
     2 * Math.max(250_000, 1_250_000 - con * 1250)
 export const computeGathererDepth = (tol: number, tier: number): number =>
     gathererDepthForTier(tol, tier)
 export const computeLoaderMass = (ins: number): number => Math.max(200, 2000 - ins * 2)
-export const computeLoaderThrust = (pla: number): number => 1 + idiv(pla * pla, 10000)
-export const computeCrafterSpeed = (rea: number): number => 100 + idiv(rea * 4, 5)
+export const computeLoaderThrust = (pla: number, tier: number): number =>
+    idiv((1 + idiv(pla * pla, 10000)) * moduleTierPct(LOADER_THRUST_TIER_PCT, tier), 100)
+export const computeCrafterSpeed = (rea: number, tier: number): number =>
+    idiv((100 + idiv(rea * 4, 5)) * moduleTierPct(CRAFTER_SPEED_TIER_PCT, tier), 100)
 export const computeCrafterDrain = (fin: number): number =>
     Math.max(5000, 30000 - idiv(fin * 1000, 33))
-export const computeBuilderSpeed = (resonance: number): number => 100 + idiv(resonance * 4, 5)
+export const computeBuilderSpeed = (resonance: number, tier: number): number =>
+    idiv((100 + idiv(resonance * 4, 5)) * moduleTierPct(BUILDER_SPEED_TIER_PCT, tier), 100)
 export const computeBuilderDrain = (fineness: number): number =>
     Math.max(5000, 30000 - idiv(fineness * 1000, 33))
 export const computeHaulerCapacity = (fin: number, tier: number): number =>
@@ -132,7 +154,8 @@ export const computeHaulerDrain = (conductivity: number, tier: number): number =
     idiv(computeT1LogisticsDrain(conductivity) * supportDrainTierPercent(tier), 100)
 export const computeCargoBayDrain = (cohesion: number, tier: number): number =>
     idiv(computeT1LogisticsDrain(cohesion) * 3 * supportDrainTierPercent(tier), 400)
-export const computeWarpRange = (stat: number): number => 100 + stat * 3
+export const computeWarpRange = (stat: number, tier: number): number =>
+    idiv((100 + stat * 3) * moduleTierPct(WARP_RANGE_TIER_PCT, tier), 100)
 export const computeCargoBayCapacity = (
     strength: number,
     density: number,
@@ -189,17 +212,22 @@ export function entityDisplayName(itemId: number): string {
 export function moduleDisplayName(itemId: number): string {
     switch (itemId) {
         case ITEM_ENGINE_T1:
+        case ITEM_ENGINE_T2:
             return 'Engine'
         case ITEM_GENERATOR_T1:
+        case ITEM_GENERATOR_T2:
             return 'Power Core'
         case ITEM_GATHERER_T1:
         case ITEM_GATHERER_T2:
             return 'Limpet Bay'
         case ITEM_LOADER_T1:
+        case ITEM_LOADER_T2:
             return 'Shuttle Bay'
         case ITEM_CRAFTER_T1:
+        case ITEM_CRAFTER_T2:
             return 'Fabricator'
         case ITEM_BUILDER_T1:
+        case ITEM_BUILDER_T2:
             return 'Assembly Arm'
         case ITEM_STORAGE_T1:
             return 'Cargo Hold'
@@ -207,6 +235,7 @@ export function moduleDisplayName(itemId: number): string {
         case ITEM_HAULER_T2:
             return 'Tractor Beam'
         case ITEM_WARP_T1:
+        case ITEM_WARP_T2:
             return 'Warp Drive'
         case ITEM_BATTERY_T1:
             return 'Battery Bank'
@@ -231,14 +260,16 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
         case MODULE_ENGINE: {
             const vol = computeEffectiveModuleStat(decodeStat(stats, 0))
             const thm = computeEffectiveModuleStat(decodeStat(stats, 1))
-            out += `  Thrust ${computeEngineThrust(vol)}  Drain ${computeEngineDrain(thm)}`
+            const tier = getItem(itemId).tier
+            out += `  Thrust ${computeEngineThrust(vol, tier)}  Drain ${computeEngineDrain(thm)}`
             break
         }
         case MODULE_GENERATOR: {
             const res = computeEffectiveModuleStat(decodeStat(stats, 0))
             const ref = computeEffectiveModuleStat(decodeStat(stats, 1))
-            out += `  Capacity ${toWholeEnergy(computeGeneratorCap(res))}  Recharge ${toWholeEnergy(
-                computeGeneratorRech(ref)
+            const tier = getItem(itemId).tier
+            out += `  Capacity ${toWholeEnergy(computeGeneratorCap(res, tier))}  Recharge ${toWholeEnergy(
+                computeGeneratorRech(ref, tier)
             )}`
             break
         }
@@ -247,7 +278,7 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             const tol = decodeStat(stats, 1)
             const con = decodeStat(stats, 2)
             const tier = getItem(itemId).tier
-            out += `  Yield ${computeGathererYield(str)}  Depth ${computeGathererDepth(
+            out += `  Yield ${computeGathererYield(str, tier)}  Depth ${computeGathererDepth(
                 tol,
                 tier
             )}  Drain ${toWholeEnergy(computeGathererDrain(con))}`
@@ -256,19 +287,22 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
         case MODULE_LOADER: {
             const fin = decodeStat(stats, 0)
             const pla = decodeStat(stats, 1)
-            out += `  Mass ${computeLoaderMass(fin)}  Thrust ${computeLoaderThrust(pla)}`
+            const tier = getItem(itemId).tier
+            out += `  Mass ${computeLoaderMass(fin)}  Thrust ${computeLoaderThrust(pla, tier)}`
             break
         }
         case MODULE_CRAFTER: {
             const rea = decodeStat(stats, 0)
             const con = decodeStat(stats, 1)
-            out += `  Speed ${computeCrafterSpeed(rea)}  Drain ${toWholeEnergy(computeCrafterDrain(con))}`
+            const tier = getItem(itemId).tier
+            out += `  Speed ${computeCrafterSpeed(rea, tier)}  Drain ${toWholeEnergy(computeCrafterDrain(con))}`
             break
         }
         case MODULE_BUILDER: {
             const res = decodeStat(stats, 0)
             const fin = decodeStat(stats, 1)
-            out += `  Speed ${computeBuilderSpeed(res)}  Drain ${toWholeEnergy(computeBuilderDrain(fin))}`
+            const tier = getItem(itemId).tier
+            out += `  Speed ${computeBuilderSpeed(res, tier)}  Drain ${toWholeEnergy(computeBuilderDrain(fin))}`
             break
         }
         case MODULE_STORAGE: {
@@ -290,7 +324,8 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
         }
         case MODULE_WARP: {
             const stat = decodeStat(stats, 0)
-            out += `  Range ${computeWarpRange(stat)}`
+            const tier = getItem(itemId).tier
+            out += `  Range ${computeWarpRange(stat, tier)}`
             break
         }
         case MODULE_BATTERY: {

package/src/resolution/resolve-item.ts

@@ -161,7 +161,7 @@ function computeCapabilityGroup(
 ): ResolvedAttributeGroup | undefined {
     switch (moduleType) {
         case MODULE_ENGINE: {
-            const caps = computeEngineCapabilities(stats)
+            const caps = computeEngineCapabilities(stats, tier)
             return {
                 capability: 'Engine',
                 attributes: [
@@ -171,7 +171,7 @@ function computeCapabilityGroup(
             }
         }
         case MODULE_GENERATOR: {
-            const caps = computeGeneratorCapabilities(stats)
+            const caps = computeGeneratorCapabilities(stats, tier)
             return {
                 capability: 'Generator',
                 attributes: [
@@ -192,7 +192,7 @@ function computeCapabilityGroup(
             }
         }
         case MODULE_LOADER: {
-            const caps = computeLoaderCapabilities(stats)
+            const caps = computeLoaderCapabilities(stats, tier)
             return {
                 capability: 'Loading',
                 attributes: [
@@ -203,7 +203,7 @@ function computeCapabilityGroup(
             }
         }
         case MODULE_CRAFTER: {
-            const caps = computeCrafterCapabilities(stats)
+            const caps = computeCrafterCapabilities(stats, tier)
             return {
                 capability: 'Crafting',
                 attributes: [
@@ -213,7 +213,7 @@ function computeCapabilityGroup(
             }
         }
         case MODULE_BUILDER: {
-            const caps = computeBuilderCapabilities(stats)
+            const caps = computeBuilderCapabilities(stats, tier)
             return {
                 capability: 'Build',
                 attributes: [

package/src/scheduling/availability.test.ts

@@ -4,8 +4,11 @@ import {
     calcCounterpartDelivery,
     cargoReadyAt,
     type CargoInput,
+    hasIncomingCoupling,
+    hasSourceCoupling,
     type IncomingSource,
     projectedCargoAvailableAt,
+    taskCargoEffect,
 } from './availability'
 
 const T0 = '2026-06-19T00:00:00'
@@ -33,6 +36,19 @@ function coupling(kind: number) {
     })
 }
 
+function craftTask(
+    cargo: ReturnType<typeof cargoItem>[],
+    couplings: ReturnType<typeof coupling>[]
+) {
+    return ServerContract.Types.task.from({
+        type: TaskType.CRAFT,
+        duration: 60,
+        cancelable: 0,
+        cargo,
+        couplings,
+    })
+}
+
 function entity(
     cargo: ReturnType<typeof cargoItem>[],
     tasks: ReturnType<typeof task>[] = [],
@@ -155,3 +171,34 @@ describe('projectedCargoAvailableAt — incoming', () => {
         expect(avail.get('7:0') ?? 0n).toBe(0n)
     })
 })
+
+describe('clustercraft projection parity', () => {
+    const inputs = [cargoItem(1001, 0, 10), cargoItem(1002, 0, 5)]
+    const output = cargoItem(2001, 0, 1)
+
+    test('own-hold craft: inputs removed, output added', () => {
+        const eff = taskCargoEffect(craftTask([...inputs, output], []))
+        expect(eff.removed.length).toBe(2)
+        expect(eff.added).toEqual([output])
+    })
+
+    test('clustercraft to a target: no crafter debit, no crafter credit', () => {
+        const t = craftTask(
+            [...inputs, output],
+            [coupling(HoldKind.SOURCE), coupling(HoldKind.GATHER)]
+        )
+        expect(hasSourceCoupling(t)).toBe(true)
+        expect(hasIncomingCoupling(t)).toBe(true)
+        const eff = taskCargoEffect(t)
+        expect(eff.removed).toEqual([])
+        expect(eff.added).toEqual([])
+    })
+
+    test('clustercraft with target omitted: output falls back to crafter, still no input debit', () => {
+        const t = craftTask([...inputs, output], [coupling(HoldKind.SOURCE)])
+        expect(hasIncomingCoupling(t)).toBe(false)
+        const eff = taskCargoEffect(t)
+        expect(eff.removed).toEqual([])
+        expect(eff.added).toEqual([output])
+    })
+})

package/src/scheduling/availability.ts

@@ -36,6 +36,25 @@ export function isIncomingCouplingKind(kind: number): boolean {
     return INCOMING_COUPLING_KINDS.has(kind)
 }
 
+// Mirrors has_source_hold: a HOLD_SOURCE coupling marks an escrowed clustercraft.
+export function hasSourceCoupling(task: Task): boolean {
+    return task.couplings.some((c) => c.kind.toNumber() === HoldKind.SOURCE)
+}
+
+// Mirrors has_incoming_coupling: any PUSH/GATHER/FLIGHT coupling delivers output to a counterpart.
+export function hasIncomingCoupling(task: Task): boolean {
+    return task.couplings.some((c) => isIncomingCouplingKind(c.kind.toNumber()))
+}
+
+// A CRAFT task's output ownership: clustered escrows inputs off other members; own-output lands on the crafter.
+export function craftCargoOwnership(task: Task): {clustered: boolean; ownOutput: boolean} {
+    const clustered = hasSourceCoupling(task)
+    return {
+        clustered,
+        ownOutput: clustered ? !hasIncomingCoupling(task) : task.couplings.length === 0,
+    }
+}
+
 // Mirrors calc_counterpart_delivery: incoming-kind couplings only; a coupled CRAFT yields its output slot.
 export function calcCounterpartDelivery(task: Task, coupling: Coupling): CargoItem[] {
     if (!isIncomingCouplingKind(coupling.kind.toNumber())) return []
@@ -58,12 +77,14 @@ export function taskCargoEffect(task: Task): CargoEffect {
             return task.couplings.length > 0
                 ? {added: [], removed: []}
                 : {added: task.cargo, removed: []}
-        case TaskType.CRAFT:
+        case TaskType.CRAFT: {
             if (task.cargo.length === 0) return {added: [], removed: []}
+            const {clustered, ownOutput} = craftCargoOwnership(task)
             return {
-                added: task.couplings.length === 0 ? [task.cargo[task.cargo.length - 1]] : [],
-                removed: task.cargo.slice(0, -1),
+                added: ownOutput ? [task.cargo[task.cargo.length - 1]] : [],
+                removed: clustered ? [] : task.cargo.slice(0, -1),
             }
+        }
         default:
             return {added: [], removed: []}
     }

package/src/scheduling/cluster-stock.test.ts

@@ -0,0 +1,31 @@
+import {describe, expect, test} from 'bun:test'
+import {ServerContract, TaskType} from '../index-module'
+import {availableForItem} from './availability'
+import {clusterStockAvailable} from './cluster-stock'
+
+const AT = new Date('2026-06-19T00:00:00')
+
+function cargoItem(itemId: number, stats: number, quantity: number) {
+    return ServerContract.Types.cargo_item.from({item_id: itemId, stats, modules: [], quantity})
+}
+
+function member(cargo: ReturnType<typeof cargoItem>[]) {
+    return {cargo, tasks: [], lanes: []} as unknown as Parameters<
+        typeof clusterStockAvailable
+    >[0][number]
+}
+
+describe('clusterStockAvailable', () => {
+    test('sums the same item split across two members', () => {
+        const stock = clusterStockAvailable(
+            [member([cargoItem(1001, 0, 30)]), member([cargoItem(1001, 0, 20)])],
+            AT
+        )
+        expect(availableForItem(stock, 1001)).toBe(50n)
+    })
+
+    test('an empty cluster yields nothing', () => {
+        const stock = clusterStockAvailable([], AT)
+        expect(availableForItem(stock, 1001)).toBe(0n)
+    })
+})

package/src/scheduling/cluster-stock.ts

@@ -0,0 +1,15 @@
+import {type AvailabilityInput, projectedCargoAvailableAt} from './availability'
+
+// Union of every cluster member's present available cargo (present-only; incoming/future not credited).
+export function clusterStockAvailable(
+    members: readonly AvailabilityInput[],
+    at: Date
+): Map<string, bigint> {
+    const total = new Map<string, bigint>()
+    for (const member of members) {
+        for (const [key, qty] of projectedCargoAvailableAt(member, at)) {
+            total.set(key, (total.get(key) ?? 0n) + qty)
+        }
+    }
+    return total
+}

package/src/scheduling/lanes.test.ts

@@ -1,7 +1,8 @@
 import {UInt8, UInt16, UInt64} from '@wharfkit/antelope'
 import {expect, test} from 'bun:test'
 import {encodeStats} from '../derivation/crafting'
-import {computeGathererYield, computeGathererDepth, computeGathererDrain} from '../nft/description'
+import {computeGathererDepth, computeGathererDrain} from '../nft/description'
+import {computeGathererYield} from '../derivation/capabilities'
 import {computeLoaderThrust, computeLoaderMass} from '../nft/description'
 import {computeCrafterSpeed, computeCrafterDrain} from '../nft/description'
 import {applySlotMultiplier} from '../entities/slot-multiplier'
@@ -77,8 +78,8 @@ test('resolveLaneGatherer reads the layout slot amp and applies it to yield (par
 
     // The resolver routes through the real layout's amp, not a hardcoded 100.
     expect(result.outputPct).toBe(ampFromLayout)
-    // Yield equals the contract formula clamp_to_uint16(compute_gatherer_yield(str) * amp / 100).
-    expect(result.yield).toBe(applySlotMultiplier(computeGathererYield(GATH_STR), ampFromLayout))
+    // Yield equals the contract formula clamp_to_uint16(compute_gatherer_yield(str, tier) * amp / 100).
+    expect(result.yield).toBe(applySlotMultiplier(computeGathererYield(GATH_STR, 1), ampFromLayout))
     expect(result.drain).toBe(computeGathererDrain(GATH_CON))
     expect(result.depth).toBe(computeGathererDepth(GATH_TOL, 1))
     expect(result.slotIndex).toBe(GATHERER_SLOT_IDX)
@@ -86,11 +87,11 @@ test('resolveLaneGatherer reads the layout slot amp and applies it to yield (par
 
 test('resolveLaneGatherer amp-scaling parity holds for a non-100 amp', () => {
     // Parity for a non-100 amp: clamp_to_uint16(value * amp / 100).
-    expect(applySlotMultiplier(computeGathererYield(GATH_STR), 80)).toBe(
-        Math.min(Math.floor((computeGathererYield(GATH_STR) * 80) / 100), 65535)
+    expect(applySlotMultiplier(computeGathererYield(GATH_STR, 1), 80)).toBe(
+        Math.min(Math.floor((computeGathererYield(GATH_STR, 1) * 80) / 100), 65535)
     )
-    expect(applySlotMultiplier(computeGathererYield(GATH_STR), 120)).toBe(
-        Math.floor((computeGathererYield(GATH_STR) * 120) / 100)
+    expect(applySlotMultiplier(computeGathererYield(GATH_STR, 1), 120)).toBe(
+        Math.floor((computeGathererYield(GATH_STR, 1) * 120) / 100)
     )
 })
 
@@ -116,7 +117,7 @@ test('resolveLaneCrafter returns correct stats for slot 0 (laneKey=1)', () => {
     const layout = getEntityLayout(ITEM_CRAFTER_T1)?.slots ?? []
     const amp = getSlotAmp(layout, 0)
     expect(result.slotIndex).toBe(0)
-    expect(result.speed).toBe(applySlotMultiplier(computeCrafterSpeed(CRAFTER_REA), amp))
+    expect(result.speed).toBe(applySlotMultiplier(computeCrafterSpeed(CRAFTER_REA, 1), amp))
     expect(result.drain).toBe(computeCrafterDrain(CRAFTER_FIN))
     expect(result.outputPct).toBe(amp)
 })
@@ -144,7 +145,7 @@ test('resolveLaneLoader returns correct stats for slot 0 (laneKey=1)', () => {
     const amp = getSlotAmp(layout, 0)
     expect(result.valid).toBe(true)
     expect(result.slotIndex).toBe(0)
-    expect(result.thrust).toBe(applySlotMultiplier(computeLoaderThrust(LOADER_PLA), amp))
+    expect(result.thrust).toBe(applySlotMultiplier(computeLoaderThrust(LOADER_PLA, 1), amp))
     expect(result.mass).toBe(computeLoaderMass(LOADER_INS))
     expect(result.outputPct).toBe(amp)
 })