@ticketboothapp/booking 1.2.56 → 1.2.59

package/src/components/booking/BookingFlow.tsx

@@ -76,8 +76,19 @@ import { getItineraryStepLabel } from '../../lib/booking/itinerary-display';
 import { MANAGE_BOOKING_FROM_CHANGE_PAYMENT, MANAGE_BOOKING_QUERY_FROM } from '../../lib/manage-booking-post-checkout';
 import { useBookingHost } from '../../runtime';
 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;
@@ -134,6 +145,148 @@ function extractTrailingQty(label: string): { baseLabel: string; qty: number } {
   return { baseLabel, qty };
 }
 
+function normalizeLineLabelForCompare(label: string): string {
+  return label
+    .toLowerCase()
+    .replace(/\([^)]*\)/g, '')
+    .replace(/[^a-z0-9]+/g, '')
+    .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 }>
@@ -308,6 +461,11 @@ interface BookingFlowProps {
   availabilityPricingProfileId?: string | null;
   /** When set (e.g. partner portal), get-availabilities filters cancellation policies by this profile. */
   availabilityCancellationPolicyProfileId?: string | null;
+  /**
+   * Provider dashboard: with `mode="change"`, submit via this callback instead of customer self-serve
+   * quote and payment (`quoteChangeBooking`, Stripe).
+   */
+  onChangeBooking?: (data: ProviderDashboardChangeBookingPayload) => Promise<void>;
 }
 
 function parseAvailabilityDateTime(value: string): Date {
@@ -602,7 +760,18 @@ export function BookingFlow({
   partnerPortalBooking = false,
   availabilityPricingProfileId,
   availabilityCancellationPolicyProfileId,
+  onChangeBooking,
 }: BookingFlowProps) {
+  const isManualOverrideEligibleLine = (line: { editable: boolean; type?: string; label?: string }): boolean => {
+    if (!line.editable) return false;
+    const type = (line.type ?? '').toUpperCase();
+    const label = (line.label ?? '').toLowerCase();
+    const isPromoLikeType =
+      type.includes('PROMO') || type.includes('DISCOUNT') || type.includes('VOUCHER') || type.includes('GIFT');
+    const isPromoLikeLabel =
+      label.includes('promo') || label.includes('discount') || label.includes('voucher') || label.includes('gift');
+    return !(isPromoLikeType || isPromoLikeLabel);
+  };
   const { env, strings: defaultStrings, analytics, catalog } = useBookingHost();
   const { t } = useTranslations();
   const { locale } = useLocale();
@@ -638,6 +807,8 @@ export function BookingFlow({
     changeWindowHoursBefore?: number | null;
   } | null>(null);
   const cancellationPolicyRef = useRef<HTMLDivElement>(null);
+  /** Dedupe parent updates from `onChangeFlowSelectionPreview` when serialized preview is unchanged. */
+  const lastChangeFlowPreviewKeyRef = useRef<string | null>(null);
   const [promoCodeValidating, setPromoCodeValidating] = useState(false);
   const [pickupLocationId, setPickupLocationId] = useState<string | null>(null);
   const [pickupLocationSkipped, setPickupLocationSkipped] = useState(false);
@@ -739,6 +910,8 @@ export function BookingFlow({
   const hasAutoSelectedPartnerPickupRef = useRef(false);
   const handleDateSelectRef = useRef<(date: string) => void>(() => {});
   const isChangeFlow = mode === 'change';
+  const isProviderDashboardChange = Boolean(onChangeBooking);
+  const isCustomerSelfServeChange = isChangeFlow && !isProviderDashboardChange;
 
   useEffect(() => {
     setPartnerAttributionConfirmed(false);
@@ -748,12 +921,14 @@ export function BookingFlow({
    * user picks a different return time — baseline is the first auto-selected return for this outbound.
    */
   const [implicitReturnBaselineId, setImplicitReturnBaselineId] = useState<string | null>(null);
-  const lockedPromoCode = isChangeFlow
-    ? (initialValues?.promoCode?.trim().toUpperCase() || null)
-    : null;
-  /** Change booking: cannot reduce tickets below original counts (can still decrease after increasing). */
+  /** Any change flow (self-serve or provider): promo from booking is fixed — show read-only, never add new. */
+  const lockedPromoCode =
+    isChangeFlow && initialValues?.promoCode?.trim()
+      ? initialValues.promoCode.trim().toUpperCase()
+      : null;
+  /** Public self-serve only: cannot reduce tickets below original counts. */
   const changeBookingMinimumQuantities = useMemo(() => {
-    if (!isChangeFlow || !initialValues?.bookingItems?.length) return undefined;
+    if (!isCustomerSelfServeChange || !initialValues?.bookingItems?.length) return undefined;
     const m: Record<string, number> = {};
     for (const item of initialValues.bookingItems) {
       const key = item.category?.trim();
@@ -761,7 +936,7 @@ export function BookingFlow({
       m[key] = Math.max(0, Number(item.count) || 0);
     }
     return m;
-  }, [isChangeFlow, initialValues?.bookingItems]);
+  }, [isCustomerSelfServeChange, initialValues?.bookingItems]);
   const [adminChoiceData, setAdminChoiceData] = useState<{
     reservationReference: string;
     reservationExpiration?: string;
@@ -1671,27 +1846,27 @@ export function BookingFlow({
 
   const initialAddOnMinQtyByKey = useMemo(() => {
     const map = new Map<string, number>();
-    if (!isChangeFlow) return map;
+    if (!isCustomerSelfServeChange) return map;
     for (const sel of initialAddOnBaselineSelections) {
       const key = `${sel.addOnId.trim()}::${sel.variantId?.trim() || ''}`;
       map.set(key, (map.get(key) ?? 0) + Math.max(1, Number(sel.quantity) || 1));
     }
     return map;
-  }, [isChangeFlow, initialAddOnBaselineSelections]);
+  }, [isCustomerSelfServeChange, initialAddOnBaselineSelections]);
 
   const initialAddOnMinTotalByAddOnId = useMemo(() => {
     const map = new Map<string, number>();
-    if (!isChangeFlow) return map;
+    if (!isCustomerSelfServeChange) return map;
     for (const sel of initialAddOnBaselineSelections) {
       const addOnId = sel.addOnId.trim();
       map.set(addOnId, (map.get(addOnId) ?? 0) + Math.max(1, Number(sel.quantity) || 1));
     }
     return map;
-  }, [isChangeFlow, initialAddOnBaselineSelections]);
+  }, [isCustomerSelfServeChange, initialAddOnBaselineSelections]);
 
   const applyChangeFlowAddOnFloor = useCallback(
     (nextSelections: Array<{ addOnId: string; variantId?: string; quantity?: number }>) => {
-      if (!isChangeFlow || initialAddOnMinQtyByKey.size === 0) return nextSelections;
+      if (!isCustomerSelfServeChange || initialAddOnMinQtyByKey.size === 0) return nextSelections;
       const qtyByKey = new Map<string, number>();
       for (const sel of nextSelections) {
         const key = `${sel.addOnId.trim()}::${sel.variantId?.trim() || ''}`;
@@ -1718,7 +1893,7 @@ export function BookingFlow({
         return { addOnId, variantId, quantity: qty };
       });
     },
-    [isChangeFlow, initialAddOnMinQtyByKey, initialAddOnMinTotalByAddOnId]
+    [isCustomerSelfServeChange, initialAddOnMinQtyByKey, initialAddOnMinTotalByAddOnId]
   );
 
   const updateAddOnSelections = useCallback(
@@ -1748,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;
@@ -1771,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) 
@@ -1791,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(() => {
@@ -2042,7 +2276,7 @@ export function BookingFlow({
     [pricingConfig?.fees]
   );
 
-  const changeFlowTicketPriceFloorByCategory = useMemo(() => {
+  const changeFlowTicketBookedUnitPriceByCategory = useMemo(() => {
     if (!isChangeFlow || !originalReceipt?.lineItems?.length) return new Map<string, number>();
     const amountByCategory = new Map<string, number>();
     const qtyByCategory = new Map<string, number>();
@@ -2083,26 +2317,141 @@ export function BookingFlow({
     if (totalAmount <= 0 || totalQty <= 0) return null;
     return totalAmount / totalQty;
   }, [isChangeFlow, originalReceipt?.lineItems, initialValues?.bookingItems]);
+  const changeFlowBookedFeeUnitByNormalizedLabel = useMemo(() => {
+    const feeUnitByLabel = new Map<string, number>();
+    if (!isChangeFlow || !originalReceipt?.lineItems?.length) return feeUnitByLabel;
+    const fallbackBookedQty =
+      (initialValues?.bookingItems ?? []).reduce((sum, item) => sum + Math.max(0, Number(item.count) || 0), 0);
+    for (const line of originalReceipt.lineItems) {
+      const type = (line.type || '').trim().toUpperCase();
+      if (!line.label || type === 'TICKET' || type === 'RETURN_OPTION' || type === 'TAX') continue;
+      if (type.includes('PROMO') || type.includes('VOUCHER') || type.includes('GIFT')) continue;
+      const amount = Number(line.amount ?? 0);
+      const qtyRaw = Number(line.quantity ?? 0);
+      const qty = qtyRaw > 0 ? qtyRaw : fallbackBookedQty;
+      if (!Number.isFinite(amount) || !Number.isFinite(qty) || amount <= 0 || qty <= 0) continue;
+      const key = normalizeLineLabelForCompare(line.label);
+      if (!key) continue;
+      feeUnitByLabel.set(key, amount / qty);
+    }
+    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;
@@ -2113,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(() => {
@@ -2156,13 +2528,11 @@ export function BookingFlow({
       const backendInDisplayCurrency = rate.priceByCurrency?.[currency] ?? (currency === 'CAD' ? backendPriceCAD : 0);
       const baseInDisplayCurrency = getBaseInDisplayCurrency(rate.category);
       const built = buildRate(rate.category, backendPriceCAD, backendInDisplayCurrency, baseInDisplayCurrency, rate.appliedAdjustments ?? rate.applied_adjustments ?? []);
-      const floorUnitPrice = changeFlowTicketPriceFloorByCategory.get(rate.category.toUpperCase());
-      const price = floorUnitPrice != null ? Math.max(built.price, floorUnitPrice) : built.price;
       return {
         category: rate.category,
         rateId: rate.rateId || rate.category,
         available: rate.available,
-        price,
+        price: built.price,
         priceCAD: built.priceCAD,
         baseInDisplayCurrency: built.baseInDisplayCurrency,
         appliedAdjustments: built.appliedAdjustments,
@@ -2172,19 +2542,17 @@ export function BookingFlow({
       const baseInDisplayCurrency = getBaseInDisplayCurrency(p.category);
       const backendInDisplayCurrency = currency === 'CAD' ? priceCADFromApi : 0;
       const built = buildRate(p.category, priceCADFromApi, backendInDisplayCurrency, baseInDisplayCurrency, []);
-      const floorUnitPrice = changeFlowTicketPriceFloorByCategory.get(p.category.toUpperCase());
-      const price = floorUnitPrice != null ? Math.max(built.price, floorUnitPrice) : built.price;
       return {
         category: p.category,
         rateId: p.category,
         available: selectedAvailability.vacancies,
-        price,
+        price: built.price,
         priceCAD: built.priceCAD,
         baseInDisplayCurrency: built.baseInDisplayCurrency,
         appliedAdjustments: built.appliedAdjustments,
       };
     }) || [];
-  }, [selectedAvailability, currency, hasFees, pricingConfig, precomputedPricesByOption, activeOptions, isSimplifiedPricingView, changeFlowTicketPriceFloorByCategory]);
+  }, [selectedAvailability, currency, hasFees, pricingConfig, precomputedPricesByOption, activeOptions, isSimplifiedPricingView]);
 
   // Price breakdown: mid-layer returns line items (base + one per rule/deal). UI renders each line; rate in brackets when used.
   const getPriceBreakdown = useCallback((category: string, priceCAD: number, baseInDisplayCurrency: number | undefined, appliedAdjustments: Array<{ type: string; id: string; name: string; changeByCurrency?: Record<string, number> }> = []): PriceBreakdownData | null => {
@@ -2211,22 +2579,97 @@ 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]
   );
+
+  /** 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;
+    }
+    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 (!changeFlowSameItineraryAsOriginalBooking) return currentTicketSubtotal;
+    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 = changeFlowTicketBookedUnitPriceByCategory.get(category);
+      if (bookedUnitPrice == null) return sum + line.itemTotal;
+      const baselineQty = changeFlowInitialTicketQtyByCategory.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);
+  }, [
+    changeFlowSameItineraryAsOriginalBooking,
+    ticketLineItems,
+    changeFlowTicketBookedUnitPriceByCategory,
+    changeFlowInitialTicketQtyByCategory,
+  ]);
   /** 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). */
@@ -2283,7 +2726,64 @@ export function BookingFlow({
   }, [addOnSelections, addOns]);
 
   // Effective subtotal includes add-ons (for promo discount and total)
-  const effectiveSubtotal = subtotal + addOnTotal;
+  const currentTicketSubtotal = useMemo(
+    () => ticketLineItems.reduce((sum, line) => sum + Math.max(0, Number(line.itemTotal) || 0), 0),
+    [ticketLineItems],
+  );
+  const changeFlowInitialTotalTicketQty = changeFlowInitialTicketCount;
+  const currentFeeSubtotal = useMemo(
+    () => feeLineItems.reduce((sum, line) => sum + Math.max(0, Number(line.totalAmount) || 0), 0),
+    [feeLineItems],
+  );
+  const changeFlowProtectedFeeSubtotal = useMemo(() => {
+    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 bookedUnitPrice = key ? changeFlowBookedFeeUnitByNormalizedLabel.get(key) : null;
+      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);
+  }, [
+    changeFlowSameItineraryAsOriginalBooking,
+    totalQuantity,
+    currentFeeSubtotal,
+    feeLineItems,
+    changeFlowBookedFeeUnitByNormalizedLabel,
+    changeFlowInitialTicketCount,
+  ]);
+  const changeFlowProtectedReturnAdjustment = useMemo(() => {
+    if (!changeFlowSameItineraryAsOriginalBooking || totalQuantity <= 0) return returnPriceAdjustment;
+    if (changeFlowReturnUnitFloorPerPerson == null) return returnPriceAdjustment;
+    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;
+  }, [
+    changeFlowSameItineraryAsOriginalBooking,
+    totalQuantity,
+    returnPriceAdjustment,
+    changeFlowReturnUnitFloorPerPerson,
+    changeFlowInitialTicketCount,
+    selectedReturnOption,
+    currency,
+  ]);
+  const effectiveSubtotalBeforeAddOns =
+    isChangeFlow && changeFlowSameItineraryAsOriginalBooking
+      ? subtotal -
+        currentTicketSubtotal -
+        currentFeeSubtotal -
+        returnPriceAdjustment +
+        changeFlowProtectedTicketSubtotal +
+        changeFlowProtectedFeeSubtotal +
+        changeFlowProtectedReturnAdjustment
+      : subtotal;
+  const effectiveSubtotal = effectiveSubtotalBeforeAddOns + addOnTotal;
 
   /** Stable signature for promo discount API (avoid effect re-fire on object identity churn). */
   const quantitiesSignature = useMemo(
@@ -2315,6 +2815,30 @@ export function BookingFlow({
     return [...feeLineItems, ...addOnLines];
   }, [feeLineItems, addOnSelections, addOns]);
 
+  const providerPricingUi = flowUi?.providerDashboardChangePricingUi;
+  const providerQuotedLines = providerPricingUi?.quotedLines ?? [];
+  const providerEditableLines = providerQuotedLines.filter((line) => isManualOverrideEligibleLine(line));
+  const showProviderPricingInlineEditor =
+    isProviderDashboardChange && isAdmin && isChangeFlow && (
+      providerPricingUi?.loading ||
+      providerPricingUi?.error != null ||
+      providerQuotedLines.length > 0
+    );
+  const normalizeReceiptLabel = (value: string): string =>
+    value
+      .toLowerCase()
+      .replace(/\([^)]*\)/g, '')
+      .replace(/[^a-z0-9]+/g, '')
+      .trim();
+  const providerEditableLineByNormalizedLabel = useMemo(() => {
+    const m = new Map<string, (typeof providerEditableLines)[number]>();
+    for (const line of providerEditableLines) {
+      const key = normalizeReceiptLabel(line.label ?? '');
+      if (key) m.set(key, line);
+    }
+    return m;
+  }, [providerEditableLines]);
+
   const checkoutPriceSummaryLines = useMemo((): PriceSummaryLine[] => {
     if (!selectedAvailability) return [];
     return [
@@ -2328,6 +2852,13 @@ export function BookingFlow({
         );
         return {
           kind: 'ticket',
+          lineKey:
+            showProviderPricingInlineEditor
+              ? providerEditableLineByNormalizedLabel.get(normalizeReceiptLabel(line.category))?.lineKey
+              : undefined,
+          editable:
+            showProviderPricingInlineEditor &&
+            providerEditableLineByNormalizedLabel.has(normalizeReceiptLabel(line.category)),
           category: line.category,
           qty: line.qty,
           itemTotal: line.itemTotal,
@@ -2362,6 +2893,25 @@ export function BookingFlow({
             fee.name.toLowerCase().includes('license'));
         return {
           kind: 'line' as const,
+          lineKey:
+            showProviderPricingInlineEditor
+              ? providerEditableLineByNormalizedLabel.get(
+                  normalizeReceiptLabel(
+                    feeLineItems.some((f) => f.name === fee.name)
+                      ? `${fee.name} (${totalQuantity} ${totalQuantity === 1 ? 'person' : 'people'})`
+                      : fee.name
+                  )
+                )?.lineKey
+              : undefined,
+          editable:
+            showProviderPricingInlineEditor &&
+            providerEditableLineByNormalizedLabel.has(
+              normalizeReceiptLabel(
+                feeLineItems.some((f) => f.name === fee.name)
+                  ? `${fee.name} (${totalQuantity} ${totalQuantity === 1 ? 'person' : 'people'})`
+                  : fee.name
+              )
+            ),
           label: feeLineItems.some((f) => f.name === fee.name)
             ? `${fee.name} (${totalQuantity} ${totalQuantity === 1 ? 'person' : 'people'})`
             : fee.name,
@@ -2388,6 +2938,8 @@ export function BookingFlow({
     effectiveCancellationPolicyLabel,
     feeLineItemsWithAddOns,
     feeLineItems,
+    showProviderPricingInlineEditor,
+    providerEditableLineByNormalizedLabel,
   ]);
 
   // Promo discount from backend (order-level only; rates are pre-promo)
@@ -2514,15 +3066,119 @@ 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 { hasChangesFromInitial: true, dateChanged: false, ticketsChanged: false };
+      return {
+        hasChangesFromInitial: true,
+        hasOperationalChangesFromInitial: true,
+        dateChanged: false,
+        ticketsChanged: false,
+        optionChanged: false,
+        pickupChanged: false,
+        countsChanged: false,
+        addOnsChanged: false,
+        returnChanged: false,
+      };
     }
     if (!selectedAvailability) {
-      return { hasChangesFromInitial: false, dateChanged: false, ticketsChanged: false };
+      return {
+        hasChangesFromInitial: false,
+        hasOperationalChangesFromInitial: false,
+        dateChanged: false,
+        ticketsChanged: false,
+        optionChanged: false,
+        pickupChanged: false,
+        countsChanged: false,
+        addOnsChanged: false,
+        returnChanged: false,
+      };
     }
     const initialMs = initialValues.dateTime ? parseAvailabilityDateTime(initialValues.dateTime).getTime() : null;
     const selectedMs = parseAvailabilityDateTime(selectedAvailability.dateTime).getTime();
@@ -2534,7 +3190,13 @@ export function BookingFlow({
     const optionChanged = Boolean(
       initialOpt && selectedOpt && initialOpt !== selectedOpt
     );
-    const pickupChanged = (initialValues.pickupLocationId ?? null) !== (pickupLocationId ?? null);
+    const normalizePickupId = (value: string | null | undefined) => {
+      const trimmed = value?.trim();
+      return trimmed ? trimmed : null;
+    };
+    const pickupChanged =
+      normalizePickupId(initialValues.pickupLocationId ?? null) !==
+      normalizePickupId(pickupLocationId ?? null);
     const normalizeCounts = (items: Array<{ category: string; count: number }> | null | undefined) => {
       const map = new Map<string, number>();
       for (const item of items ?? []) {
@@ -2580,7 +3242,16 @@ export function BookingFlow({
     let returnChanged = false;
     if (hasReturnOptions && selectedReturnOption) {
       if (initialReturnId && selectedReturnId) {
-        returnChanged = initialReturnId !== selectedReturnId;
+        if (initialReturnId === selectedReturnId) {
+          returnChanged = false;
+        } else if (initialReturnDt && selectedReturnDt) {
+          // Some refreshes can rotate return availability IDs for the same departure time.
+          returnChanged =
+            parseAvailabilityDateTime(initialReturnDt).getTime() !==
+            parseAvailabilityDateTime(selectedReturnDt).getTime();
+        } else {
+          returnChanged = true;
+        }
       } else if (initialReturnDt && selectedReturnDt) {
         returnChanged =
           parseAvailabilityDateTime(initialReturnDt).getTime() !==
@@ -2597,9 +3268,22 @@ export function BookingFlow({
         countsChanged ||
         addOnsChanged ||
         returnChanged,
+      // Authoritative for "real user change" gating in provider dashboard:
+      // ignore option-id noise and only consider user-visible booking deltas.
+      hasOperationalChangesFromInitial:
+        dateChanged ||
+        pickupChanged ||
+        countsChanged ||
+        addOnsChanged ||
+        returnChanged,
       dateChanged,
       // Tickets line corresponds to "option + ticket counts"; add-ons and pickup changes affect itinerary but not the ticket label.
       ticketsChanged: Boolean(optionChanged || countsChanged),
+      optionChanged,
+      pickupChanged,
+      countsChanged,
+      addOnsChanged,
+      returnChanged,
     };
   }, [
     isChangeFlow,
@@ -2612,38 +3296,232 @@ export function BookingFlow({
     addOnSelections,
     initialAddOnMinQtyByKey,
   ]);
-  const hasChangeSelection = changeSelectionDetails.hasChangesFromInitial;
+  const hasChangeSelection =
+    isProviderDashboardChange
+      ? changeSelectionDetails.hasOperationalChangesFromInitial
+      : changeSelectionDetails.hasChangesFromInitial;
 
   const changeFlowNeedsServerPrice =
-    isChangeFlow &&
+    isCustomerSelfServeChange &&
     hasChangeSelection &&
     !!initialValues?.bookingReference?.trim() &&
     !!lastName.trim();
 
-  const isChangeQuoteBlocked = isChangeFlow && latestChangeQuote?.canProceed === false;
-  const requiresReturnInChangeFlow = isChangeFlow && !!initialValues?.returnAvailabilityId?.trim();
+  const isChangeQuoteBlocked = isCustomerSelfServeChange && latestChangeQuote?.canProceed === false;
+  const requiresReturnInChangeFlow = isCustomerSelfServeChange && !!initialValues?.returnAvailabilityId?.trim();
   const missingRequiredReturnSelection = requiresReturnInChangeFlow && !selectedReturnOption;
 
   const changeFlowSubmitDisabled =
     isChangeFlow &&
     (missingRequiredReturnSelection ||
-      (changeFlowNeedsServerPrice && (changeQuoteLoading || (!latestChangeQuote && !changeQuoteFetchError))));
+      (isCustomerSelfServeChange &&
+        changeFlowNeedsServerPrice &&
+        (changeQuoteLoading || (!latestChangeQuote && !changeQuoteFetchError))));
+
+  const providerTotalsPreview =
+    showProviderPricingInlineEditor && providerPricingUi?.totalsPreview
+      ? providerPricingUi.totalsPreview
+      : null;
+  const providerHasEditedLineOverrides =
+    isProviderDashboardChange &&
+    providerQuotedLines.some((line) => {
+      if (!isManualOverrideEligibleLine(line)) return false;
+      const raw = providerPricingUi?.lineAmountInputs?.[line.lineKey];
+      const parsed = raw == null || raw.trim() === '' ? line.amount : Number(raw);
+      if (!Number.isFinite(parsed)) return false;
+      const rounded = Math.round(parsed * 100) / 100;
+      return Math.abs(rounded - line.amount) > 0.0001;
+    });
+  const providerHasAdditionalAdjustments =
+    isProviderDashboardChange &&
+    (providerPricingUi?.additionalAdjustments ?? []).some((adj) => {
+      const parsed = Number((adj.amountInput ?? '').trim());
+      const hasAmount = Number.isFinite(parsed) && parsed > 0;
+      const currentAmount = hasAmount ? (Math.round(parsed * 100) / 100).toFixed(2) : '';
+      const originalAmount = adj.originalAmountInput ?? '';
+      const currentLabel = (adj.label ?? '').trim();
+      const originalLabel = (adj.originalLabel ?? '').trim();
+      const currentMode = adj.mode;
+      const originalMode = adj.originalMode;
+      if (!originalMode) return hasAmount || currentLabel.length > 0;
+      return currentAmount !== originalAmount || currentLabel !== originalLabel || currentMode !== originalMode;
+    });
+  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
-    ? Math.max(changeFlowProposedTotal - originalReceipt.total, 0)
+    ? (isProviderDashboardChange
+        ? displayChangeFlowProposedTotal - originalReceipt.total
+        : Math.max(displayChangeFlowProposedTotal - originalReceipt.total, 0))
     : 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;
-  const changeFlowAmountDue =
-    isChangeFlow ? Math.round(changeFlowAmountDueRaw * 100) / 100 : changeFlowAmountDueRaw;
+  const changeFlowAmountDue = isChangeFlow
+    ? (() => {
+        const rounded = Math.round(changeFlowAmountDueRaw * 100) / 100;
+        return Math.abs(rounded) < 0.01 ? 0 : rounded;
+      })()
+    : 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 (!hasChangeSelection) return undefined;
+    if (!hasEffectiveChangeSelection) return undefined;
+    if (isProviderDashboardChange) {
+      const est = Math.round(changeFlowClientEstimateDue * 100) / 100;
+      return est > 0
+        ? `Change booking (${formatCurrencyAmount(est, currency, locale as 'en' | 'fr')})`
+        : est < 0
+          ? `Change booking (${formatCurrencyAmount(est, currency, locale as 'en' | 'fr')})`
+          : 'Change booking (no charge)';
+    }
     if (changeFlowNeedsServerPrice) {
       if (changeQuoteLoading) {
         const tr = t('booking.updatingPrice');
@@ -2679,8 +3557,39 @@ export function BookingFlow({
   const checkoutFormError =
     (error || '') ||
     (missingRequiredReturnSelection ? 'Removing return option in self-serve is not available. Please contact support.' : '') ||
-    (isChangeQuoteBlocked ? (latestChangeQuote?.reasonIfBlocked ?? '') : '') ||
-    (changeQuoteFetchError ?? '');
+    (isCustomerSelfServeChange && isChangeQuoteBlocked ? (latestChangeQuote?.reasonIfBlocked ?? '') : '') ||
+    (isCustomerSelfServeChange ? changeQuoteFetchError ?? '' : '');
+
+  const providerPricingOverrides =
+    isProviderDashboardChange && providerQuotedLines.length > 0
+      ? providerQuotedLines
+          .filter((line) => isManualOverrideEligibleLine(line))
+          .map((line) => {
+            const raw = providerPricingUi?.lineAmountInputs?.[line.lineKey];
+            const parsed = raw == null || raw.trim() === '' ? line.amount : Number(raw);
+            if (!Number.isFinite(parsed)) return null;
+            const rounded = Math.round(parsed * 100) / 100;
+            return Math.abs(rounded - line.amount) > 0.0001
+              ? { lineKey: line.lineKey, amount: rounded, reason: 'Provider dashboard override' }
+              : null;
+          })
+          .filter((v): v is { lineKey: string; amount: number; reason: string } => v != null)
+      : [];
+  const providerAdditionalAdjustments =
+    isProviderDashboardChange
+      ? (providerPricingUi?.additionalAdjustments ?? [])
+          .map((adj) => {
+            const parsed = Number((adj.amountInput ?? '').trim());
+            if (!Number.isFinite(parsed) || parsed <= 0) return null;
+            const rounded = Math.round(parsed * 100) / 100;
+            const signed = adj.mode === 'DISCOUNT' ? -rounded : rounded;
+            return {
+              label: adj.label?.trim() || (signed < 0 ? 'Provider discount' : 'Provider charge'),
+              amount: signed,
+            };
+          })
+          .filter((v): v is { label: string; amount: number } => v != null)
+      : [];
 
   const changeFlowSelectionPreview = useMemo((): ChangeFlowSelectionPreview | null => {
     if (!isChangeFlow) return null;
@@ -2702,7 +3611,7 @@ export function BookingFlow({
       dateChanged: changeSelectionDetails.dateChanged,
       ticketsChanged: changeSelectionDetails.ticketsChanged,
       hasChangesFromInitial: changeSelectionDetails.hasChangesFromInitial,
-      selectionTotal: totalPrice,
+      selectionTotal: originalReceipt ? changeFlowProposedTotalResolved : totalPrice,
       selectionCurrency: currency,
     };
   }, [
@@ -2715,11 +3624,34 @@ export function BookingFlow({
     changeSelectionDetails,
     totalPrice,
     currency,
+    originalReceipt,
+    changeFlowProposedTotalResolved,
   ]);
 
   useEffect(() => {
-    if (!isChangeFlow || !onChangeFlowSelectionPreview) return;
-    onChangeFlowSelectionPreview(changeFlowSelectionPreview);
+    if (!isChangeFlow) {
+      lastChangeFlowPreviewKeyRef.current = null;
+      return;
+    }
+    if (!onChangeFlowSelectionPreview) return;
+    const next = changeFlowSelectionPreview;
+    const key =
+      next === null
+        ? 'null'
+        : JSON.stringify({
+            tourName: next.tourName,
+            dateTime: next.dateTime,
+            ticketsLine: next.ticketsLine,
+            itinerarySteps: next.itinerarySteps,
+            dateChanged: next.dateChanged,
+            ticketsChanged: next.ticketsChanged,
+            hasChangesFromInitial: next.hasChangesFromInitial,
+            selectionTotal: next.selectionTotal,
+            selectionCurrency: next.selectionCurrency,
+          });
+    if (key === lastChangeFlowPreviewKeyRef.current) return;
+    lastChangeFlowPreviewKeyRef.current = key;
+    onChangeFlowSelectionPreview(next);
   }, [isChangeFlow, changeFlowSelectionPreview, onChangeFlowSelectionPreview]);
 
   useEffect(() => {
@@ -2729,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,
     });
   }, [
@@ -2740,16 +3677,22 @@ 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. */
   useEffect(() => {
-    if (!isChangeFlow) {
+    if (!isCustomerSelfServeChange) {
       setChangeQuoteLoading(false);
       setChangeQuoteFetchError(null);
+      setLatestChangeQuote(null);
       return;
     }
 
@@ -2796,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;
@@ -2829,7 +3778,7 @@ export function BookingFlow({
       window.clearTimeout(timer);
     };
   }, [
-    isChangeFlow,
+    isCustomerSelfServeChange,
     hasChangeSelection,
     selectedAvailability,
     selectedAvailability?.dateTime,
@@ -2841,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.
@@ -3339,31 +4292,33 @@ export function BookingFlow({
       setError('Removing return option in self-serve is not available. Please contact support.');
       return;
     }
-    
-    // Validate email (required)
-    if (!email) {
-      setError(t('booking.enterEmail') || 'Please enter your email address');
-      return;
-    }
-    
-    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
-      setError(t('booking.invalidEmail') || 'Please enter a valid email address');
-      return;
-    }
 
-    // Validate first name (required)
-    if (!firstName?.trim()) {
-      setError(t('booking.enterFirstName') || 'Please enter your first name');
-      return;
-    }
+    const skipContactFields = isProviderDashboardChange && isChangeFlow;
+    if (!skipContactFields) {
+      // Validate email (required)
+      if (!email) {
+        setError(t('booking.enterEmail') || 'Please enter your email address');
+        return;
+      }
 
-    // Validate last name (required for manage booking lookup)
-    if (!lastName?.trim()) {
-      setError(t('booking.enterLastName') || 'Please enter your last name');
-      return;
+      if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+        setError(t('booking.invalidEmail') || 'Please enter a valid email address');
+        return;
+      }
+
+      // Validate first name (required)
+      if (!firstName?.trim()) {
+        setError(t('booking.enterFirstName') || 'Please enter your first name');
+        return;
+      }
+
+      // Validate last name (required for manage booking lookup)
+      if (!lastName?.trim()) {
+        setError(t('booking.enterLastName') || 'Please enter your last name');
+        return;
+      }
     }
-    
-    
+
     // Allow checkout if pickup location is selected OR if user chose "I don't know"
     if (product.pickupLocations && product.pickupLocations.length > 0 && !pickupLocationId && !pickupLocationSkipped) {
       setError(t('booking.selectPickupLocation'));
@@ -3389,6 +4344,45 @@ export function BookingFlow({
         return;
       }
 
+      if (onChangeBooking && isChangeFlow) {
+        const pickupForChange = pickupLocationId
+          ? product.pickupLocations?.find((loc) => loc.id === pickupLocationId)
+          : null;
+        await onChangeBooking({
+          productId: availabilityProductOptionId,
+          dateTime: selectedAvailability.dateTime,
+          bookingItems,
+          returnAvailabilityId: selectedReturnOption?.returnAvailabilityId ?? null,
+          pickupLocationId: pickupLocationId ?? null,
+          travelerHotel: pickupForChange?.name ?? null,
+          startTime: selectedAvailability.dateTime ?? null,
+          passengerCount: null,
+          childSafetySeatsCount: null,
+          foodRestrictions: null,
+          addOnSelections: addOnSelections.length > 0 ? addOnSelections : null,
+          cancellationPolicyId: cancellationPolicyId ?? initialValues?.cancellationPolicyId ?? null,
+          promoCode: appliedPromoCode ?? null,
+          newTotalAmount: displayChangeFlowProposedTotal,
+          additionalHoursCount: null,
+          pricingAdjustment:
+            providerPricingOverrides.length > 0 || providerAdditionalAdjustments.length > 0
+              ? {
+                  mode: 'MANUAL_LINES',
+                  lineOverrides: providerPricingOverrides,
+                  additionalAdjustments: providerAdditionalAdjustments,
+                }
+              : undefined,
+          capacitySeatCredit: {
+            enabled: true,
+            previousPassengerCount: changeFlowInitialTicketCount,
+            previousAvailabilityId: initialValues?.availabilityId ?? null,
+            previousReturnAvailabilityId: initialValues?.returnAvailabilityId ?? null,
+          },
+        });
+        setLoading(false);
+        return;
+      }
+
       const bookingSourceContext = buildBookingSourceContext(bookingSourceAttribution, {
         clientChannelSource: inferClientBookingSourceFromProductIds(
           product.productId,
@@ -3406,7 +4400,7 @@ export function BookingFlow({
       let changeIntentIdForCheckout: string | undefined;
       let changeBookingReferenceForPaidFlow: string | undefined;
 
-      if (isChangeFlow) {
+      if (isCustomerSelfServeChange) {
         const changeBookingReference = initialValues?.bookingReference?.trim();
         const changeLastName = lastName.trim();
         if (!changeBookingReference || !changeLastName) {
@@ -3422,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;
@@ -3443,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)
@@ -3552,8 +4546,8 @@ export function BookingFlow({
       // Build checkout breakdown from the exact same values we show in the UI and Stripe modal.
       // Backend will charge totalAmount and store this as the receipt so /manage matches.
       const taxForBreakdown = effectivePromoDiscountAmount > 0 ? effectiveTax : tax;
-      const amountDueForCheckout = isChangeFlow
-        ? Math.max(0, changeFlowProposedTotal - (originalReceipt?.total ?? 0))
+      const amountDueForCheckout = isCustomerSelfServeChange
+        ? Math.max(0, changeFlowProposedTotalResolved - (originalReceipt?.total ?? 0))
         : totalPrice;
       const lines = [
         ...ticketLineItems.map((line) => ({
@@ -3674,7 +4668,7 @@ export function BookingFlow({
         return;
       }
 
-      const paymentIntent = isChangeFlow
+      const paymentIntent = isCustomerSelfServeChange
         ? await createChangeBookingPaymentIntent(
             (() => {
               const id = changeIntentIdForCheckout ?? latestChangeQuote?.changeIntentId;
@@ -3811,7 +4805,7 @@ export function BookingFlow({
         // Paid change: always return to stable ref+lastName + explicit intent (not reservationRef).
         // /manage-booking runs bounded refresh only when `from=change_payment` (see manage-booking page).
         successUrlOverride:
-          isChangeFlow && changeBookingReferenceForPaidFlow
+          isCustomerSelfServeChange && changeBookingReferenceForPaidFlow
             ? (() => {
                 const origin = typeof window !== 'undefined' ? window.location.origin : '';
                 const ref = encodeURIComponent(
@@ -3839,10 +4833,10 @@ export function BookingFlow({
         promoDiscountAmount: effectivePromoDiscountAmount > 0 ? effectivePromoDiscountAmount : 0,
         discountLabel: appliedPromoCode ? `Promo: ${appliedPromoCode}` : (originalReceipt?.promoLabel || undefined),
         changeTotals:
-          isChangeFlow && originalReceipt
+          isCustomerSelfServeChange && originalReceipt
             ? {
                 previousTotal: originalReceipt.total,
-                newTotal: totalPrice,
+                newTotal: displayChangeFlowProposedTotal,
                 differenceTotal: amountDueForCheckout,
               }
             : undefined,
@@ -4135,7 +5129,7 @@ export function BookingFlow({
                 currency={currency}
                 showCapacity={isAdmin}
                 extraDiscountPercent={calendarDiscountPercent}
-                capDiscountToSelectedDate={isChangeFlow && changeFlowTicketPriceFloorByCategory.size > 0}
+                capDiscountToSelectedDate={isChangeFlow && changeFlowTicketBookedUnitPriceByCategory.size > 0}
               />
             </div>
           </div>
@@ -4248,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}
@@ -4261,7 +5253,7 @@ export function BookingFlow({
               t={t}
               onQuantityChange={handleQuantityChange}
               minimumQuantities={changeBookingMinimumQuantities}
-              ticketUnitFloorByCategory={isChangeFlow ? changeFlowTicketPriceFloorByCategory : undefined}
+              ticketUnitFloorByCategory={isChangeFlow ? changeFlowTicketBookedUnitPriceByCategory : undefined}
             />
           )}
 
@@ -4273,48 +5265,71 @@ export function BookingFlow({
               currency={currency}
               locale={locale}
               onSelectionsChange={updateAddOnSelections}
-              minimumTotalByAddOnId={isChangeFlow ? initialAddOnMinTotalByAddOnId : undefined}
+              minimumTotalByAddOnId={isCustomerSelfServeChange ? initialAddOnMinTotalByAddOnId : undefined}
             />
           )}
 
           {/* Total and Checkout — shared PriceSummary component */}
           {selectedAvailability && (
             <CheckoutForm
-              priceSummaryLines={checkoutPriceSummaryLines}
-              totalPrice={changeFlowAmountDue}
-              totalSummaryLabel={
-                isChangeFlow
-                  ? (t('booking.totalOwedForBookingChange') &&
-                    t('booking.totalOwedForBookingChange') !== 'booking.totalOwedForBookingChange'
-                      ? t('booking.totalOwedForBookingChange')
-                      : 'Total owed for booking difference')
-                  : undefined
-              }
-              subtotal={subtotal !== totalFromSummary || effectivePromoDiscountAmount > 0 || addOnTotal > 0 ? effectiveSubtotal : undefined}
-              taxAmount={!isTaxIncludedInPrice && (effectivePromoDiscountAmount > 0 ? effectiveTax : tax) > 0 ? (effectivePromoDiscountAmount > 0 ? effectiveTax : tax) : 0}
-              taxRate={pricingConfig?.taxRate}
-              currency={currency}
-              locale={locale}
-              t={t}
-              extraBetweenTaxAndTotal={
-                <>
-                  {isChangeFlow && originalReceipt && lockedPromoCode ? (
-                    <PromoCodeInput
-                      promoCodeInput={promoCodeInput}
-                      appliedPromoCode={appliedPromoCode}
-                      promoCodeError={promoCodeError}
-                      promoCodeValidating={promoCodeValidating}
-                      promoDiscountAmount={effectivePromoDiscountAmount}
-                      currency={currency}
-                      locale={locale}
-                      t={t}
-                      onInputChange={() => {}}
-                      onApply={() => {}}
-                      onRemove={() => {}}
-                      locked
-                    />
-                  ) : (
-                    !isChangeFlow ? (
+                priceSummaryLines={checkoutPriceSummaryLines}
+                totalPrice={changeFlowAmountDue}
+                totalSummaryLabel={
+                  isChangeFlow
+                    ? (t('booking.totalOwedForBookingChange') &&
+                      t('booking.totalOwedForBookingChange') !== 'booking.totalOwedForBookingChange'
+                        ? t('booking.totalOwedForBookingChange')
+                        : 'Total owed for booking difference')
+                    : undefined
+                }
+                subtotal={
+                  isChangeFlow
+                    ? displayChangeFlowSubtotal
+                    : (subtotal !== totalFromSummary || effectivePromoDiscountAmount > 0 || addOnTotal > 0
+                        ? effectiveSubtotal
+                        : undefined)
+                }
+                taxAmount={
+                  !isTaxIncludedInPrice &&
+                  (isChangeFlow ? displayChangeFlowTax : (effectivePromoDiscountAmount > 0 ? effectiveTax : tax)) > 0
+                    ? (isChangeFlow ? displayChangeFlowTax : (effectivePromoDiscountAmount > 0 ? effectiveTax : tax))
+                    : 0
+                }
+                taxRate={pricingConfig?.taxRate}
+                currency={currency}
+                locale={locale}
+                t={t}
+                extraBetweenTaxAndTotal={
+                  <>
+                    {showProviderPricingInlineEditor && providerPricingUi?.error ? (
+                      <div className="mt-2 text-sm text-red-700">{providerPricingUi.error}</div>
+                    ) : null}
+                    {showProviderPricingInlineEditor &&
+                    providerPricingUi?.loading &&
+                    providerQuotedLines.length === 0 ? (
+                      <div className="mt-2 text-sm text-stone-500">Loading price lines...</div>
+                    ) : null}
+                    {showProviderPricingInlineEditor &&
+                    providerPricingUi?.helperText &&
+                    !providerPricingUi.error ? (
+                      <div className="mt-2 text-xs text-stone-500">{providerPricingUi.helperText}</div>
+                    ) : null}
+                    {isChangeFlow && lockedPromoCode ? (
+                      <PromoCodeInput
+                        promoCodeInput={promoCodeInput}
+                        appliedPromoCode={appliedPromoCode}
+                        promoCodeError={promoCodeError}
+                        promoCodeValidating={promoCodeValidating}
+                        promoDiscountAmount={effectivePromoDiscountAmount}
+                        currency={currency}
+                        locale={locale}
+                        t={t}
+                        onInputChange={() => {}}
+                        onApply={() => {}}
+                        onRemove={() => {}}
+                        locked
+                      />
+                    ) : !isChangeFlow ? (
                       <PromoCodeInput
                         promoCodeInput={promoCodeInput}
                         appliedPromoCode={appliedPromoCode}
@@ -4339,71 +5354,150 @@ export function BookingFlow({
                           fetchedRangesRef.current = [];
                         }}
                       />
-                    ) : null
-                  )}
-                </>
-              }
-              firstName={firstName}
-              lastName={lastName}
-              email={email}
-              onFirstNameChange={(v) => { setFirstName(v); setError(''); }}
-              onLastNameChange={(v) => { setLastName(v); setError(''); }}
-              onEmailChange={(v) => { setEmail(v); setError(''); }}
-              readOnlyContactFields={isChangeFlow}
-              pickupLocations={
-                selectedDate && product.pickupLocations && product.pickupLocations.length > 0
-                  ? product.pickupLocations
-                  : undefined
-              }
-              destinations={product.destinations}
-              pickupLocationId={pickupLocationId}
-              pickupLocationSkipped={pickupLocationSkipped}
-              selectedPickupLocation={selectedPickupLocation}
-              highlightedPickupLocationIds={highlightedPickupLocationIds}
-              onLocationSelect={(locationId) => {
-                setPickupLocationId(locationId);
-                setError('');
-                if (locationId === null && pickupLocationSkipped) {
-                  setPickupLocationSkipped(false);
-                } else if (locationId !== null) {
+                    ) : null}
+                  </>
+                }
+                extraBeforeSubtotal={
+                  showProviderPricingInlineEditor && (providerPricingUi?.additionalAdjustments?.length ?? 0) > 0 ? (
+                    <div className="space-y-1">
+                      {providerPricingUi?.additionalAdjustments?.map((adj) => (
+                        <div key={adj.id} className="flex items-center justify-between gap-2 text-sm">
+                          <div className="flex min-w-0 items-center gap-1">
+                            <button
+                              type="button"
+                              className="rounded border border-stone-300 px-1 text-xs text-stone-600 hover:bg-stone-100"
+                              onClick={() => providerPricingUi?.onRemoveAdditionalAdjustment?.(adj.id)}
+                            >
+                              -
+                            </button>
+                            <input
+                              type="text"
+                              className="w-40 rounded border border-stone-300 px-2 py-0.5 text-sm"
+                              placeholder="Line description"
+                              value={adj.label}
+                              onChange={(e) =>
+                                providerPricingUi?.onUpdateAdditionalAdjustment?.(adj.id, { label: e.target.value })
+                              }
+                            />
+                          </div>
+                          <div className="flex items-center gap-1">
+                            <select
+                              className="rounded border border-stone-300 px-1 py-0.5 text-xs"
+                              value={adj.mode}
+                              onChange={(e) =>
+                                providerPricingUi?.onUpdateAdditionalAdjustment?.(adj.id, {
+                                  mode: e.target.value as 'DISCOUNT' | 'CHARGE',
+                                })
+                              }
+                            >
+                              <option value="DISCOUNT">-</option>
+                              <option value="CHARGE">+</option>
+                            </select>
+                            <input
+                              type="text"
+                              inputMode="decimal"
+                              className="h-6 w-24 rounded border border-stone-300 bg-white px-2 py-0.5 text-right text-sm font-medium leading-none text-stone-700"
+                              placeholder="0.00"
+                              value={adj.amountInput}
+                              onChange={(e) =>
+                                providerPricingUi?.onUpdateAdditionalAdjustment?.(adj.id, {
+                                  amountInput: e.target.value,
+                                })
+                              }
+                            />
+                          </div>
+                        </div>
+                      ))}
+                      <button
+                        type="button"
+                        className="rounded border border-stone-300 px-2 py-0.5 text-xs text-stone-600 hover:bg-stone-100"
+                        onClick={() => providerPricingUi?.onAddAdditionalAdjustment?.()}
+                      >
+                        + add line item
+                      </button>
+                    </div>
+                  ) : showProviderPricingInlineEditor ? (
+                    <button
+                      type="button"
+                      className="rounded border border-stone-300 px-2 py-0.5 text-xs text-stone-600 hover:bg-stone-100"
+                      onClick={() => providerPricingUi?.onAddAdditionalAdjustment?.()}
+                    >
+                      + add line item
+                    </button>
+                  ) : undefined
+                }
+                firstName={firstName}
+                lastName={lastName}
+                email={email}
+                onFirstNameChange={(v) => { setFirstName(v); setError(''); }}
+                onLastNameChange={(v) => { setLastName(v); setError(''); }}
+                onEmailChange={(v) => { setEmail(v); setError(''); }}
+                readOnlyContactFields={isChangeFlow}
+                pickupLocations={
+                  selectedDate && product.pickupLocations && product.pickupLocations.length > 0
+                    ? product.pickupLocations
+                    : undefined
+                }
+                destinations={product.destinations}
+                pickupLocationId={pickupLocationId}
+                pickupLocationSkipped={pickupLocationSkipped}
+                selectedPickupLocation={selectedPickupLocation}
+                highlightedPickupLocationIds={highlightedPickupLocationIds}
+                onLocationSelect={(locationId) => {
+                  setPickupLocationId(locationId);
+                  setError('');
+                  if (locationId === null && pickupLocationSkipped) {
+                    setPickupLocationSkipped(false);
+                  } else if (locationId !== null) {
+                    setPickupLocationSkipped(false);
+                  }
+                }}
+                onSkip={() => {
+                  setPickupLocationSkipped(true);
+                  setPickupLocationId(null);
+                  setError('');
+                }}
+                onChangePickup={() => {
+                  setPickupLocationId(null);
                   setPickupLocationSkipped(false);
+                }}
+                termsAccepted={termsAccepted}
+                onTermsChange={(checked) => {
+                  setTermsAccepted(checked);
+                  setTermsAcceptedAt(checked ? new Date().toISOString() : null);
+                }}
+                isAdmin={isAdmin}
+                showCommunicationAdminSection={!isChangeFlow}
+                skipConfirmationCommunications={skipConfirmationCommunications}
+                disableAutoCommunications={disableAutoCommunications}
+                onSkipConfirmationChange={setSkipConfirmationCommunications}
+                onDisableCommunicationsChange={setDisableAutoCommunications}
+                error={checkoutFormError}
+                loading={loading}
+                totalQuantity={totalQuantity}
+                onCheckout={handleCheckout}
+                submitLabel={changeCheckoutButtonLabel ?? deferredInvoiceSubmitLabel}
+                hideSubmitButton={
+                  showCheckoutModal ||
+                  showAdminPaymentChoice ||
+                  (isChangeFlow && (!hasEffectiveChangeSelection || isChangeQuoteBlocked))
                 }
-              }}
-              onSkip={() => {
-                setPickupLocationSkipped(true);
-                setPickupLocationId(null);
-                setError('');
-              }}
-              onChangePickup={() => {
-                setPickupLocationId(null);
-                setPickupLocationSkipped(false);
-              }}
-              termsAccepted={termsAccepted}
-              onTermsChange={(checked) => {
-                setTermsAccepted(checked);
-                setTermsAcceptedAt(checked ? new Date().toISOString() : null);
-              }}
-              isAdmin={isAdmin}
-              skipConfirmationCommunications={skipConfirmationCommunications}
-              disableAutoCommunications={disableAutoCommunications}
-              onSkipConfirmationChange={setSkipConfirmationCommunications}
-              onDisableCommunicationsChange={setDisableAutoCommunications}
-              error={checkoutFormError}
-              loading={loading}
-              totalQuantity={totalQuantity}
-              onCheckout={handleCheckout}
-              submitLabel={changeCheckoutButtonLabel ?? deferredInvoiceSubmitLabel}
-              hideSubmitButton={
-                showCheckoutModal ||
-                showAdminPaymentChoice ||
-                (isChangeFlow && (!hasChangeSelection || isChangeQuoteBlocked))
-              }
-              submitDisabled={changeFlowSubmitDisabled}
-              attributionSummary={flowUi?.partnerAttributionSummary}
-              attributionConfirmLabel={flowUi?.partnerAttributionConfirmLabel}
-              attributionConfirmed={partnerAttributionConfirmed}
-              onAttributionConfirmedChange={setPartnerAttributionConfirmed}
-            />
+                submitDisabled={changeFlowSubmitDisabled}
+                attributionSummary={flowUi?.partnerAttributionSummary}
+                attributionConfirmLabel={flowUi?.partnerAttributionConfirmLabel}
+                attributionConfirmed={partnerAttributionConfirmed}
+                onAttributionConfirmedChange={setPartnerAttributionConfirmed}
+                lineAmountInputs={showProviderPricingInlineEditor ? providerPricingUi?.lineAmountInputs : undefined}
+                onLineAmountInputChange={
+                  showProviderPricingInlineEditor ? providerPricingUi?.onLineAmountInputChange : undefined
+                }
+                onLineAmountInputBlur={
+                  showProviderPricingInlineEditor ? providerPricingUi?.onLineAmountInputBlur : undefined
+                }
+                onLineAmountReset={
+                  showProviderPricingInlineEditor ? providerPricingUi?.onLineAmountReset : undefined
+                }
+              />
           )}
           </div>
         </>