@ticketboothapp/booking 1.2.166 → 1.2.168

package/src/components/booking/useAdminProviderPricingAdjustments.ts

@@ -5,17 +5,8 @@ import type {
   ProviderDashboardPricingLine,
 } from './booking-flow-ui';
 import type { ProviderDashboardChangeBookingPayload } from './provider-dashboard-change-booking';
+import type { AdminCustomReceiptLine } from './useAdminCustomReceiptLines';
 
-type AdminCustomReceiptLine = {
-  id: string;
-  label: string;
-  amountInput: string;
-  amountSign?: number;
-  calculation: 'FIXED_AMOUNT' | 'PERCENTAGE';
-  scope: 'POSITIVE_AMENDMENT_VALUE' | 'CURRENT_ACTIVE_TICKETS' | 'CURRENT_ACTIVE_BOOKING';
-  taxBehavior: 'NON_TAXABLE' | 'TAXABLE' | 'PRE_TAX_DISCOUNT' | 'POST_TAX_DISCOUNT';
-  reasonCode: string;
-};
 type AdminStructuredAdjustment = NonNullable<
   ProviderDashboardChangeBookingPayload['structuredAdjustments']
 >[number];
@@ -26,6 +17,35 @@ type ProviderAdditionalAdjustment = NonNullable<
   NonNullable<ProviderDashboardChangeBookingPayload['pricingAdjustment']>['additionalAdjustments']
 >[number];
 
