fix: Group services by travel time similarity in segment times modal

expandGroupedDataToServices was doing a full replace of each non-edited
service with the representative's edits, which injected periods (e.g. EV)
onto services that were merged in via mergeServicesWithSubsetPeriods and
never had those periods originally.

Propagate edits only for periods the target service already had, and add
tests covering the leak case as well as confirming that serviceIds[0] is
always the service with the most periods regardless of input order.

Author: iTzxMigz

packages/transition-common/src/services/path/PathServiceGrouping.ts

@@ -301,10 +301,14 @@ const buildServiceGroups = (
             allDayKeys.filter((day) => service.get(day)).forEach((d) => activeDaysSet.add(d));
         }
         const averageTimesByPeriod = getAverageSegmentTimesByPeriod(path, ids[0]);
+        const hasHoliday = ids.some((id) => {
+            const svc = servicesCollection?.getById(id);
+            return svc && isHolidayService(svc);
+        });
         return {
             serviceIds: ids,
             activeDays: [...activeDaysSet],
-            hasHolidayService: false,
+            hasHolidayService: hasHoliday,
             averageTimesByPeriod
         };
     });
@@ -397,8 +401,12 @@ export const groupServicesByTravelTimes = (
 
 /**
  * Expand grouped segment time overrides to all services in each group.
- * When saving, the edits made on the representative service of a group
- * are copied to all other services in the same group.
+ * When saving, edits made on the representative service of a group are
+ * propagated to the other services in the same group — but only for
+ * periods that those services already had in their original data.
+ * Periods that exist only on the representative (e.g. when a smaller
+ * service was merged into a superset via mergeServicesWithSubsetPeriods)
+ * are not injected into services that never had them.
  *
  * @param localData - Edited segment times keyed by service ID then period shortname
  * @param serviceGroups - The service groups to expand across
@@ -411,14 +419,17 @@ export const expandGroupedDataToServices = (
     const expanded = { ...localData };
     for (const group of serviceGroups) {
         const editedServiceId = group.serviceIds.find((id) => expanded[id]);
-        if (editedServiceId) {
-            for (const otherId of group.serviceIds) {
-                if (otherId !== editedServiceId) {
-                    expanded[otherId] = Object.fromEntries(
-                        Object.entries(expanded[editedServiceId]).map(([k, arr]) => [k, [...arr]])
-                    );
-                }
+        if (!editedServiceId) continue;
+        const editedEntries = expanded[editedServiceId];
+        for (const otherId of group.serviceIds) {
+            if (otherId === editedServiceId) continue;
+            const existing = expanded[otherId];
+            if (!existing) continue;
+            const merged: Record<string, number[]> = {};
+            for (const period of Object.keys(existing)) {
+                merged[period] = editedEntries[period] ? [...editedEntries[period]] : existing[period];
             }
+            expanded[otherId] = merged;
         }
     }
     return expanded;

packages/transition-common/src/services/path/__tests__/PathServiceGrouping.test.ts

@@ -208,6 +208,7 @@ describe('groupServicesByTravelTimes', () => {
         expect(groups.length).toEqual(1);
         expect(groups[0].serviceIds).toContain('regular');
         expect(groups[0].serviceIds).toContain('holiday');
+        expect(groups[0].hasHolidayService).toBe(true);
     });
 
     test('service with subset of periods merges into group with more periods', () => {
@@ -240,8 +241,55 @@ describe('groupServicesByTravelTimes', () => {
         expect(groups[0].activeDays.sort()).toEqual(['friday', 'monday', 'saturday', 'sunday', 'thursday', 'tuesday', 'wednesday']);
     });
 
+    test('representative (serviceIds[0]) is the service with the most periods even when passed last', () => {
+        // subsetService has 3 periods, fullService has 4. They share the same times for
+        // the 3 common periods, so subsetService is merged into fullService's bucket.
+        // Passing subsetService first in serviceIds must not make it the representative.
+        const path = makePath([
+            {
+                periodShortname: 'AM',
+                services: [
+                    { id: 'subsetService', travelTimeSeconds: [100, 100] },
+                    { id: 'fullService', travelTimeSeconds: [100, 100] }
+                ]
+            },
+            {
+                periodShortname: 'MD',
+                services: [
+                    { id: 'subsetService', travelTimeSeconds: [90, 90] },
+                    { id: 'fullService', travelTimeSeconds: [90, 90] }
+                ]
+            },
+            {
+                periodShortname: 'PM',
+                services: [
+                    { id: 'subsetService', travelTimeSeconds: [110, 110] },
+                    { id: 'fullService', travelTimeSeconds: [110, 110] }
+                ]
+            },
+            // Only fullService has an EV period — this is what makes its key a superset.
+            { periodShortname: 'EV', services: [{ id: 'fullService', travelTimeSeconds: [80, 80] }] }
+        ]);
+
+        const services = makeServicesCollection({
+            subsetService: makeService(
+                'subsetService',
+                { monday: true, tuesday: true, wednesday: true, thursday: true, friday: true },
+                '2026-01-01',
+                '2026-12-31'
+            ),
+            fullService: makeService('fullService', { saturday: true, sunday: true }, '2026-01-01', '2026-12-31')
+        });
+
+        const groups = groupServicesByTravelTimes(path, ['subsetService', 'fullService'], 800, services);
+
+        expect(groups.length).toEqual(1);
+        expect(groups[0].serviceIds).toHaveLength(2);
+        expect(groups[0].serviceIds[0]).toEqual('fullService');
+        expect(Object.keys(groups[0].averageTimesByPeriod).sort()).toEqual(['AM', 'EV', 'MD', 'PM']);
+    });
+
     test('service with no trips for the path produces empty fingerprint', () => {
-        // TODO: Check if we keep this test
         const path = makePath([
             {
                 periodShortname: 'AM',
@@ -389,7 +437,9 @@ describe('expandGroupedDataToServices', () => {
             }
         ];
         const localData = {
-            s1: { AM: [100, 200] }
+            s1: { AM: [100, 200] },
+            s2: { AM: [50, 60] },
+            s3: { AM: [70, 80] }
         };
 
         const expanded = expandGroupedDataToServices(localData, groups);
@@ -421,7 +471,9 @@ describe('expandGroupedDataToServices', () => {
             }
         ];
         const localData = {
-            s1: { AM: [100, 200], PM: [300, 400] }
+            s1: { AM: [100, 200], PM: [300, 400] },
+            s2: { AM: [10, 20], PM: [30, 40] },
+            s3: { AM: [50, 60], PM: [70, 80] }
         };
 
         const expanded = expandGroupedDataToServices(localData, groups);
@@ -438,4 +490,67 @@ describe('expandGroupedDataToServices', () => {
         expect(expanded.s1.PM[1]).toBe(400);
         expect(expanded.s3.PM[1]).toBe(400);
     });
+
+    test('does not propagate periods to services that did not originally have them', () => {
+        // fullService is the representative (4 periods), subsetService was merged in
+        // via mergeServicesWithSubsetPeriods and only has 3 periods. Editing EV on the
+        // representative must not create an EV entry on subsetService.
+        const groups = [
+            {
+                serviceIds: ['fullService', 'subsetService'],
+                activeDays: ['monday'],
+                hasHolidayService: false,
+                averageTimesByPeriod: {}
+            }
+        ];
+        const localData = {
+            fullService: {
+                AM: [100, 200],
+                MD: [90, 180],
+                PM: [110, 220],
+                EV: [80, 160]
+            },
+            subsetService: {
+                AM: [100, 200],
+                MD: [90, 180],
+                PM: [110, 220]
+            }
+        };
+
+        const expanded = expandGroupedDataToServices(localData, groups);
+
+        expect(Object.keys(expanded.subsetService).sort()).toEqual(['AM', 'MD', 'PM']);
+        expect(expanded.subsetService.EV).toBeUndefined();
+        expect(expanded.fullService.EV).toEqual([80, 160]);
+    });
+
+    test('propagates edited shared periods to the subset service without adding new ones', () => {
+        // User edits AM and EV on the representative. AM is shared, EV is representative-only.
+        // subsetService should receive the AM edits but nothing for EV.
+        const groups = [
+            {
+                serviceIds: ['fullService', 'subsetService'],
+                activeDays: ['monday'],
+                hasHolidayService: false,
+                averageTimesByPeriod: {}
+            }
+        ];
+        const localData = {
+            fullService: {
+                AM: [111, 222],
+                PM: [110, 220],
+                EV: [77, 155]
+            },
+            subsetService: {
+                AM: [100, 200],
+                PM: [110, 220]
+            }
+        };
+
+        const expanded = expandGroupedDataToServices(localData, groups);
+
+        expect(expanded.subsetService.AM).toEqual([111, 222]);
+        expect(expanded.subsetService.PM).toEqual([110, 220]);
+        expect(expanded.subsetService.EV).toBeUndefined();
+    });
 });

packages/transition-frontend/src/components/forms/path/TransitPathSegmentTimesByPeriodModal/useSegmentTimesByPeriod.ts

@@ -31,8 +31,13 @@ import {
 const weekdays = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday'] as const;
 
 const dayKeyMap: Record<string, string> = {
-    monday: 'Mon', tuesday: 'Tue', wednesday: 'Wed', thursday: 'Thu',
-    friday: 'Fri', saturday: 'Sat', sunday: 'Sun'
+    monday: 'Mon',
+    tuesday: 'Tue',
+    wednesday: 'Wed',
+    thursday: 'Thu',
+    friday: 'Fri',
+    saturday: 'Sat',
+    sunday: 'Sun'
 };
 
 /** Build a human-readable label for a service group based on its active days. */