@ticketboothapp/booking 1.2.58 → 1.2.59

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ticketboothapp/booking",
-  "version": "1.2.58",
+  "version": "1.2.59",
   "private": false,
   "sideEffects": [
     "**/*.css",

package/src/components/booking/BookingFlow.tsx

@@ -79,6 +79,16 @@ import type { BookingFlowUiOptions } from './booking-flow-ui';
 import type { ProviderDashboardChangeBookingPayload } from './provider-dashboard-change-booking';
 import { BOOKING_FLOW_ABANDON_EVENT } from '../../providers/booking-dialog-provider';
 
+/**
+ * Change-booking diagnostics in the console on local machines only.
+ * Uses hostname (not NODE_ENV): bundled packages often inline production, so `development` was never true in the browser.
+ */
+function isLocalhostChangeBookingDebug(): boolean {
+  if (typeof window === 'undefined') return false;
+  const h = window.location.hostname;
+  return h === 'localhost' || h === '127.0.0.1' || h === '[::1]' || h.endsWith('.localhost');
+}
+
 /** Live selection snapshot for change-booking compare UI (parent dialog). */
 export interface ChangeFlowSelectionPreview {
   tourName: string;
@@ -143,6 +153,140 @@ function normalizeLineLabelForCompare(label: string): string {
     .trim();
 }
 
+/** Mirrors BookingFlow protected ticket subtotal for a given order summary snapshot. */
+function computeChangeFlowProtectedTicketSubtotalForOrderSummary(
+  sameItinerary: boolean,
+  ticketLineItems: OrderSummary['ticketLineItems'],
+  ticketFloors: Map<string, number>,
+  initialQtyByCat: Map<string, number>,
+): number {
+  if (!sameItinerary) {
+    return ticketLineItems.reduce((sum, line) => sum + Math.max(0, Number(line.itemTotal) || 0), 0);
+  }
+  return ticketLineItems.reduce((sum, line) => {
+    const category = line.category?.trim().toUpperCase();
+    const qty = Math.max(0, Number(line.qty) || 0);
+    if (!category || qty <= 0) return sum;
+    const bookedUnitPrice = ticketFloors.get(category);
+    if (bookedUnitPrice == null) return sum + line.itemTotal;
+    const baselineQty = initialQtyByCat.get(category) ?? 0;
+    const protectedQty = Math.min(qty, baselineQty);
+    const incrementalQty = Math.max(0, qty - baselineQty);
+    const liveUnit = qty > 0 ? Math.max(0, Number(line.itemTotal) || 0) / qty : 0;
+    return sum + protectedQty * bookedUnitPrice + incrementalQty * liveUnit;
+  }, 0);
+}
+
+function computeChangeFlowProtectedFeeSubtotalForOrderSummary(
+  sameItinerary: boolean,
+  totalQuantity: number,
+  feeLineItems: OrderSummary['feeLineItems'],
+  feeFloors: Map<string, number>,
+  initialTicketCount: number,
+): number {
+  if (!sameItinerary || totalQuantity <= 0) {
+    return feeLineItems.reduce((sum, line) => sum + Math.max(0, Number(line.totalAmount) || 0), 0);
+  }
+  const protectedP = Math.min(initialTicketCount, totalQuantity);
+  const incrementalP = Math.max(0, totalQuantity - protectedP);
+  return feeLineItems.reduce((sum, line) => {
+    const key = normalizeLineLabelForCompare(line.name || '');
+    const bookedUnitPrice = key ? feeFloors.get(key) : undefined;
+    if (bookedUnitPrice == null) return sum + line.totalAmount;
+    const liveTotal = Math.max(0, Number(line.totalAmount) || 0);
+    const livePer = totalQuantity > 0 ? liveTotal / totalQuantity : 0;
+    return sum + protectedP * bookedUnitPrice + incrementalP * livePer;
+  }, 0);
+}
+
+function computeChangeFlowProtectedReturnForOrderSummary(
+  sameItinerary: boolean,
+  totalQuantity: number,
+  returnPriceAdjustment: number,
+  returnFloorPerPerson: number | null,
+  initialTicketCount: number,
+  selectedReturnOption: ReturnOption | null,
+  currency: Currency,
+): number {
+  if (!sameItinerary || totalQuantity <= 0) return returnPriceAdjustment;
+  if (returnFloorPerPerson == null) return returnPriceAdjustment;
+  const rawPerPerson = selectedReturnOption?.priceAdjustmentByCurrency?.[currency] ?? 0;
+  const protectedP = Math.min(initialTicketCount, totalQuantity);
+  const incrementalP = Math.max(0, totalQuantity - protectedP);
+  return protectedP * returnFloorPerPerson + incrementalP * rawPerPerson;
+}
+
+function computeChangeFlowEffectiveSubtotalBeforeAddOnsForOrderSummary(
+  isChangeFlow: boolean,
+  sameItinerary: boolean,
+  os: OrderSummary,
+  ticketFloors: Map<string, number>,
+  initialQtyByCat: Map<string, number>,
+  feeFloors: Map<string, number>,
+  initialTicketCount: number,
+  returnFloorPerPerson: number | null,
+  selectedReturnOption: ReturnOption | null,
+  currency: Currency,
+): number {
+  const { subtotal, ticketLineItems, feeLineItems, returnPriceAdjustment, totalQuantity } = os;
+  if (!isChangeFlow || !sameItinerary) return subtotal;
+  const currentTicketSubtotal = ticketLineItems.reduce(
+    (s, l) => s + Math.max(0, Number(l.itemTotal) || 0),
+    0,
+  );
+  const currentFeeSubtotal = feeLineItems.reduce((s, l) => s + Math.max(0, Number(l.totalAmount) || 0), 0);
+  const protectedT = computeChangeFlowProtectedTicketSubtotalForOrderSummary(
+    sameItinerary,
+    ticketLineItems,
+    ticketFloors,
+    initialQtyByCat,
+  );
+  const protectedF = computeChangeFlowProtectedFeeSubtotalForOrderSummary(
+    sameItinerary,
+    totalQuantity,
+    feeLineItems,
+    feeFloors,
+    initialTicketCount,
+  );
+  const protectedR = computeChangeFlowProtectedReturnForOrderSummary(
+    sameItinerary,
+    totalQuantity,
+    returnPriceAdjustment,
+    returnFloorPerPerson,
+    initialTicketCount,
+    selectedReturnOption,
+    currency,
+  );
+  return (
+    subtotal -
+    currentTicketSubtotal -
+    currentFeeSubtotal -
+    returnPriceAdjustment +
+    protectedT +
+    protectedF +
+    protectedR
+  );
+}
+
+/** Matches BookingFlow totalPrice from effectiveSubtotalBeforeAddOns + add-ons + tax − promo. */
+function computeTotalPriceFromEffectiveSubtotalBeforeAddOns(
+  effectiveSubtotalBeforeAddOns: number,
+  addOnTotal: number,
+  effectivePromoDiscountAmount: number,
+  isGiftCard: boolean,
+  isVoucher: boolean,
+  isTaxIncludedInPrice: boolean,
+  pricingConfig: PricingConfig | null,
+): number {
+  const effectiveSubtotal = effectiveSubtotalBeforeAddOns + addOnTotal;
+  const taxOnSubtotal = isTaxIncludedInPrice ? 0 : effectiveSubtotal * (pricingConfig?.taxRate ?? 0);
+  const effectiveTax =
+    effectivePromoDiscountAmount > 0 && !isGiftCard && !isVoucher
+      ? (effectiveSubtotal - effectivePromoDiscountAmount) * (pricingConfig?.taxRate ?? 0)
+      : taxOnSubtotal;
+  return effectiveSubtotal + effectiveTax - effectivePromoDiscountAmount;
+}
+
 function deriveAddOnSelectionsFromReceiptLines(
   addOns: AddOn[],
   lines: Array<{ type?: string; label?: string; amount?: number; quantity?: number }>
@@ -1779,7 +1923,55 @@ export function BookingFlow({
     }
     return Math.max(...product.pickupLocations.map(loc => loc.pickupTimeOffsetMinutes ?? 0));
   }, [product.pickupLocations]);
+  const changeFlowInitialTicketCountForSeatCredit = useMemo(() => {
+    if (!isChangeFlow || !initialValues?.bookingItems?.length) return 0;
+    return initialValues.bookingItems.reduce(
+      (sum, item) => sum + Math.max(0, Number(item.count) || 0),
+      0,
+    );
+  }, [isChangeFlow, initialValues?.bookingItems]);
   
+  const changeFlowSeatCreditForOutboundAvailability = useCallback(
+    (availability: Availability): number => {
+      if (!isChangeFlow || changeFlowInitialTicketCountForSeatCredit <= 0) return 0;
+      const initialAvailabilityId = initialValues?.availabilityId?.trim();
+      const availabilityId = availability.availabilityId?.trim();
+      if (initialAvailabilityId && availabilityId) {
+        return initialAvailabilityId === availabilityId ? changeFlowInitialTicketCountForSeatCredit : 0;
+      }
+      if (!initialValues?.dateTime) return 0;
+      const selectedMs = parseAvailabilityDateTime(availability.dateTime).getTime();
+      const initialMs = parseAvailabilityDateTime(initialValues.dateTime).getTime();
+      if (selectedMs !== initialMs) return 0;
+      const selectedOptionId = availability.productOptionId?.trim() || null;
+      const initialOptionId = initialValues.productOptionId?.trim() || null;
+      if (!selectedOptionId || !initialOptionId) return changeFlowInitialTicketCountForSeatCredit;
+      return selectedOptionId === initialOptionId ? changeFlowInitialTicketCountForSeatCredit : 0;
+    },
+    [
+      isChangeFlow,
+      changeFlowInitialTicketCountForSeatCredit,
+      initialValues?.availabilityId,
+      initialValues?.dateTime,
+      initialValues?.productOptionId,
+    ],
+  );
+  const changeFlowSeatCreditForReturnAvailabilityId = useCallback(
+    (returnAvailabilityId: string | null | undefined): number => {
+      if (!isChangeFlow || changeFlowInitialTicketCountForSeatCredit <= 0) return 0;
+      const initialReturnAvailabilityId = initialValues?.returnAvailabilityId?.trim() || null;
+      const selectedReturnAvailabilityId = returnAvailabilityId?.trim() || null;
+      if (!selectedReturnAvailabilityId) {
+        return initialReturnAvailabilityId == null ? changeFlowInitialTicketCountForSeatCredit : 0;
+      }
+      if (!initialReturnAvailabilityId) return 0;
+      return selectedReturnAvailabilityId === initialReturnAvailabilityId
+        ? changeFlowInitialTicketCountForSeatCredit
+        : 0;
+    },
+    [isChangeFlow, changeFlowInitialTicketCountForSeatCredit, initialValues?.returnAvailabilityId],
+  );
+
   // Calculate pickup times based on availability times + pickup location offset
   interface PickupTimeInfo extends Availability {
     pickupTime: string;
@@ -1802,6 +1994,8 @@ export function BookingFlow({
     return timesForSelectedDate.map(avail => {
       // Parse the dateTime (which should already be in company timezone from backend)
       const availabilityTime = parseISO(avail.dateTime);
+      const vacancyCredit = changeFlowSeatCreditForOutboundAvailability(avail);
+      const adjustedVacancies = Math.max(0, avail.vacancies ?? 0) + vacancyCredit;
       
       // Only apply offset if it's set and > 0 and location is selected
       const pickupTime = (offsetMinutes > 0 && selectedPickupLocation) 
@@ -1822,13 +2016,22 @@ export function BookingFlow({
       
       return {
         ...avail,
+        vacancies: adjustedVacancies,
         pickupTime: pickupTime.toISOString(),
         displayTime,
         originalTime,
         displayTimeRange,
       };
     });
-  }, [selectedDate, selectedPickupLocation, timesForSelectedDate, pickupLocationSkipped, maxTimeOffsetMinutes, companyTimezone]);
+  }, [
+    selectedDate,
+    selectedPickupLocation,
+    timesForSelectedDate,
+    pickupLocationSkipped,
+    maxTimeOffsetMinutes,
+    companyTimezone,
+    changeFlowSeatCreditForOutboundAvailability,
+  ]);
 
   // Check if any pickup time has "most popular" tag (memoized for performance)
   const hasAnyMostPopular = useMemo(() => {
@@ -2134,25 +2337,121 @@ export function BookingFlow({
     return feeUnitByLabel;
   }, [isChangeFlow, originalReceipt?.lineItems, initialValues?.bookingItems]);
 
+  const changeFlowInitialTicketQtyByCategory = useMemo(() => {
+    const qtyByCategory = new Map<string, number>();
+    if (!isChangeFlow || !initialValues?.bookingItems?.length) return qtyByCategory;
+    for (const item of initialValues.bookingItems) {
+      const category = item.category?.trim().toUpperCase();
+      if (!category) continue;
+      qtyByCategory.set(category, Math.max(0, Number(item.count) || 0));
+    }
+    return qtyByCategory;
+  }, [isChangeFlow, initialValues?.bookingItems]);
+  const changeFlowInitialTicketCount = useMemo(() => {
+    let sum = 0;
+    for (const qty of changeFlowInitialTicketQtyByCategory.values()) sum += qty;
+    return sum;
+  }, [changeFlowInitialTicketQtyByCategory]);
+  const changeFlowOutboundMatchesOriginalSelection = useMemo(() => {
+    if (!isChangeFlow || !selectedAvailability || !initialValues?.dateTime) return false;
+    const initialAvailabilityId = initialValues.availabilityId?.trim();
+    const selectedAvailabilityId = selectedAvailability.availabilityId?.trim();
+    const idsMatch =
+      Boolean(initialAvailabilityId && selectedAvailabilityId) &&
+      initialAvailabilityId === selectedAvailabilityId;
+    if (idsMatch) return true;
+    // Same wall time + option after API/list refreshes can carry a new availability row id; still "same" for price floors.
+    const selectedMs = parseAvailabilityDateTime(selectedAvailability.dateTime).getTime();
+    const initialMs = parseAvailabilityDateTime(initialValues.dateTime).getTime();
+    if (selectedMs !== initialMs) return false;
+    const selectedOptionId = selectedAvailability.productOptionId?.trim() || null;
+    const initialOptionId = initialValues.productOptionId?.trim() || null;
+    return !selectedOptionId || !initialOptionId || selectedOptionId === initialOptionId;
+  }, [
+    isChangeFlow,
+    selectedAvailability,
+    initialValues?.availabilityId,
+    initialValues?.dateTime,
+    initialValues?.productOptionId,
+  ]);
+  const changeFlowReturnMatchesOriginalSelection = useMemo(() => {
+    if (!isChangeFlow) return false;
+    const initialReturnAvailabilityId = initialValues?.returnAvailabilityId?.trim() || null;
+    const selectedReturnAvailabilityId = selectedReturnOption?.returnAvailabilityId?.trim() || null;
+    const initialReturnDt = initialValues?.returnDateTime?.trim() || null;
+    const selectedReturnDt = selectedReturnOption?.dateTime?.trim() || null;
+
+    if (!selectedReturnAvailabilityId) {
+      return initialReturnAvailabilityId == null;
+    }
+    if (initialReturnAvailabilityId && selectedReturnAvailabilityId) {
+      if (initialReturnAvailabilityId === selectedReturnAvailabilityId) return true;
+      if (initialReturnDt && selectedReturnDt) {
+        return (
+          parseAvailabilityDateTime(initialReturnDt).getTime() ===
+          parseAvailabilityDateTime(selectedReturnDt).getTime()
+        );
+      }
+      return false;
+    }
+    // Bookings often store returnDateTime without returnAvailabilityId; still the same return if wall times match.
+    if (!initialReturnAvailabilityId && initialReturnDt && selectedReturnDt) {
+      return (
+        parseAvailabilityDateTime(initialReturnDt).getTime() ===
+        parseAvailabilityDateTime(selectedReturnDt).getTime()
+      );
+    }
+    return false;
+  }, [
+    isChangeFlow,
+    initialValues?.returnAvailabilityId,
+    initialValues?.returnDateTime,
+    selectedReturnOption?.returnAvailabilityId,
+    selectedReturnOption?.dateTime,
+  ]);
+  /** Same outbound + return as original booking: incremental seats use live pricing; receipt floors apply only after itinerary changes. */
+  const changeFlowSameItineraryAsOriginalBooking = useMemo(
+    () =>
+      isChangeFlow &&
+      changeFlowOutboundMatchesOriginalSelection &&
+      changeFlowReturnMatchesOriginalSelection,
+    [isChangeFlow, changeFlowOutboundMatchesOriginalSelection, changeFlowReturnMatchesOriginalSelection],
+  );
+
   const returnOptionsWithFloor = useMemo(() => {
     const options = selectedAvailability?.returnOptions ?? [];
-    if (!isChangeFlow || changeFlowReturnUnitFloorPerPerson == null) return options;
+    if (!isChangeFlow && changeFlowReturnUnitFloorPerPerson == null) return options;
     return options.map((opt) => {
+      const vacancyCredit = changeFlowSeatCreditForReturnAvailabilityId(opt.returnAvailabilityId);
+      const adjustedVacancies = Math.max(0, opt.vacancies ?? 0) + vacancyCredit;
       const rawPerPerson = opt.priceAdjustmentByCurrency?.[currency] ?? 0;
-      const flooredPerPerson = Math.max(rawPerPerson, changeFlowReturnUnitFloorPerPerson);
-      if (flooredPerPerson === rawPerPerson) return opt;
+      const applyReturnFloor =
+        changeFlowReturnUnitFloorPerPerson != null && (!isChangeFlow || !changeFlowSameItineraryAsOriginalBooking);
+      const flooredPerPerson = applyReturnFloor
+        ? Math.max(rawPerPerson, changeFlowReturnUnitFloorPerPerson!)
+        : rawPerPerson;
+      if (flooredPerPerson === rawPerPerson && adjustedVacancies === (opt.vacancies ?? 0)) return opt;
       return {
         ...opt,
+        vacancies: adjustedVacancies,
         priceAdjustmentByCurrency: {
           ...(opt.priceAdjustmentByCurrency ?? {}),
           [currency]: flooredPerPerson,
         },
       };
     });
-  }, [selectedAvailability?.returnOptions, isChangeFlow, changeFlowReturnUnitFloorPerPerson, currency]);
+  }, [
+    selectedAvailability?.returnOptions,
+    isChangeFlow,
+    changeFlowReturnUnitFloorPerPerson,
+    changeFlowSameItineraryAsOriginalBooking,
+    currency,
+    changeFlowSeatCreditForReturnAvailabilityId,
+  ]);
 
   const selectedReturnOptionWithFloor = useMemo(() => {
     if (!selectedReturnOption || !isChangeFlow || changeFlowReturnUnitFloorPerPerson == null) return selectedReturnOption;
+    if (changeFlowSameItineraryAsOriginalBooking) return selectedReturnOption;
     const rawPerPerson = selectedReturnOption.priceAdjustmentByCurrency?.[currency] ?? 0;
     const flooredPerPerson = Math.max(rawPerPerson, changeFlowReturnUnitFloorPerPerson);
     if (flooredPerPerson === rawPerPerson) return selectedReturnOption;
@@ -2163,7 +2462,30 @@ export function BookingFlow({
         [currency]: flooredPerPerson,
       },
     };
-  }, [selectedReturnOption, isChangeFlow, changeFlowReturnUnitFloorPerPerson, currency]);
+  }, [
+    selectedReturnOption,
+    isChangeFlow,
+    changeFlowReturnUnitFloorPerPerson,
+    changeFlowSameItineraryAsOriginalBooking,
+    currency,
+  ]);
+
+  const returnOptionForOrderSummary = useMemo(() => {
+    if (isChangeFlow && changeFlowSameItineraryAsOriginalBooking) return selectedReturnOption ?? null;
+    return selectedReturnOptionWithFloor;
+  }, [isChangeFlow, changeFlowSameItineraryAsOriginalBooking, selectedReturnOption, selectedReturnOptionWithFloor]);
+  const effectiveSelectedPickupVacancies = useMemo(() => {
+    if (!selectedAvailability) return 0;
+    const seatCredit = changeFlowSeatCreditForOutboundAvailability(selectedAvailability);
+    return Math.max(0, selectedAvailability.vacancies ?? 0) + seatCredit;
+  }, [selectedAvailability, changeFlowSeatCreditForOutboundAvailability]);
+  const effectiveSelectedReturnVacancies = useMemo(() => {
+    if (!selectedReturnOption) return null;
+    const seatCredit = changeFlowSeatCreditForReturnAvailabilityId(
+      selectedReturnOption.returnAvailabilityId
+    );
+    return Math.max(0, selectedReturnOption.vacancies ?? 0) + seatCredit;
+  }, [selectedReturnOption, changeFlowSeatCreditForReturnAvailabilityId]);
   
   // Ticket prices: use breakdown final price so booking flow total matches the price breakdown. All conversion in mid-layer.
   const pricing = useMemo(() => {
@@ -2257,56 +2579,71 @@ export function BookingFlow({
       computeOrderSummary(
         quantities,
         pricing,
-        selectedReturnOptionWithFloor,
+        returnOptionForOrderSummary,
         pricingConfig ?? null,
         currency,
         hasFees,
         cancellationPolicyId
       ),
-    [quantities, pricing, selectedReturnOptionWithFloor, pricingConfig, currency, hasFees, cancellationPolicyId]
+    [quantities, pricing, returnOptionForOrderSummary, pricingConfig, currency, hasFees, cancellationPolicyId]
   );
-  const { totalQuantity, subtotal, tax, total: totalFromSummary, feeLineItems, returnPriceAdjustment, cancellationPolicyFee, isTaxIncludedInPrice, ticketLineItems } = orderSummary;
-  const changeFlowInitialTicketQtyByCategory = useMemo(() => {
-    const qtyByCategory = new Map<string, number>();
-    if (!isChangeFlow || !initialValues?.bookingItems?.length) return qtyByCategory;
-    for (const item of initialValues.bookingItems) {
-      const category = item.category?.trim().toUpperCase();
-      if (!category) continue;
-      qtyByCategory.set(category, Math.max(0, Number(item.count) || 0));
+
+  /** Initial booking ticket counts on the same pricing grid (for catalog delta vs receipt anchoring). */
+  const changeFlowBaselineQuantitiesForSummary = useMemo((): Record<string, number> => {
+    const next: Record<string, number> = {};
+    for (const rate of pricing) {
+      next[rate.category] = 0;
     }
-    return qtyByCategory;
-  }, [isChangeFlow, initialValues?.bookingItems]);
-  const changeFlowPreserveBookedTicketPricing = useMemo(() => {
-    if (!isChangeFlow || !selectedAvailability || !initialValues?.dateTime) return false;
-    const selectedMs = parseAvailabilityDateTime(selectedAvailability.dateTime).getTime();
-    const initialMs = parseAvailabilityDateTime(initialValues.dateTime).getTime();
-    if (selectedMs !== initialMs) return false;
-    const selectedOptionId = selectedAvailability.productOptionId?.trim() || null;
-    const initialOptionId = initialValues.productOptionId?.trim() || null;
-    // If option IDs are missing, still protect pricing when date/time is unchanged.
-    if (!selectedOptionId || !initialOptionId) return true;
-    return selectedOptionId === initialOptionId;
-  }, [isChangeFlow, selectedAvailability, initialValues?.dateTime, initialValues?.productOptionId]);
+    for (const item of initialValues?.bookingItems ?? []) {
+      const c = item.category?.trim();
+      if (c) next[c] = Math.max(0, Number(item.count) || 0);
+    }
+    return next;
+  }, [pricing, initialValues?.bookingItems]);
+
+  const orderSummaryChangeFlowBaseline: OrderSummary = useMemo(
+    () =>
+      computeOrderSummary(
+        changeFlowBaselineQuantitiesForSummary,
+        pricing,
+        returnOptionForOrderSummary,
+        pricingConfig ?? null,
+        currency,
+        hasFees,
+        cancellationPolicyId
+      ),
+    [
+      changeFlowBaselineQuantitiesForSummary,
+      pricing,
+      returnOptionForOrderSummary,
+      pricingConfig,
+      currency,
+      hasFees,
+      cancellationPolicyId,
+    ],
+  );
+
+  const { totalQuantity, subtotal, tax, total: totalFromSummary, feeLineItems, returnPriceAdjustment, cancellationPolicyFee, isTaxIncludedInPrice, ticketLineItems } = orderSummary;
   const changeFlowProtectedTicketSubtotal = useMemo(() => {
     const currentTicketSubtotal = ticketLineItems.reduce(
       (sum, line) => sum + Math.max(0, Number(line.itemTotal) || 0),
       0,
     );
-    if (!changeFlowPreserveBookedTicketPricing) return currentTicketSubtotal;
+    if (!changeFlowSameItineraryAsOriginalBooking) return currentTicketSubtotal;
     return ticketLineItems.reduce((sum, line) => {
       const category = line.category?.trim().toUpperCase();
       const qty = Math.max(0, Number(line.qty) || 0);
-      const liveUnitPrice = qty > 0 ? line.itemTotal / qty : 0;
       if (!category || qty <= 0) return sum;
       const bookedUnitPrice = changeFlowTicketBookedUnitPriceByCategory.get(category);
       if (bookedUnitPrice == null) return sum + line.itemTotal;
-      const baselineQty = Math.max(0, changeFlowInitialTicketQtyByCategory.get(category) ?? 0);
+      const baselineQty = changeFlowInitialTicketQtyByCategory.get(category) ?? 0;
       const protectedQty = Math.min(qty, baselineQty);
       const incrementalQty = Math.max(0, qty - baselineQty);
-      return sum + protectedQty * bookedUnitPrice + incrementalQty * liveUnitPrice;
+      const liveUnit = qty > 0 ? Math.max(0, Number(line.itemTotal) || 0) / qty : 0;
+      return sum + protectedQty * bookedUnitPrice + incrementalQty * liveUnit;
     }, 0);
   }, [
-    changeFlowPreserveBookedTicketPricing,
+    changeFlowSameItineraryAsOriginalBooking,
     ticketLineItems,
     changeFlowTicketBookedUnitPriceByCategory,
     changeFlowInitialTicketQtyByCategory,
@@ -2314,10 +2651,25 @@ export function BookingFlow({
   /** Round-trip party limit: both legs must fit — use the tighter of outbound vs return vacancies. */
   const effectivePartySizeCap = useMemo(() => {
     if (!selectedAvailability) return 0;
-    const outbound = selectedAvailability.vacancies ?? 0;
+    const outboundSeatCredit =
+      changeFlowOutboundMatchesOriginalSelection && changeFlowInitialTicketCount > 0
+        ? changeFlowInitialTicketCount
+        : 0;
+    const outbound = Math.max(0, selectedAvailability.vacancies ?? 0) + outboundSeatCredit;
     if (selectedReturnOption == null) return outbound;
-    return Math.min(outbound, selectedReturnOption.vacancies ?? 0);
-  }, [selectedAvailability, selectedReturnOption]);
+    const returnSeatCredit =
+      changeFlowReturnMatchesOriginalSelection && changeFlowInitialTicketCount > 0
+        ? changeFlowInitialTicketCount
+        : 0;
+    const returnCap = Math.max(0, selectedReturnOption.vacancies ?? 0) + returnSeatCredit;
+    return Math.min(outbound, returnCap);
+  }, [
+    selectedAvailability,
+    selectedReturnOption,
+    changeFlowInitialTicketCount,
+    changeFlowOutboundMatchesOriginalSelection,
+    changeFlowReturnMatchesOriginalSelection,
+  ]);
 
   const selectedCancellationPolicy = pricingConfig?.cancellationPolicies?.find((p) => p.id === cancellationPolicyId);
   /** Label for display when policy may be forced by promo (not in pricingConfig list). */
@@ -2378,50 +2730,51 @@ export function BookingFlow({
     () => ticketLineItems.reduce((sum, line) => sum + Math.max(0, Number(line.itemTotal) || 0), 0),
     [ticketLineItems],
   );
-  const changeFlowInitialTotalTicketQty = useMemo(() => {
-    let sum = 0;
-    for (const qty of changeFlowInitialTicketQtyByCategory.values()) sum += qty;
-    return sum;
-  }, [changeFlowInitialTicketQtyByCategory]);
+  const changeFlowInitialTotalTicketQty = changeFlowInitialTicketCount;
   const currentFeeSubtotal = useMemo(
     () => feeLineItems.reduce((sum, line) => sum + Math.max(0, Number(line.totalAmount) || 0), 0),
     [feeLineItems],
   );
   const changeFlowProtectedFeeSubtotal = useMemo(() => {
-    if (!changeFlowPreserveBookedTicketPricing || totalQuantity <= 0) return currentFeeSubtotal;
+    if (!changeFlowSameItineraryAsOriginalBooking || totalQuantity <= 0) return currentFeeSubtotal;
+    const initialParty = changeFlowInitialTicketCount;
+    const protectedP = Math.min(initialParty, totalQuantity);
+    const incrementalP = Math.max(0, totalQuantity - protectedP);
     return feeLineItems.reduce((sum, line) => {
       const key = normalizeLineLabelForCompare(line.name || '');
-      const currentUnitPrice = line.totalAmount / totalQuantity;
       const bookedUnitPrice = key ? changeFlowBookedFeeUnitByNormalizedLabel.get(key) : null;
       if (bookedUnitPrice == null) return sum + line.totalAmount;
-      const protectedQty = Math.min(totalQuantity, changeFlowInitialTotalTicketQty);
-      const incrementalQty = Math.max(0, totalQuantity - changeFlowInitialTotalTicketQty);
-      return sum + protectedQty * bookedUnitPrice + incrementalQty * currentUnitPrice;
+      const liveTotal = Math.max(0, Number(line.totalAmount) || 0);
+      const livePer = totalQuantity > 0 ? liveTotal / totalQuantity : 0;
+      return sum + protectedP * bookedUnitPrice + incrementalP * livePer;
     }, 0);
   }, [
-    changeFlowPreserveBookedTicketPricing,
+    changeFlowSameItineraryAsOriginalBooking,
     totalQuantity,
     currentFeeSubtotal,
     feeLineItems,
     changeFlowBookedFeeUnitByNormalizedLabel,
-    changeFlowInitialTotalTicketQty,
+    changeFlowInitialTicketCount,
   ]);
   const changeFlowProtectedReturnAdjustment = useMemo(() => {
-    if (!changeFlowPreserveBookedTicketPricing || totalQuantity <= 0) return returnPriceAdjustment;
+    if (!changeFlowSameItineraryAsOriginalBooking || totalQuantity <= 0) return returnPriceAdjustment;
     if (changeFlowReturnUnitFloorPerPerson == null) return returnPriceAdjustment;
-    const currentUnitPrice = returnPriceAdjustment / totalQuantity;
-    const protectedQty = Math.min(totalQuantity, changeFlowInitialTotalTicketQty);
-    const incrementalQty = Math.max(0, totalQuantity - changeFlowInitialTotalTicketQty);
-    return protectedQty * changeFlowReturnUnitFloorPerPerson + incrementalQty * currentUnitPrice;
+    const rawPerPerson = selectedReturnOption?.priceAdjustmentByCurrency?.[currency] ?? 0;
+    const initialParty = changeFlowInitialTicketCount;
+    const protectedP = Math.min(initialParty, totalQuantity);
+    const incrementalP = Math.max(0, totalQuantity - protectedP);
+    return protectedP * changeFlowReturnUnitFloorPerPerson + incrementalP * rawPerPerson;
   }, [
-    changeFlowPreserveBookedTicketPricing,
+    changeFlowSameItineraryAsOriginalBooking,
     totalQuantity,
     returnPriceAdjustment,
     changeFlowReturnUnitFloorPerPerson,
-    changeFlowInitialTotalTicketQty,
+    changeFlowInitialTicketCount,
+    selectedReturnOption,
+    currency,
   ]);
   const effectiveSubtotalBeforeAddOns =
-    isChangeFlow && changeFlowPreserveBookedTicketPricing
+    isChangeFlow && changeFlowSameItineraryAsOriginalBooking
       ? subtotal -
         currentTicketSubtotal -
         currentFeeSubtotal -
@@ -2713,9 +3066,93 @@ export function BookingFlow({
       ? (effectiveSubtotal - effectivePromoDiscountAmount) * (pricingConfig?.taxRate ?? 0)
       : taxOnSubtotal;
   const totalPrice = effectiveSubtotal + effectiveTax - effectivePromoDiscountAmount;
+  /** Cent-round for change quote only; matches server final rounding and avoids float noise in clientProposedTotal. */
   const changeFlowProposedTotal = isChangeFlow && originalReceipt
-    ? reconcileChangeBookingProposedTotal(totalPrice, originalReceipt.total)
+    ? reconcileChangeBookingProposedTotal(Math.round(totalPrice * 100) / 100, originalReceipt.total)
     : totalPrice;
+
+  const changeFlowBaselineEffectiveSubtotalBeforeAddOns = useMemo(() => {
+    if (!isChangeFlow || !changeFlowSameItineraryAsOriginalBooking) return effectiveSubtotalBeforeAddOns;
+    return computeChangeFlowEffectiveSubtotalBeforeAddOnsForOrderSummary(
+      true,
+      true,
+      orderSummaryChangeFlowBaseline,
+      changeFlowTicketBookedUnitPriceByCategory,
+      changeFlowInitialTicketQtyByCategory,
+      changeFlowBookedFeeUnitByNormalizedLabel,
+      changeFlowInitialTicketCount,
+      changeFlowReturnUnitFloorPerPerson,
+      selectedReturnOption,
+      currency,
+    );
+  }, [
+    isChangeFlow,
+    changeFlowSameItineraryAsOriginalBooking,
+    effectiveSubtotalBeforeAddOns,
+    orderSummaryChangeFlowBaseline,
+    changeFlowTicketBookedUnitPriceByCategory,
+    changeFlowInitialTicketQtyByCategory,
+    changeFlowBookedFeeUnitByNormalizedLabel,
+    changeFlowInitialTicketCount,
+    changeFlowReturnUnitFloorPerPerson,
+    selectedReturnOption,
+    currency,
+  ]);
+
+  const changeFlowBaselineEffectiveSubtotalFull = useMemo(() => {
+    if (!isChangeFlow || !changeFlowSameItineraryAsOriginalBooking) return effectiveSubtotal;
+    return changeFlowBaselineEffectiveSubtotalBeforeAddOns + addOnTotal;
+  }, [
+    isChangeFlow,
+    changeFlowSameItineraryAsOriginalBooking,
+    changeFlowBaselineEffectiveSubtotalBeforeAddOns,
+    addOnTotal,
+    effectiveSubtotal,
+  ]);
+
+  const changeFlowBaselineEffectiveTax = useMemo(() => {
+    if (!isChangeFlow || !changeFlowSameItineraryAsOriginalBooking) return effectiveTax;
+    const es = changeFlowBaselineEffectiveSubtotalFull;
+    const taxOnSubtotal = isTaxIncludedInPrice ? 0 : es * (pricingConfig?.taxRate ?? 0);
+    return effectivePromoDiscountAmount > 0 && !isGiftCard && !isVoucher
+      ? (es - effectivePromoDiscountAmount) * (pricingConfig?.taxRate ?? 0)
+      : taxOnSubtotal;
+  }, [
+    isChangeFlow,
+    changeFlowSameItineraryAsOriginalBooking,
+    changeFlowBaselineEffectiveSubtotalFull,
+    effectiveTax,
+    isTaxIncludedInPrice,
+    pricingConfig?.taxRate,
+    effectivePromoDiscountAmount,
+    isGiftCard,
+    isVoucher,
+  ]);
+
+  const changeFlowBaselineTotalPrice = useMemo(() => {
+    if (!isChangeFlow || !changeFlowSameItineraryAsOriginalBooking) {
+      return totalPrice;
+    }
+    return computeTotalPriceFromEffectiveSubtotalBeforeAddOns(
+      changeFlowBaselineEffectiveSubtotalBeforeAddOns,
+      addOnTotal,
+      effectivePromoDiscountAmount,
+      isGiftCard,
+      isVoucher,
+      isTaxIncludedInPrice,
+      pricingConfig,
+    );
+  }, [
+    isChangeFlow,
+    changeFlowSameItineraryAsOriginalBooking,
+    changeFlowBaselineEffectiveSubtotalBeforeAddOns,
+    addOnTotal,
+    effectivePromoDiscountAmount,
+    isGiftCard,
+    isVoucher,
+    isTaxIncludedInPrice,
+    pricingConfig,
+  ]);
   const changeSelectionDetails = useMemo(() => {
     if (!isChangeFlow || !initialValues) {
       return {
@@ -2885,15 +3322,6 @@ export function BookingFlow({
     showProviderPricingInlineEditor && providerPricingUi?.totalsPreview
       ? providerPricingUi.totalsPreview
       : null;
-  const displayChangeFlowProposedTotal = providerTotalsPreview
-    ? providerTotalsPreview.totalAmount
-    : changeFlowProposedTotal;
-  const displayChangeFlowSubtotal = providerTotalsPreview
-    ? providerTotalsPreview.subtotalBeforeTax
-    : effectiveSubtotal;
-  const displayChangeFlowTax = providerTotalsPreview
-    ? providerTotalsPreview.taxAmount
-    : effectiveTax;
   const providerHasEditedLineOverrides =
     isProviderDashboardChange &&
     providerQuotedLines.some((line) => {
@@ -2921,6 +3349,40 @@ export function BookingFlow({
   const hasEffectiveChangeSelection =
     hasChangeSelection || providerHasEditedLineOverrides || providerHasAdditionalAdjustments;
 
+  /**
+   * Same itinerary: amount owed must be catalog delta from the *initial* party size, anchored to what
+   * was actually paid (`originalReceipt`). Otherwise `totalPrice − receipt.total` includes a bogus gap
+   * whenever list pricing ≠ historical receipt (e.g. ~$703 + real ticket delta).
+   */
+  const changeFlowReceiptAnchoredCatalogTotalRaw =
+    isChangeFlow && originalReceipt && changeFlowSameItineraryAsOriginalBooking
+      ? originalReceipt.total + (totalPrice - changeFlowBaselineTotalPrice)
+      : totalPrice;
+
+  const changeFlowProposedTotalResolved =
+    isChangeFlow && originalReceipt
+      ? reconcileChangeBookingProposedTotal(
+          Math.round(changeFlowReceiptAnchoredCatalogTotalRaw * 100) / 100,
+          originalReceipt.total,
+        )
+      : changeFlowProposedTotal;
+
+  const displayChangeFlowProposedTotal = providerTotalsPreview
+    ? providerTotalsPreview.totalAmount
+    : changeFlowProposedTotalResolved;
+  const displayChangeFlowSubtotal = providerTotalsPreview
+    ? providerTotalsPreview.subtotalBeforeTax
+    : isChangeFlow && originalReceipt && changeFlowSameItineraryAsOriginalBooking
+      ? Math.round(
+          (originalReceipt.subtotal + (effectiveSubtotal - changeFlowBaselineEffectiveSubtotalFull)) * 100,
+        ) / 100
+      : effectiveSubtotal;
+  const displayChangeFlowTax = providerTotalsPreview
+    ? providerTotalsPreview.taxAmount
+    : isChangeFlow && originalReceipt && changeFlowSameItineraryAsOriginalBooking
+      ? Math.round((originalReceipt.tax + (effectiveTax - changeFlowBaselineEffectiveTax)) * 100) / 100
+      : effectiveTax;
+
   const changeFlowClientEstimateDue = originalReceipt
     ? (isProviderDashboardChange
         ? displayChangeFlowProposedTotal - originalReceipt.total
@@ -2928,7 +3390,7 @@ export function BookingFlow({
     : totalPrice;
 
   /**
-   * Amount owed for change flow: same recipe as normal booking — FE `totalPrice` vs original receipt.
+   * Amount owed for change flow: FE proposed total vs original receipt.
    * Quote is still required before submit (session + canProceed); `clientProposedTotal` on quote keeps BE in sync.
    */
   const changeFlowAmountDueRaw = isChangeFlow ? changeFlowClientEstimateDue : totalPrice;
@@ -2939,6 +3401,116 @@ export function BookingFlow({
       })()
     : changeFlowAmountDueRaw;
 
+  useEffect(() => {
+    if (!isChangeFlow || !isLocalhostChangeBookingDebug()) return;
+    const receiptTicketLines =
+      originalReceipt?.lineItems?.filter((l) => (l.type || '').toUpperCase() === 'TICKET') ?? [];
+    const ticketFloors: Record<string, number> = {};
+    changeFlowTicketBookedUnitPriceByCategory.forEach((v, k) => {
+      ticketFloors[k] = v;
+    });
+    const tag = '[viavia change-booking]';
+    // Plain console.log only (no groupCollapsed — those are easy to miss / count as “hidden” in DevTools).
+    console.log(tag, 'itinerary gates', {
+      outboundMatch: changeFlowOutboundMatchesOriginalSelection,
+      returnMatch: changeFlowReturnMatchesOriginalSelection,
+      sameItinerary: changeFlowSameItineraryAsOriginalBooking,
+    });
+    console.log(tag, 'ids & times', {
+      initialAvailabilityId: initialValues?.availabilityId ?? null,
+      selectedAvailabilityId: selectedAvailability?.availabilityId ?? null,
+      initialDateTime: initialValues?.dateTime ?? null,
+      selectedDateTime: selectedAvailability?.dateTime ?? null,
+      initialOptionId: initialValues?.productOptionId ?? null,
+      selectedOptionId: selectedAvailability?.productOptionId ?? null,
+      initialReturnId: initialValues?.returnAvailabilityId ?? null,
+      selectedReturnId: selectedReturnOption?.returnAvailabilityId ?? null,
+      initialReturnDateTime: initialValues?.returnDateTime ?? null,
+      selectedReturnDateTime: selectedReturnOption?.dateTime ?? null,
+    });
+    console.log(tag, 'selection flags', {
+      hasChangeSelection,
+      hasEffectiveChangeSelection,
+      changeFlowNeedsServerPrice,
+      dateChanged: changeSelectionDetails.dateChanged,
+      returnChanged: changeSelectionDetails.returnChanged,
+      optionChanged: changeSelectionDetails.optionChanged,
+      countsChanged: changeSelectionDetails.countsChanged,
+    });
+    console.log(tag, 'promo', {
+      promoFromApi: promoDiscountAmount,
+      lockedPromoFallback: lockedPromoFallbackAmount,
+      effectivePromo: effectivePromoDiscountAmount,
+    });
+    console.log(tag, 'receipt anchor (same itinerary)', {
+      baselineCatalogTotal: changeFlowBaselineTotalPrice,
+      catalogDeltaVsBaseline: totalPrice - changeFlowBaselineTotalPrice,
+      anchoredTotalRaw: changeFlowReceiptAnchoredCatalogTotalRaw,
+      resolvedProposedTotal: changeFlowProposedTotalResolved,
+    });
+    console.log(tag, 'subtotals (live vs protected)', {
+      orderSummarySubtotal: subtotal,
+      currentTicketSubtotal,
+      changeFlowProtectedTicketSubtotal,
+      currentFeeSubtotal,
+      changeFlowProtectedFeeSubtotal,
+      returnPriceAdjustment,
+      changeFlowProtectedReturnAdjustment,
+      effectiveSubtotal,
+      tax: effectiveTax,
+      totalPrice,
+      changeFlowProposedTotal,
+      changeFlowProposedTotalResolved,
+      originalReceiptTotal: originalReceipt?.total ?? null,
+      amountDue: changeFlowAmountDue,
+    });
+    console.log(tag, 'ticket price floors from receipt (empty => live catalog for tickets)', ticketFloors);
+    console.log(tag, 'receipt TICKET lines', receiptTicketLines);
+  }, [
+    isChangeFlow,
+    changeFlowOutboundMatchesOriginalSelection,
+    changeFlowReturnMatchesOriginalSelection,
+    changeFlowSameItineraryAsOriginalBooking,
+    initialValues?.availabilityId,
+    initialValues?.dateTime,
+    initialValues?.productOptionId,
+    initialValues?.returnAvailabilityId,
+    initialValues?.returnDateTime,
+    selectedAvailability?.availabilityId,
+    selectedAvailability?.dateTime,
+    selectedAvailability?.productOptionId,
+    selectedReturnOption?.returnAvailabilityId,
+    selectedReturnOption?.dateTime,
+    hasChangeSelection,
+    hasEffectiveChangeSelection,
+    changeFlowNeedsServerPrice,
+    changeSelectionDetails.dateChanged,
+    changeSelectionDetails.returnChanged,
+    changeSelectionDetails.optionChanged,
+    changeSelectionDetails.countsChanged,
+    subtotal,
+    currentTicketSubtotal,
+    changeFlowProtectedTicketSubtotal,
+    currentFeeSubtotal,
+    changeFlowProtectedFeeSubtotal,
+    returnPriceAdjustment,
+    changeFlowProtectedReturnAdjustment,
+    effectiveSubtotal,
+    effectivePromoDiscountAmount,
+    effectiveTax,
+    totalPrice,
+    changeFlowProposedTotal,
+    originalReceipt?.total,
+    originalReceipt?.lineItems,
+    changeFlowAmountDue,
+    changeFlowTicketBookedUnitPriceByCategory,
+    changeFlowProposedTotalResolved,
+    changeFlowBaselineTotalPrice,
+    changeFlowReceiptAnchoredCatalogTotalRaw,
+    promoDiscountAmount,
+    lockedPromoFallbackAmount,
+  ]);
+
   const changeCheckoutButtonLabel = (() => {
     if (!isChangeFlow) return undefined;
     if (!hasEffectiveChangeSelection) return undefined;
@@ -3039,7 +3611,7 @@ export function BookingFlow({
       dateChanged: changeSelectionDetails.dateChanged,
       ticketsChanged: changeSelectionDetails.ticketsChanged,
       hasChangesFromInitial: changeSelectionDetails.hasChangesFromInitial,
-      selectionTotal: totalPrice,
+      selectionTotal: originalReceipt ? changeFlowProposedTotalResolved : totalPrice,
       selectionCurrency: currency,
     };
   }, [
@@ -3052,6 +3624,8 @@ export function BookingFlow({
     changeSelectionDetails,
     totalPrice,
     currency,
+    originalReceipt,
+    changeFlowProposedTotalResolved,
   ]);
 
   useEffect(() => {
@@ -3087,9 +3661,14 @@ export function BookingFlow({
       return;
     }
     onPricePreviewChange({
-      subtotal: effectiveSubtotal,
-      tax: !isTaxIncludedInPrice ? effectiveTax : 0,
-      total: totalPrice,
+      subtotal: isChangeFlow && originalReceipt ? displayChangeFlowSubtotal : effectiveSubtotal,
+      tax:
+        !isTaxIncludedInPrice
+          ? isChangeFlow && originalReceipt
+            ? displayChangeFlowTax
+            : effectiveTax
+          : 0,
+      total: isChangeFlow && originalReceipt ? changeFlowProposedTotalResolved : totalPrice,
       currency,
     });
   }, [
@@ -3098,9 +3677,14 @@ export function BookingFlow({
     totalQuantity,
     effectiveSubtotal,
     effectiveTax,
-    changeFlowProposedTotal,
+    changeFlowProposedTotalResolved,
+    displayChangeFlowSubtotal,
+    displayChangeFlowTax,
     currency,
     isTaxIncludedInPrice,
+    isChangeFlow,
+    originalReceipt,
+    totalPrice,
   ]);
 
   /** Debounced server quote so CTA + “amount owed” match PaymentIntent; avoids free confirm when FE estimate ≠ BE. */
@@ -3155,7 +3739,13 @@ export function BookingFlow({
             newPassengerCounts: bookingItems,
             // Omit when empty: backend treats [] as "clear all"; missing = preserve stored selections (BookingChangeIntentService).
             ...(addOnSelections.length > 0 ? { newAddOnSelections: addOnSelections } : {}),
-            clientProposedTotal: changeFlowProposedTotal,
+            clientProposedTotal: changeFlowProposedTotalResolved,
+            capacitySeatCredit: {
+              enabled: true,
+              previousPassengerCount: changeFlowInitialTicketCount,
+              previousAvailabilityId: initialValues.availabilityId ?? null,
+              previousReturnAvailabilityId: initialValues.returnAvailabilityId ?? null,
+            },
           });
           if (seq !== changeQuoteRequestSeq.current) return;
           const canProceed = quote.canProceed !== false;
@@ -3200,9 +3790,13 @@ export function BookingFlow({
     selectedReturnOption?.returnAvailabilityId,
     quantities,
     addOnSelections,
+    changeFlowInitialTicketCount,
+    changeFlowProposedTotalResolved,
     totalPrice,
     currency,
     activeOptions,
+    initialValues?.availabilityId,
+    initialValues?.returnAvailabilityId,
   ]);
 
   // Auto-select product option when date is selected: most popular if set, otherwise first available.
@@ -3778,6 +4372,12 @@ export function BookingFlow({
                   additionalAdjustments: providerAdditionalAdjustments,
                 }
               : undefined,
+          capacitySeatCredit: {
+            enabled: true,
+            previousPassengerCount: changeFlowInitialTicketCount,
+            previousAvailabilityId: initialValues?.availabilityId ?? null,
+            previousReturnAvailabilityId: initialValues?.returnAvailabilityId ?? null,
+          },
         });
         setLoading(false);
         return;
@@ -3816,7 +4416,7 @@ export function BookingFlow({
           newReturnAvailabilityId: selectedReturnOption?.returnAvailabilityId ?? null,
           newPassengerCounts: bookingItems,
           ...(addOnSelections.length > 0 ? { newAddOnSelections: addOnSelections } : {}),
-          clientProposedTotal: changeFlowProposedTotal,
+          clientProposedTotal: changeFlowProposedTotalResolved,
         });
         const canProceed = quote.canProceed !== false;
         const quoteCurrency = (quote.currency || currency) as Currency;
@@ -3837,7 +4437,7 @@ export function BookingFlow({
         if (!canProceed) {
           throw new Error(quote.reasonIfBlocked || 'This booking change cannot be completed right now.');
         }
-        const feChangeDue = Math.max(0, changeFlowProposedTotal - (originalReceipt?.total ?? 0));
+        const feChangeDue = Math.max(0, changeFlowProposedTotalResolved - (originalReceipt?.total ?? 0));
         const serverAmountDue =
           quote.amountDueCents != null
             ? Math.max(0, quote.amountDueCents / 100)
@@ -3947,7 +4547,7 @@ export function BookingFlow({
       // Backend will charge totalAmount and store this as the receipt so /manage matches.
       const taxForBreakdown = effectivePromoDiscountAmount > 0 ? effectiveTax : tax;
       const amountDueForCheckout = isCustomerSelfServeChange
-        ? Math.max(0, changeFlowProposedTotal - (originalReceipt?.total ?? 0))
+        ? Math.max(0, changeFlowProposedTotalResolved - (originalReceipt?.total ?? 0))
         : totalPrice;
       const lines = [
         ...ticketLineItems.map((line) => ({
@@ -4236,7 +4836,7 @@ export function BookingFlow({
           isCustomerSelfServeChange && originalReceipt
             ? {
                 previousTotal: originalReceipt.total,
-                newTotal: totalPrice,
+                newTotal: displayChangeFlowProposedTotal,
                 differenceTotal: amountDueForCheckout,
               }
             : undefined,
@@ -4642,11 +5242,9 @@ export function BookingFlow({
               selectedVacancies={effectivePartySizeCap}
               companyTimezone={companyTimezone}
               pickupDateTime={selectedAvailability.dateTime}
-              pickupVacancies={selectedAvailability.vacancies ?? 0}
+              pickupVacancies={effectiveSelectedPickupVacancies}
               returnDateTime={selectedReturnOption?.dateTime ?? null}
-              returnVacancies={
-                selectedReturnOption != null ? (selectedReturnOption.vacancies ?? 0) : null
-              }
+              returnVacancies={effectiveSelectedReturnVacancies}
               resourceCount={selectedReturnOption ? null : (selectedAvailability.resourceCount ?? null)}
               currency={currency}
               locale={locale}

package/src/components/booking/provider-dashboard-change-booking.ts

@@ -22,6 +22,12 @@ export type ProviderDashboardChangeBookingPayload = {
     lineOverrides?: Array<{ lineKey: string; amount: number; reason?: string }>;
     additionalAdjustments?: Array<{ label: string; amount: number }>;
   } | null;
+  capacitySeatCredit?: {
+    enabled: boolean;
+    previousPassengerCount?: number | null;
+    previousAvailabilityId?: string | null;
+    previousReturnAvailabilityId?: string | null;
+  } | null;
 };
 
 /** Seeds the flow when opening provider change-booking (matches TicketBooth `BookingWidget` `initialBooking`). */

package/src/lib/booking/pricing.ts

@@ -413,18 +413,35 @@ export function computeOrderSummary(
 
   const isTaxIncludedInPrice = pricingConfig.currenciesWithTaxIncluded.includes(currency);
 
-  const basePrice = pricing.reduce((sum, rate) => {
-    const qty = quantities[rate.category] ?? 0;
-    return sum + qty * (rate.price ?? 0);
-  }, 0);
+  const round2 = (n: number) => Math.round(n * 100) / 100;
+
+  const ticketLineItems: OrderSummaryTicketLine[] = pricing
+    .map((rate) => {
+      const qty = quantities[rate.category] ?? 0;
+      if (qty === 0) return null;
+      const pricePerUnit = rate.price ?? 0;
+      return {
+        category: rate.category,
+        qty,
+        pricePerUnit,
+        itemTotal: round2(qty * pricePerUnit),
+      };
+    })
+    .filter((line): line is OrderSummaryTicketLine => line != null);
+
+  const basePrice = ticketLineItems.reduce((sum, line) => sum + line.itemTotal, 0);
 
   const perPersonInDisplay = selectedReturnOption?.priceAdjustmentByCurrency?.[currency] ?? 0;
   const returnPriceAdjustment =
-    totalQuantity > 0 && perPersonInDisplay !== 0 ? totalQuantity * perPersonInDisplay : 0;
+    totalQuantity > 0 && perPersonInDisplay !== 0
+      ? round2(totalQuantity * perPersonInDisplay)
+      : 0;
 
   const cancellationPolicyFee =
     cancellationPolicyId && pricingConfig?.cancellationPolicies?.length
-      ? (pricingConfig.cancellationPolicies.find((p) => p.id === cancellationPolicyId)?.feeByCurrency?.[currency] ?? 0)
+      ? round2(
+          pricingConfig.cancellationPolicies.find((p) => p.id === cancellationPolicyId)?.feeByCurrency?.[currency] ?? 0
+        )
       : 0;
 
   const fees = pricingConfig.fees ?? {};
@@ -434,23 +451,14 @@ export function computeOrderSummary(
       ? []
       : Object.entries(byCurrency).map(([name, amountPerPerson]) => ({
           name,
-          totalAmount: totalQuantity * amountPerPerson,
+          totalAmount: round2(totalQuantity * amountPerPerson),
           description: fees[name]?.description,
         }));
 
   const feesTotal = feeLineItems.reduce((s, f) => s + f.totalAmount, 0);
-  const subtotal = basePrice + returnPriceAdjustment + cancellationPolicyFee + feesTotal;
-  const tax = isTaxIncludedInPrice ? 0 : subtotal * pricingConfig.taxRate;
-  const total = subtotal + tax;
-
-  const ticketLineItems: OrderSummaryTicketLine[] = pricing
-    .map((rate) => {
-      const qty = quantities[rate.category] ?? 0;
-      if (qty === 0) return null;
-      const pricePerUnit = rate.price ?? 0;
-      return { category: rate.category, qty, pricePerUnit, itemTotal: qty * pricePerUnit };
-    })
-    .filter((line): line is OrderSummaryTicketLine => line != null);
+  const subtotal = round2(basePrice + returnPriceAdjustment + cancellationPolicyFee + feesTotal);
+  const tax = isTaxIncludedInPrice ? 0 : round2(subtotal * pricingConfig.taxRate);
+  const total = round2(subtotal + tax);
 
   return {
     subtotal,

package/src/lib/booking-api.ts

@@ -838,6 +838,13 @@ export interface ChangeBookingQuoteRequest {
   newAddOnSelections?: Array<{ addOnId: string; variantId?: string; quantity?: number }>;
   /** Full new-booking total shown in the UI; server verifies within tolerance then uses this for the session so charge matches screen. */
   clientProposedTotal?: number;
+  /** Optional change-flow capacity hint so API can exclude current booking seats from sold counts. */
+  capacitySeatCredit?: {
+    enabled: boolean;
+    previousPassengerCount?: number | null;
+    previousAvailabilityId?: string | null;
+    previousReturnAvailabilityId?: string | null;
+  } | null;
 }
 
 export interface ChangeBookingQuoteReceipt {