+export interface EffectiveAdminChangeSelectionInput {
+  hasChangeSelection: boolean;
+  providerPricingOverrideCount: number;
+  providerHasAdditionalAdjustments: boolean;
+  isProviderDashboardChange: boolean;
+  editableSummaryPreSubtotalDelta: number;
+  adminStructuredAdjustmentCount: number;
+  adminReverseAdjustmentCount?: number;
+}
+
+export function hasEffectiveAdminChangeSelection({
+  hasChangeSelection,
+  providerPricingOverrideCount,
+  providerHasAdditionalAdjustments,
+  isProviderDashboardChange,
+  editableSummaryPreSubtotalDelta,
+  adminStructuredAdjustmentCount,
+  adminReverseAdjustmentCount = 0,
+}: EffectiveAdminChangeSelectionInput): boolean {
+  return Boolean(
+    hasChangeSelection ||
+      providerPricingOverrideCount > 0 ||
+      providerHasAdditionalAdjustments ||
+      (isProviderDashboardChange && Math.abs(editableSummaryPreSubtotalDelta) >= 0.005) ||
+      adminStructuredAdjustmentCount > 0 ||
+      adminReverseAdjustmentCount > 0,
+  );
+}
+
 export interface UseAdminProviderPricingAdjustmentsParams {
   isProviderDashboardChange: boolean;
   showProviderPricingInlineEditor: boolean;
@@ -33,8 +53,8 @@ export interface UseAdminProviderPricingAdjustmentsParams {
   providerQuotedLines: ProviderDashboardPricingLine[];
   hasChangeSelection: boolean;
   editableSummaryPreSubtotalDelta: number;
-  adminCustomAdjustmentTotal: number;
   adminCustomReceiptLines: AdminCustomReceiptLine[];
+  adminReverseAdjustmentIds: string[];
   isManualOverrideEligibleLine: (line: ProviderDashboardPricingLine) => boolean;
 }
 
@@ -51,8 +71,8 @@ export function useAdminProviderPricingAdjustments({
   providerQuotedLines,
   hasChangeSelection,
   editableSummaryPreSubtotalDelta,
-  adminCustomAdjustmentTotal,
   adminCustomReceiptLines,
+  adminReverseAdjustmentIds,
   isManualOverrideEligibleLine,
 }: UseAdminProviderPricingAdjustmentsParams) {
   const [adjustmentIdNamespace] = useState(() =>
@@ -127,6 +147,7 @@ export function useAdminProviderPricingAdjustments({
   const adminCustomLinesAsAdditionalAdjustments = useMemo(
     (): ProviderAdditionalAdjustment[] =>
       adminCustomReceiptLines.flatMap((line) => {
+        if (line.sourceAdjustmentId) return [];
         const raw = line.amountInput.trim();
         if (raw === '' || raw === '+' || raw === '-') return [];
         const n = Number(raw);
@@ -142,20 +163,26 @@ export function useAdminProviderPricingAdjustments({
   const adminStructuredAdjustments = useMemo(
     (): AdminStructuredAdjustment[] => {
       const customAdjustments = adminCustomReceiptLines.flatMap((line) => {
+        if (line.sourceAdjustmentId && !line.isDirty) return [];
         const value = Number(line.amountInput.trim());
         if (!Number.isFinite(value) || value <= 0) return [];
+        if (line.scope === 'SELECTED_COMPONENTS' && line.selectedComponentIds.length === 0) {
+          return [];
+        }
         const discount = (line.amountSign ?? 1) < 0;
         const percentage = line.calculation === 'PERCENTAGE';
         const mode: AdminStructuredAdjustment['mode'] = percentage
           ? discount ? 'PERCENTAGE_DISCOUNT' : 'PERCENTAGE_SURCHARGE'
           : 'FIXED_AMOUNT';
         return [{
-          adjustmentId: line.id,
+          adjustmentId: line.replacementAdjustmentId ?? line.id,
           mode,
           ...(percentage
             ? { percentageBasisPoints: Math.round(value * 100) }
             : { fixedAmount: roundMoney((discount ? -1 : 1) * value) }),
           scope: line.scope,
+          selectedComponentIds:
+            line.scope === 'SELECTED_COMPONENTS' ? line.selectedComponentIds : [],
           taxBehavior: line.taxBehavior,
           reasonCode: line.reasonCode.trim() || 'STAFF_ADJUSTMENT',
           reason: line.label.trim() || null,
@@ -209,12 +236,15 @@ export function useAdminProviderPricingAdjustments({
     [providerAdditionalAdjustments],
   );
 
-  const hasEffectiveChangeSelection =
-    hasChangeSelection ||
-    providerPricingOverrides.length > 0 ||
-    providerHasAdditionalAdjustments ||
-    (isProviderDashboardChange && Math.abs(editableSummaryPreSubtotalDelta) >= 0.005) ||
-    Math.abs(adminCustomAdjustmentTotal) >= 0.005;
+  const hasEffectiveChangeSelection = hasEffectiveAdminChangeSelection({
+    hasChangeSelection,
+    providerPricingOverrideCount: providerPricingOverrides.length,
+    providerHasAdditionalAdjustments,
+    isProviderDashboardChange,
+    editableSummaryPreSubtotalDelta,
+    adminStructuredAdjustmentCount: adminStructuredAdjustments.length,
+    adminReverseAdjustmentCount: adminReverseAdjustmentIds.length,
+  });
 
   return {
     providerTotalsPreview,
@@ -223,5 +253,6 @@ export function useAdminProviderPricingAdjustments({
     adminCustomLinesAsAdditionalAdjustments,
     mergedProviderAdditionalAdjustments,
     adminStructuredAdjustments,
+    adminReverseAdjustmentIds,
   };
 }

package/src/components/booking/useBookingAvailabilityAddOns.ts

@@ -16,6 +16,7 @@ export interface UseBookingAvailabilityAddOnsResult {
   addOns: AddOn[];
   setAddOns: Dispatch<SetStateAction<AddOn[]>>;
   availabilityProductOptionId: string | null;
+  loadedProductOptionId: string | null;
 }
 
 export function useBookingAvailabilityAddOns({
@@ -24,15 +25,19 @@ export function useBookingAvailabilityAddOns({
   onProductOptionChange,
 }: UseBookingAvailabilityAddOnsParams): UseBookingAvailabilityAddOnsResult {
   const [addOns, setAddOns] = useState<AddOn[]>([]);
+  const [loadedProductOptionId, setLoadedProductOptionId] = useState<string | null>(null);
   const previousAvailabilityProductOptionIdRef = useRef<string | null>(null);
   const availabilityProductOptionId = useMemo(
     () => (selectedAvailability ? getAvailabilityOptionId(selectedAvailability) || null : null),
     [selectedAvailability],
   );
+  const availabilityDateTime = selectedAvailability?.dateTime?.trim() || null;
 
   useEffect(() => {
+    let cancelled = false;
     if (!availabilityProductOptionId || !companyId) {
       setAddOns([]);
+      setLoadedProductOptionId(null);
       onProductOptionChange?.();
       return;
     }
@@ -41,14 +46,31 @@ export function useBookingAvailabilityAddOns({
       onProductOptionChange?.();
       previousAvailabilityProductOptionIdRef.current = availabilityProductOptionId;
     }
-    getAddOns(companyId, { productOptionId: availabilityProductOptionId, preCheckout: true })
-      .then(setAddOns)
-      .catch(() => setAddOns([]));
-  }, [availabilityProductOptionId, companyId, onProductOptionChange]);
+    setLoadedProductOptionId(null);
+    getAddOns(companyId, {
+      productOptionId: availabilityProductOptionId,
+      preCheckout: true,
+      dateTime: availabilityDateTime ?? undefined,
+    })
+      .then((rows) => {
+        if (cancelled) return;
+        setAddOns(rows);
+        setLoadedProductOptionId(availabilityProductOptionId);
+      })
+      .catch(() => {
+        if (cancelled) return;
+        setAddOns([]);
+        setLoadedProductOptionId(availabilityProductOptionId);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [availabilityProductOptionId, availabilityDateTime, companyId, onProductOptionChange]);
 
   return {
     addOns,
     setAddOns,
     availabilityProductOptionId,
+    loadedProductOptionId,
   };
 }

package/src/components/booking/useBookingPromoAndQuantityController.ts

@@ -27,6 +27,9 @@ export interface UseBookingPromoAndQuantityControllerParams {
 export interface UseBookingPromoAndQuantityControllerResult {
   handleQuantityChange: (category: string, delta: number) => void;
   handleApplyPromo: () => Promise<void>;
+  handleRemovePromo: () => void;
+  promoCodeError: string;
+  promoCodeValidating: boolean;
 }
 
 export function useBookingPromoAndQuantityController({
@@ -47,8 +50,8 @@ export function useBookingPromoAndQuantityController({
   t,
   setError,
 }: UseBookingPromoAndQuantityControllerParams): UseBookingPromoAndQuantityControllerResult {
-  const [, setPromoCodeError] = useState('');
-  const [, setPromoCodeValidating] = useState(false);
+  const [promoCodeError, setPromoCodeError] = useState('');
+  const [promoCodeValidating, setPromoCodeValidating] = useState(false);
   const promoAppliedSelectionKeyRef = useRef<string | null>(null);
   const promoValidateInFlightRef = useRef(false);
 
@@ -156,8 +159,19 @@ export function useBookingPromoAndQuantityController({
     return () => clearTimeout(timer);
   }, [promoCodeInput, appliedPromoCode, selectedAvailability, totalQuantity]);
 
+  const handleRemovePromo = useCallback(() => {
+    promoAppliedSelectionKeyRef.current = null;
+    setAppliedPromoCode(null);
+    setPromoCodeError('');
+    setPromoCodeValidating(false);
+    clearFetchedAvailabilityRanges();
+  }, [clearFetchedAvailabilityRanges, setAppliedPromoCode]);
+
   return {
     handleQuantityChange,
     handleApplyPromo,
+    handleRemovePromo,
+    promoCodeError,
+    promoCodeValidating,
   };
 }

package/src/components/booking/useChangeBookingAddOnFloorController.ts

@@ -13,7 +13,7 @@ interface UseChangeBookingAddOnFloorControllerOptions {
   initialValues?: ChangeBookingFlowProps['initialValues'];
   originalReceiptLineItems?: NonNullable<ChangeBookingFlowProps['originalReceipt']>['lineItems'];
   addOns: AddOn[];
-  isCustomerSelfServeChange: boolean;
+  lockExistingAddOnQuantities: boolean;
   setAddOnSelections: Dispatch<SetStateAction<AddOnSelection[]>>;
 }
 
@@ -21,9 +21,10 @@ export function useChangeBookingAddOnFloorController({
   initialValues,
   originalReceiptLineItems,
   addOns,
-  isCustomerSelfServeChange,
+  lockExistingAddOnQuantities,
   setAddOnSelections,
 }: UseChangeBookingAddOnFloorControllerOptions): {
+  initialAddOnQtyByKey: Map<string, number>;
   initialAddOnMinQtyByKey: Map<string, number>;
   initialAddOnMinTotalByAddOnId: Map<string, number>;
   updateAddOnSelections: (updater: AddOnSelectionsUpdater) => void;
@@ -39,29 +40,33 @@ export function useChangeBookingAddOnFloorController({
     return [] as AddOnSelection[];
   }, [initialValues?.addOnSelections, originalReceiptLineItems, addOns]);
 
-  const initialAddOnMinQtyByKey = useMemo(() => {
+  const initialAddOnQtyByKey = useMemo(() => {
     const map = new Map<string, number>();
-    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;
-  }, [isCustomerSelfServeChange, initialAddOnBaselineSelections]);
+  }, [initialAddOnBaselineSelections]);
+
+  const initialAddOnMinQtyByKey = useMemo(
+    () => (lockExistingAddOnQuantities ? initialAddOnQtyByKey : new Map<string, number>()),
+    [lockExistingAddOnQuantities, initialAddOnQtyByKey]
+  );
 
   const initialAddOnMinTotalByAddOnId = useMemo(() => {
     const map = new Map<string, number>();
-    if (!isCustomerSelfServeChange) return map;
+    if (!lockExistingAddOnQuantities) 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;
-  }, [isCustomerSelfServeChange, initialAddOnBaselineSelections]);
+  }, [lockExistingAddOnQuantities, initialAddOnBaselineSelections]);
 
   const applyChangeFlowAddOnFloor = useCallback(
     (nextSelections: AddOnSelection[]) => {
-      if (!isCustomerSelfServeChange || initialAddOnMinQtyByKey.size === 0) return nextSelections;
+      if (!lockExistingAddOnQuantities || initialAddOnMinQtyByKey.size === 0) return nextSelections;
       const qtyByKey = new Map<string, number>();
       for (const sel of nextSelections) {
         const key = `${sel.addOnId.trim()}::${sel.variantId?.trim() || ''}`;
@@ -88,7 +93,7 @@ export function useChangeBookingAddOnFloorController({
         return { addOnId, variantId, quantity: qty };
       });
     },
-    [isCustomerSelfServeChange, initialAddOnMinQtyByKey, initialAddOnMinTotalByAddOnId]
+    [lockExistingAddOnQuantities, initialAddOnMinQtyByKey, initialAddOnMinTotalByAddOnId]
   );
 
   const updateAddOnSelections = useCallback(
@@ -102,6 +107,7 @@ export function useChangeBookingAddOnFloorController({
   );
 
   return {
+    initialAddOnQtyByKey,
     initialAddOnMinQtyByKey,
     initialAddOnMinTotalByAddOnId,
     updateAddOnSelections,

package/src/components/booking/useChangeBookingAutoSelections.ts

@@ -1,7 +1,11 @@
 'use client';
 
-import { useEffect, useRef, type RefObject } from 'react';
+import { useCallback, useEffect, useRef, type RefObject } from 'react';
 import type { Availability, PickupLocation } from '../../lib/booking-api';
+import {
+  findFirstDateWithBookableAvailability,
+  selectedDateHasVisibleAvailability,
+} from './availability-date-selection';
 
 export interface UseChangeBookingAutoSelectionsOptions {
   autoSelectFirstAvailableDate?: boolean;
@@ -71,6 +75,55 @@ export function useChangeBookingAutoSelections({
   const hasAutoSelectedPartnerDateRef = useRef(false);
   const hasAutoSelectedPartnerPickupRef = useRef(false);
 
+  const isBookableForAutoSelection = useCallback(
+    (availability: Availability): boolean => {
+      if (isAdmin) return (availability.vacancies ?? 0) > 0;
+      if (isCustomerSelfServeChange && changeFlowInitialTicketCount > 0) {
+        return getCalendarEffectiveOutboundVacancies(availability) >= changeFlowInitialTicketCount;
+      }
+      return (availability.vacancies ?? 0) > 0;
+    },
+    [
+      changeFlowInitialTicketCount,
+      getCalendarEffectiveOutboundVacancies,
+      isAdmin,
+      isCustomerSelfServeChange,
+    ],
+  );
+
+  useEffect(() => {
+    if (!autoSelectFirstAvailableDate) return;
+    if (isPartialLaunch) return;
+    if (!selectedDate || dates.length === 0) return;
+    if (selectedDateHasVisibleAvailability(selectedDate, getRowsForDate)) return;
+
+    const first = findFirstDateWithBookableAvailability(
+      dates,
+      getRowsForDate,
+      isBookableForAutoSelection,
+    );
+    if (!first || first === selectedDate) return;
+
+    hasAutoSelectedPartnerDateRef.current = true;
+    setSelectedDate(first);
+    onDateSelect(first);
+    if (!suppressCalendarDateScroll) {
+      scrollAfterCalendarSelection(contentRef, useWindowScroll);
+    }
+  }, [
+    autoSelectFirstAvailableDate,
+    isPartialLaunch,
+    selectedDate,
+    dates,
+    getRowsForDate,
+    isBookableForAutoSelection,
+    setSelectedDate,
+    onDateSelect,
+    suppressCalendarDateScroll,
+    contentRef,
+    useWindowScroll,
+  ]);
+
   useEffect(() => {
     if (!autoSelectFirstAvailableDate) return;
     if (isPartialLaunch) return;
@@ -79,18 +132,11 @@ export function useChangeBookingAutoSelections({
     if (dates.length === 0) return;
     if (hasAutoSelectedPartnerDateRef.current) return;
 
-    const firstWithInventory = dates.find((date) => {
-      const rows = getRowsForDate(date);
-      if (rows.length === 0) return false;
-      if (isAdmin) return rows.some((availability) => (availability.vacancies ?? 0) > 0);
-      if (isCustomerSelfServeChange && changeFlowInitialTicketCount > 0) {
-        return rows.some(
-          (availability) =>
-            getCalendarEffectiveOutboundVacancies(availability) >= changeFlowInitialTicketCount,
-        );
-      }
-      return rows.some((availability) => (availability.vacancies ?? 0) > 0);
-    });
+    const firstWithInventory = findFirstDateWithBookableAvailability(
+      dates,
+      getRowsForDate,
+      isBookableForAutoSelection,
+    );
     const first = firstWithInventory ?? (isAdmin && dates[0] ? dates[0] : undefined);
     if (!first) return;
 
@@ -107,10 +153,7 @@ export function useChangeBookingAutoSelections({
     selectedDate,
     dates,
     getRowsForDate,
-    isAdmin,
-    isCustomerSelfServeChange,
-    changeFlowInitialTicketCount,
-    getCalendarEffectiveOutboundVacancies,
+    isBookableForAutoSelection,
     setSelectedDate,
     onDateSelect,
     suppressCalendarDateScroll,

package/src/components/booking/useChangeBookingInitialHydration.ts

@@ -6,6 +6,7 @@ import type { AddOn, Availability, PrecomputedPricesByCategory } from '../../lib
 import type { Currency } from './CurrencySwitcher';
 import type { ChangeBookingFlowProps } from './booking-flow-types';
 import {
+  deriveCompatibleInitialBookingQuantities,
   deriveAddOnSelectionsFromReceiptLines,
   normalizeAddOnSelections,
   parseAvailabilityDateTime,
@@ -23,6 +24,7 @@ export interface UseChangeBookingInitialHydrationOptions {
   timesForSelectedDate: Availability[];
   companyTimezone: string;
   changeFlowResolvedInitialProductOptionId: string | null;
+  mostPopularProductOptionId: string | null;
   precomputedPricesByOption: Record<string, PrecomputedPricesByCategory> | null | undefined;
   currency: Currency;
   originalReceiptSubtotal?: number | null;
@@ -53,6 +55,7 @@ export function useChangeBookingInitialHydration({
   timesForSelectedDate,
   companyTimezone,
   changeFlowResolvedInitialProductOptionId,
+  mostPopularProductOptionId,
   precomputedPricesByOption,
   currency,
   originalReceiptSubtotal,
@@ -130,6 +133,7 @@ export function useChangeBookingInitialHydration({
       precomputedPricesByOption,
       currency,
       originalReceiptSubtotal ?? undefined,
+      mostPopularProductOptionId,
     );
     if (defer) return;
     if (selection) {
@@ -142,6 +146,7 @@ export function useChangeBookingInitialHydration({
     initialValues?.productOptionId,
     initialValues?.bookingItems,
     changeFlowResolvedInitialProductOptionId,
+    mostPopularProductOptionId,
     selectedAvailability,
     selectedDate,
     timesForSelectedDate,
@@ -163,15 +168,13 @@ export function useChangeBookingInitialHydration({
     ) {
       return;
     }
-    const next: Record<string, number> = {};
-    for (const item of initialValues.bookingItems) {
-      const key = item.category?.trim();
-      if (!key) continue;
-      next[key] = Math.max(0, Number(item.count) || 0);
-    }
+    const next = deriveCompatibleInitialBookingQuantities(
+      initialValues.bookingItems,
+      selectedAvailability,
+    );
+    hasAppliedInitialQuantitiesRef.current = true;
     if (Object.keys(next).length > 0) {
       setQuantities((prev) => ({ ...prev, ...next }));
-      hasAppliedInitialQuantitiesRef.current = true;
     }
   }, [initialValues, selectedAvailability, setQuantities]);
 

package/src/components/booking/useChangeBookingQuotePreview.ts

@@ -24,6 +24,7 @@ import {
   formatTicketLineItemsForSummary,
   getAvailabilityOptionId,
 } from './change-booking-flow-helpers';
+import { friendlyChangeBookingError } from './change-booking-error-message';
 import type { Currency } from './CurrencySwitcher';
 
 type AddOnSelection = { addOnId: string; variantId?: string; quantity?: number };
@@ -197,11 +198,12 @@ export function useChangeBookingQuotePreview({
       : 'Change booking (no charge)';
   })();
 
-  const checkoutFormError =
+  const rawCheckoutFormError =
     (error || '') ||
     (missingRequiredReturnSelection ? 'Removing return option in self-serve is not available. Please contact support.' : '') ||
     (isChangeQuoteBlocked ? (latestChangeQuote?.reasonIfBlocked ?? '') : '') ||
     (changeQuoteFetchError ?? '');
+  const checkoutFormError = friendlyChangeBookingError(rawCheckoutFormError);
 
   const changeFlowSelectionPreview = useMemo((): ChangeFlowSelectionPreview | null => {
     if (!selectedAvailability || totalQuantity <= 0) return null;

package/src/components/booking/useChangeBookingSelectionDetails.ts

@@ -30,7 +30,7 @@ export interface UseChangeBookingSelectionDetailsParams {
   pickupLocationId: string | null;
   quantities: Record<string, number>;
   addOnSelections: AddOnSelection[];
-  initialAddOnMinQtyByKey: Map<string, number>;
+  initialAddOnQtyByKey: Map<string, number>;
   changeFlowResolvedInitialProductOptionId: string | null;
   productChanged?: boolean;
 }
@@ -65,6 +65,25 @@ function normalizeCounts(items: Array<{ category: string; count: number }> | nul
   return map;
 }
 
+export function haveAddOnSelectionsChanged(
+  initialAddOnQtyByKey: Map<string, number>,
+  addOnSelections: AddOnSelection[],
+): boolean {
+  const currentAddOnQtyByKey = new Map<string, number>();
+  for (const sel of addOnSelections) {
+    const key = `${sel.addOnId.trim()}::${sel.variantId?.trim() || ''}`;
+    currentAddOnQtyByKey.set(key, (currentAddOnQtyByKey.get(key) ?? 0) + Math.max(1, Number(sel.quantity) || 1));
+  }
+
+  const allAddOnKeys = new Set([...initialAddOnQtyByKey.keys(), ...currentAddOnQtyByKey.keys()]);
+  for (const key of allAddOnKeys) {
+    if ((initialAddOnQtyByKey.get(key) ?? 0) !== (currentAddOnQtyByKey.get(key) ?? 0)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 export function useChangeBookingSelectionDetails({
   initialValues,
   selectedAvailability,
@@ -73,7 +92,7 @@ export function useChangeBookingSelectionDetails({
   pickupLocationId,
   quantities,
   addOnSelections,
-  initialAddOnMinQtyByKey,
+  initialAddOnQtyByKey,
   changeFlowResolvedInitialProductOptionId,
   productChanged = false,
 }: UseChangeBookingSelectionDetailsParams): ChangeBookingSelectionDetails {
@@ -115,20 +134,7 @@ export function useChangeBookingSelectionDetails({
       }
     }
 
-    const currentAddOnQtyByKey = new Map<string, number>();
-    for (const sel of addOnSelections) {
-      const key = `${sel.addOnId.trim()}::${sel.variantId?.trim() || ''}`;
-      currentAddOnQtyByKey.set(key, (currentAddOnQtyByKey.get(key) ?? 0) + Math.max(1, Number(sel.quantity) || 1));
-    }
-
-    const allAddOnKeys = new Set([...initialAddOnMinQtyByKey.keys(), ...currentAddOnQtyByKey.keys()]);
-    let addOnsChanged = false;
-    for (const key of allAddOnKeys) {
-      if ((initialAddOnMinQtyByKey.get(key) ?? 0) !== (currentAddOnQtyByKey.get(key) ?? 0)) {
-        addOnsChanged = true;
-        break;
-      }
-    }
+    const addOnsChanged = haveAddOnSelectionsChanged(initialAddOnQtyByKey, addOnSelections);
 
     const hasReturnOptions = (selectedAvailability?.returnOptions?.length ?? 0) > 0;
     const initialReturnId = initialValues.returnAvailabilityId?.trim() || null;
@@ -193,7 +199,7 @@ export function useChangeBookingSelectionDetails({
     pickupLocationId,
     quantities,
     addOnSelections,
-    initialAddOnMinQtyByKey,
+    initialAddOnQtyByKey,
     changeFlowResolvedInitialProductOptionId,
     productChanged,
   ]);

package/src/components/booking/useStandardBookingAutoSelections.ts

@@ -3,9 +3,14 @@ import { parseISO } from 'date-fns';
 import type { Availability, Product, ReturnOption } from '../../lib/booking-api';
 import {
   availabilityMatchesSelectedDate,
+  findMergedAvailabilityForSelection,
   parseAvailabilityDateTime,
   pickDefaultAvailabilityForTimes,
 } from './standard-booking-availability';
+import {
+  findFirstDateWithBookableAvailability,
+  selectedDateHasVisibleAvailability,
+} from './availability-date-selection';
 
 interface UseStandardBookingAutoSelectionsParams {
   selectedDate: string;
@@ -91,19 +96,22 @@ export function useStandardBookingAutoSelections({
 
   useEffect(() => {
     if (!selectedDate || timesForSelectedDateLength === 0) return;
+    const eligibleTimes = getPickupCutoffEligibleTimesForDate(selectedDate);
     if (
       selectedAvailability &&
-      availabilityMatchesSelectedDate(selectedAvailability, selectedDate, companyTimezone)
+      availabilityMatchesSelectedDate(selectedAvailability, selectedDate, companyTimezone) &&
+      findMergedAvailabilityForSelection(eligibleTimes, selectedAvailability)
     ) {
       return;
     }
-    const toSelect = pickDefaultAvailabilityForTimes(
-      getPickupCutoffEligibleTimesForDate(selectedDate),
-      activeOptions,
-    );
+    const toSelect = pickDefaultAvailabilityForTimes(eligibleTimes, activeOptions);
     if (toSelect) {
       setSelectedAvailability(toSelect);
+      setSelectedReturnOption(null);
       setError('');
+    } else if (selectedAvailability) {
+      setSelectedAvailability(null);
+      setSelectedReturnOption(null);
     }
   }, [
     selectedDate,
@@ -114,9 +122,47 @@ export function useStandardBookingAutoSelections({
     companyTimezone,
     getPickupCutoffEligibleTimesForDate,
     setSelectedAvailability,
+    setSelectedReturnOption,
     setError,
   ]);
 
+  useEffect(() => {
+    if (!autoSelectFirstAvailableDate) return;
+    if (isPartialLaunch) return;
+    if (!selectedDate || dates.length === 0) return;
+    if (selectedDateHasVisibleAvailability(selectedDate, getPickupCutoffEligibleTimesForDate)) return;
+
+    const first = findFirstDateWithBookableAvailability(
+      dates,
+      getPickupCutoffEligibleTimesForDate,
+      (availability) => (availability.vacancies ?? 0) > 0,
+    );
+    if (!first || first === selectedDate) return;
+
+    hasAutoSelectedPartnerDateRef.current = true;
+    setSelectedDate(first);
+    setSelectedReturnOption(null);
+    setSelectedAvailability(
+      pickDefaultAvailabilityForTimes(getPickupCutoffEligibleTimesForDate(first), activeOptions),
+    );
+    if (!suppressCalendarDateScroll) {
+      scrollAfterCalendarSelection(contentRef, useWindowScroll);
+    }
+  }, [
+    autoSelectFirstAvailableDate,
+    isPartialLaunch,
+    selectedDate,
+    dates,
+    getPickupCutoffEligibleTimesForDate,
+    activeOptions,
+    setSelectedAvailability,
+    setSelectedDate,
+    setSelectedReturnOption,
+    suppressCalendarDateScroll,
+    contentRef,
+    useWindowScroll,
+  ]);
+
   useEffect(() => {
     if (!selectedAvailability?.returnOptions?.length || selectedReturnOption) return;
 
@@ -162,8 +208,10 @@ export function useStandardBookingAutoSelections({
     if (dates.length === 0) return;
     if (hasAutoSelectedPartnerDateRef.current) return;
 
-    const firstWithInventory = dates.find((date) =>
-      getPickupCutoffEligibleTimesForDate(date).some((availability) => (availability.vacancies ?? 0) > 0),
+    const firstWithInventory = findFirstDateWithBookableAvailability(
+      dates,
+      getPickupCutoffEligibleTimesForDate,
+      (availability) => (availability.vacancies ?? 0) > 0,
     );
     const first = firstWithInventory ?? (isAdmin && dates[0] ? dates[0] : undefined);
     if (!first) return;