leg-aware capacity and wagon sharing

apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.ts

@@ -6925,6 +6925,42 @@ export class TrainSchedulingService {
         reverseWagonOrder: schedule.reverseWagonOrder,
       });
 
+    // Heaviest-edge consist usage. Cross-leg slot sharing means plain sums
+    // over-report a multi-stop train — a wagon reused Gelan→Adama and
+    // Adama→Doraleh is two slots but ONE physical wagon, and the train is never
+    // heavier/longer than its heaviest single leg. Same math as the pull-limit
+    // enforcement; coupled-but-empty consist wagons ride every edge.
+    const heaviestLeg = schedule.trainSet
+      ? (() => {
+          const usage = maxEdgeConsistUsage(
+            [
+              ...(schedule.trainSet.wagons ?? []).map((w) => ({
+                lengthMeters: Number(w.lengthMeters),
+                tareWeightTons: w.wagonType
+                  ? Number(w.wagonType.tareWeightTons)
+                  : 0,
+                assignedWeightTons: Number(w.assignedWeightTons),
+                boardYardId: w.boardYardId ?? null,
+                alightYardId: w.alightYardId ?? null,
+                allocations: w.allocations ?? [],
+              })),
+              ...emptyConsistWagons.map((w) => ({
+                lengthMeters: w.lengthMeters,
+                tareWeightTons: Number(w.tareWeightTons ?? 0),
+                assignedWeightTons: 0,
+                allocations: [],
+              })),
+            ],
+            this.mapScheduleStops(schedule).map((s) => s.yardId),
+          );
+          return {
+            grossWeightTons: roundTons(usage.grossWeightTons),
+            lengthMeters: roundTons(usage.lengthMeters),
+            loadedWagonCount: usage.loadedWagonCount,
+          };
+        })()
+      : null;
+
     return {
       id: schedule.id,
       reference: schedule.reference ?? null,
@@ -6997,6 +7033,9 @@ export class TrainSchedulingService {
             wagonCount: schedule.trainSet.wagonCount,
             totalWeightTons: roundTons(Number(schedule.trainSet.totalWeightTons)),
             totalLengthMeters: roundTons(Number(schedule.trainSet.totalLengthMeters)),
+            // What the locomotives actually haul: usage on the corridor's
+            // heaviest edge, not the sum of every leg's slots.
+            heaviestLeg,
             locomotive: schedule.trainSet.locomotive
               ? {
                   id: schedule.trainSet.locomotive.id,

apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.spec.ts

@@ -308,6 +308,7 @@ describe('maxEdgeConsistUsage — the binding edge, not the whole-route sum', ()
     expect(maxEdgeConsistUsage(plan, stops)).toEqual({
       grossWeightTons: 89,
       lengthMeters: 14,
+      loadedWagonCount: 1,
     });
   });
 
@@ -328,6 +329,7 @@ describe('maxEdgeConsistUsage — the binding edge, not the whole-route sum', ()
     expect(maxEdgeConsistUsage(plan, ['a', 'b'])).toEqual({
       grossWeightTons: 178,
       lengthMeters: 28,
+      loadedWagonCount: 2,
     });
   });
 });

apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.ts

@@ -565,9 +565,22 @@ export function validateMixedTrainLimitsPerEdge(
   return [...violations];
 }
 
+/**
+ * The slot fields per-edge usage math actually reads — lets callers feed
+ * persisted TrainSetWagon rows (or any structural subset), not only plan slots.
+ */
+export type EdgeUsageSlot = Pick<
+  WagonPlanSlot,
+  'lengthMeters' | 'tareWeightTons' | 'assignedWeightTons'
+> & {
+  boardYardId?: string | null;
+  alightYardId?: string | null;
+  allocations?: unknown[];
+};
+
 /** Per-slot stop-index spans; a yard missing from the stop list keeps the slot on the whole route. */
 function slotSpans(
-  wagonPlan: WagonPlanSlot[],
+  wagonPlan: EdgeUsageSlot[],
   stops: string[],
 ): Array<{ from: number; to: number }> {
   const lastIdx = stops.length - 1;
@@ -587,26 +600,28 @@ function slotSpans(
  * Two stops or fewer degrade to the whole-train totals.
  */
 export function maxEdgeConsistUsage(
-  wagonPlan: WagonPlanSlot[],
+  wagonPlan: EdgeUsageSlot[],
   stops: string[],
-): { grossWeightTons: number; lengthMeters: number } {
-  const totals = (slots: WagonPlanSlot[]) => ({
+): { grossWeightTons: number; lengthMeters: number; loadedWagonCount: number } {
+  const totals = (slots: EdgeUsageSlot[]) => ({
     grossWeightTons: slots.reduce(
       (sum, w) =>
         sum + Number(w.tareWeightTons ?? 0) + Number(w.assignedWeightTons ?? 0),
       0,
     ),
     lengthMeters: slots.reduce((sum, w) => sum + Number(w.lengthMeters ?? 0), 0),
+    loadedWagonCount: slots.filter((w) => (w.allocations?.length ?? 1) > 0).length,
   });
   if (stops.length <= 2) return totals(wagonPlan);
   const spans = slotSpans(wagonPlan, stops);
-  const usage = { grossWeightTons: 0, lengthMeters: 0 };
+  const usage = { grossWeightTons: 0, lengthMeters: 0, loadedWagonCount: 0 };
   for (let edge = 0; edge < stops.length - 1; edge += 1) {
     const active = totals(
       wagonPlan.filter((_, i) => spans[i].from <= edge && edge < spans[i].to),
     );
     usage.grossWeightTons = Math.max(usage.grossWeightTons, active.grossWeightTons);
     usage.lengthMeters = Math.max(usage.lengthMeters, active.lengthMeters);
+    usage.loadedWagonCount = Math.max(usage.loadedWagonCount, active.loadedWagonCount);
   }
   return usage;
 }