@ticketboothapp/booking 1.2.166 → 1.2.168

package/src/components/booking/admin-refund-decision-context.ts

@@ -0,0 +1,122 @@
+import type {
+  AdminAmendmentOperationSnapshot,
+  AdminAmendmentRefundDisposition,
+} from '../../lib/booking-api';
+
+export interface AdminRefundDecisionContext {
+  selectionKey: string;
+  operations: AdminAmendmentOperationSnapshot[];
+  allowedByOperationId: Record<string, AdminAmendmentRefundDisposition[]>;
+  removedValueByOperationId: Record<string, number>;
+}
+
+interface MergeAdminRefundDecisionContextParams {
+  current: AdminRefundDecisionContext | null;
+  selectionKey: string;
+  operations: AdminAmendmentOperationSnapshot[];
+  allowedByOperationId: Record<string, AdminAmendmentRefundDisposition[]>;
+  removedValueByOperationId: Record<string, number>;
+}
+
+/**
+ * Refund-decision quote responses are incremental: after one operation is answered,
+ * the server can return only the operations that still need an answer. Keep all of
+ * the operations for the current booking selection so an answered operation does
+ * not disappear from the next request and get requested again.
+ */
+export function mergeAdminRefundDecisionContext({
+  current,
+  selectionKey,
+  operations,
+  allowedByOperationId,
+  removedValueByOperationId,
+}: MergeAdminRefundDecisionContextParams): AdminRefundDecisionContext | null {
+  const sameSelection = current?.selectionKey === selectionKey ? current : null;
+  if (!sameSelection && operations.length === 0) return null;
+
+  const operationsById = new Map<string, AdminAmendmentOperationSnapshot>();
+  for (const operation of sameSelection?.operations ?? []) {
+    operationsById.set(operation.operationId, operation);
+  }
+  for (const operation of operations) {
+    operationsById.set(operation.operationId, operation);
+  }
+
+  const relevantOperationIds = new Set(operationsById.keys());
+  const mergedAllowed = {
+    ...(sameSelection?.allowedByOperationId ?? {}),
+    ...allowedByOperationId,
+  };
+  const mergedRemovedValues = {
+    ...(sameSelection?.removedValueByOperationId ?? {}),
+    ...removedValueByOperationId,
+  };
+
+  return {
+    selectionKey,
+    operations: [...operationsById.values()],
+    allowedByOperationId: Object.fromEntries(
+      Object.entries(mergedAllowed).filter(([operationId]) =>
+        relevantOperationIds.has(operationId),
+      ),
+    ),
+    removedValueByOperationId: Object.fromEntries(
+      Object.entries(mergedRemovedValues).filter(([operationId]) =>
+        relevantOperationIds.has(operationId),
+      ),
+    ),
+  };
+}
+
+export function selectRefundDispositionsForOperations(
+  context: AdminRefundDecisionContext | null,
+  additionalOperations: AdminAmendmentOperationSnapshot[],
+  dispositionsByOperationId: Record<string, AdminAmendmentRefundDisposition>,
+): Record<string, AdminAmendmentRefundDisposition> {
+  const relevantOperationIds = new Set([
+    ...(context?.operations ?? []).map((operation) => operation.operationId),
+    ...additionalOperations.map((operation) => operation.operationId),
+  ]);
+  return Object.fromEntries(
+    Object.entries(dispositionsByOperationId).filter(([operationId]) =>
+      relevantOperationIds.has(operationId),
+    ),
+  );
+}
+
+/**
+ * Staff removals default to a pending refund. The refund remains a separate,
+ * reviewed action; this only removes the required choice from the change form.
+ */
+export function defaultPendingRefundDispositions(
+  operations: readonly AdminAmendmentOperationSnapshot[],
+  dispositionsByOperationId: Record<string, AdminAmendmentRefundDisposition>,
+): Record<string, AdminAmendmentRefundDisposition> {
+  if (operations.length === 0) return dispositionsByOperationId;
+
+  return operations.reduce<Record<string, AdminAmendmentRefundDisposition>>(
+    (next, operation) => {
+      next[operation.operationId] = 'PENDING_REFUND';
+      return next;
+    },
+    { ...dispositionsByOperationId },
+  );
+}
+
+/**
+ * Omitting a disposition for a return-price treatment operation tells the server
+ * to retain the original paid return-price floor.
+ */
+export function defaultKeepOriginalReturnPriceDispositions(
+  operations: readonly AdminAmendmentOperationSnapshot[],
+  dispositionsByOperationId: Record<string, AdminAmendmentRefundDisposition>,
+): Record<string, AdminAmendmentRefundDisposition> {
+  if (operations.length === 0) return dispositionsByOperationId;
+
+  const returnOperationIds = new Set(operations.map((operation) => operation.operationId));
+  return Object.fromEntries(
+    Object.entries(dispositionsByOperationId).filter(
+      ([operationId]) => !returnOperationIds.has(operationId),
+    ),
+  );
+}

package/src/components/booking/admin-refund-disposition.ts

@@ -74,10 +74,79 @@ export function normalizeReturnPriceTreatment(
     : 'KEEP_FLOOR';
 }
 
-export function adminRemovalOperationLabel(operation: AdminAmendmentOperationSnapshot): string {
+export type AdminRemovalOperationLabelContext = {
+  sourceProductName?: string | null;
+  targetProductName?: string | null;
+  promoCode?: string | null;
+  manualAdjustmentLabelsById?: Readonly<Record<string, string>>;
+};
+
+function conciseTourName(name: string): string {
+  const beforeTourDescription = name.split(/\s+Tour:\s*/i)[0]?.trim() || name.trim();
+  return beforeTourDescription.replace(/\s+Tour$/i, '').trim();
+}
+
+export function adminRemovalOperationLabel(
+  operation: AdminAmendmentOperationSnapshot,
+  context: AdminRemovalOperationLabelContext = {},
+): string {
+  if (operation.type === 'REVERSE_MANUAL_ADJUSTMENT') {
+    const adjustmentId = operation.componentKey.startsWith('manual_adjustment:')
+      ? operation.componentKey.slice('manual_adjustment:'.length)
+      : '';
+    const label = operation.metadata?.displayName?.trim() || (
+      adjustmentId
+        ? context.manualAdjustmentLabelsById?.[adjustmentId]?.trim()
+        : ''
+    );
+    return label ? `Remove adjustment: ${label}` : 'Remove existing adjustment';
+  }
+  if (
+    operation.type === 'ADD_MANUAL_ADJUSTMENT' &&
+    operation.componentKey.startsWith('manual_adjustment:promo_') &&
+    context.promoCode?.trim()
+  ) {
+    return `Apply promo to entire booking: ${context.promoCode.trim().toUpperCase()}`;
+  }
+  if (operation.type === 'ADD_MANUAL_ADJUSTMENT') {
+    const adjustmentId = operation.componentKey.startsWith('manual_adjustment:')
+      ? operation.componentKey.slice('manual_adjustment:'.length)
+      : '';
+    const label = adjustmentId
+      ? context.manualAdjustmentLabelsById?.[adjustmentId]?.trim()
+      : '';
+    if (label) return label;
+  }
+  if (
+    operation.type === 'MOVE_SERVICE' &&
+    context.sourceProductName?.trim() &&
+    context.targetProductName?.trim()
+  ) {
+    return `Change tour: ${conciseTourName(context.sourceProductName)} → ${conciseTourName(context.targetProductName)}`;
+  }
   const component = operation.componentKey.split(':').slice(1).join(':') || operation.componentKey;
   const quantity = operation.quantityDelta ? ` (${Math.abs(operation.quantityDelta)})` : '';
-  return `${operation.type.replaceAll('_', ' ').toLowerCase()}: ${component}${quantity}`;
+  const operationName = operation.type.replaceAll('_', ' ').toLowerCase();
+  return `${operationName.charAt(0).toUpperCase()}${operationName.slice(1)}: ${component}${quantity}`;
+}
+
+export function refundTreatmentDisplayValue(
+  operation: AdminAmendmentOperationSnapshot,
+  operations: readonly AdminAmendmentOperationSnapshot[],
+  removedValueByOperationId: Readonly<Record<string, number>>,
+  refundCandidate: number,
+): number | undefined {
+  const removedValue = removedValueByOperationId[operation.operationId];
+  if (!Number.isFinite(removedValue)) return undefined;
+
+  // With one decision, the server's aggregate refund candidate is the exact amount
+  // that can be returned after first reducing any unpaid booking balance. Keep the
+  // gross removed value available to the settlement helpers, but do not present it
+  // to an operator as if the entire amount were refundable.
+  if (operations.length === 1 && Number.isFinite(refundCandidate)) {
+    return Math.min(Math.max(0, refundCandidate), Math.max(0, removedValue));
+  }
+  return removedValue;
 }
 
 export function refundDecisionsComplete(

package/src/components/booking/availability-date-selection.ts

@@ -0,0 +1,16 @@
+import type { Availability } from '../../lib/booking-api';
+
+export function findFirstDateWithBookableAvailability(
+  dates: string[],
+  getRowsForDate: (date: string) => Availability[],
+  isBookable: (availability: Availability) => boolean,
+): string | undefined {
+  return dates.find((date) => getRowsForDate(date).some(isBookable));
+}
+
+export function selectedDateHasVisibleAvailability(
+  selectedDate: string,
+  getRowsForDate: (date: string) => Availability[],
+): boolean {
+  return selectedDate !== '' && getRowsForDate(selectedDate).length > 0;
+}

package/src/components/booking/booking-flow-types.ts

@@ -177,6 +177,10 @@ export interface ChangeBookingFlowProps extends BookingFlowBaseProps {
       label?: string;
       amount?: number;
       quantity?: number;
+      reference?: string | null;
+      identity?: {
+        componentId?: string | null;
+      } | null;
       priceBasis?: import('../../lib/booking-api').PriceBasisSnapshot | null;
     }>;
   } | null;

package/src/components/booking/booking-flow.css

@@ -330,6 +330,11 @@
   padding: 0.5rem 0.85rem;
   min-height: 2.5rem;
 }
+.booking-flow-preflight .admin-custom-receipt-apply {
+  box-sizing: border-box;
+  padding: 0.75rem 1.5rem;
+  min-height: 2.75rem;
+}
 
 /* Labels */
 .booking-flow-preflight label {

package/src/components/booking/change-booking-error-message.ts

@@ -0,0 +1,137 @@
+const CHANGE_BOOKING_ERROR_MESSAGES: Record<string, string> = {
+  pricing_v2_unsupported_features:
+    'Some selected booking options do not work together. Review the highlighted selections before continuing.',
+  pricing_v2_capacity_unavailable:
+    'There is not enough availability for this change. Choose another time or reduce the number of guests.',
+  pricing_v2_availability_required:
+    'Choose an available date and time before continuing.',
+  pricing_v2_availability_mismatch:
+    'The selected date or time is no longer available for this tour. Choose another option and try again.',
+  pricing_v2_invalid_passenger_counts:
+    'Review the number and types of guests before continuing.',
+  pricing_v2_product_option_not_found:
+    'The selected tour option is no longer available. Refresh and choose another option.',
+  pricing_v2_price_not_available:
+    'A confirmed price is not available for this selection. Choose another option or try again.',
+  pricing_v2_return_price_not_found:
+    'A confirmed price is not available for the selected return. Choose another return time.',
+  pricing_v2_itinerary_not_available:
+    'An itinerary is not available for this selection. Choose another date, time, or pickup location.',
+  pricing_v2_invalid_additional_hours:
+    'Review the number of additional hours before continuing.',
+  pricing_v2_additional_hours_not_supported:
+    'Additional hours are not available for the selected tour.',
+  pricing_v2_dependent_add_on_not_available:
+    'A linked add-on is not available with this change. Review the linked booking before continuing.',
+  pricing_v2_dependent_add_on_currency_mismatch:
+    'A linked add-on uses a different currency and cannot be changed with this booking.',
+  pricing_v2_invalid_admin_adjustment:
+    'Review the custom pricing adjustment before continuing.',
+  pricing_v2_cancellation_policy_not_authorized:
+    'The selected cancellation policy cannot be used for this booking.',
+  pricing_v2_cancellation_upgrade_fee_not_found:
+    'A confirmed price is not available for the selected cancellation-policy upgrade.',
+  pricing_v2_pricing_profile_not_authorized:
+    'The selected pricing option cannot be used for this booking.',
+  pricing_v2_non_no_change_not_implemented:
+    'This combination of changes is not supported yet. Try changing one booking option at a time.',
+  pricing_v2_admin_amendment_payment_disabled:
+    'Payments for booking changes are temporarily unavailable. Try again later.',
+  pricing_v2_admin_apply_disabled:
+    'Saving booking changes is temporarily unavailable. Try again later.',
+  pricing_v2_admin_quote_disabled:
+    'Pricing booking changes is temporarily unavailable. Try again later.',
+  apply_v2_not_enabled:
+    'Booking changes are temporarily unavailable. Try again later.',
+  admin_refund_disposition_required:
+    'Choose how to handle the removed paid value before continuing.',
+  admin_refund_disposition_not_supported:
+    'The selected refund treatment is not available for this change.',
+  admin_refund_disposition_invalid:
+    'Choose a valid refund treatment before continuing.',
+  amendment_refund_disposition_not_supported:
+    'The selected refund treatment is not available for this change.',
+  amendment_quote_blocked:
+    'This booking change cannot be completed with the selected options.',
+  admin_ledger_requires_review_or_repair:
+    'This booking needs a financial review before it can be changed.',
+  amendment_ledger_summary_missing:
+    'This booking needs a financial review before it can be changed.',
+  amendment_ledger_components_missing:
+    'This booking needs a financial review before it can be changed.',
+  booking_amendment_ledger_pointer_mismatch:
+    'This booking changed after the page was opened. Refresh it before trying again.',
+  promo_change_only_no_eligible_new_value:
+    'This promo only applies to new charges. Make a priced change, or choose Entire active booking.',
+  structured_adjustment_basis_is_zero:
+    'This credit needs a value to apply to. Make a priced booking change, or choose All active tickets, Entire active booking, or Selected components.',
+};
+
+function readableList(values: string[]): string {
+  if (values.length <= 1) return values[0] ?? '';
+  if (values.length === 2) return `${values[0]} and ${values[1]}`;
+  return `${values.slice(0, -1).join(', ')}, and ${values.at(-1)}`;
+}
+
+export function incompatibleAddOnChangeError(
+  addOnNames: readonly string[],
+  targetTourName: string | null | undefined,
+): string {
+  const names = Array.from(new Set(addOnNames.map((name) => name.trim()).filter(Boolean)));
+  const tour = targetTourName?.trim();
+  const itemLabel = readableList(names) || 'The selected add-on';
+  const availability = tour
+    ? `${itemLabel} ${names.length > 1 ? "aren't" : "isn't"} available with ${tour}.`
+    : `${itemLabel} ${names.length > 1 ? "aren't" : "isn't"} available with the selected tour.`;
+  const action = names.length > 1
+    ? 'Remove these add-ons or choose a different tour.'
+    : 'Remove the add-on or choose a different tour.';
+  return `${availability} ${action}`;
+}
+
+function errorCodeFromMessage(message: string): string | null {
+  const match = message.match(
+    /\b(?:pricing_v2|apply_v2|promo|admin|amendment|booking_amendment|quote|structured_adjustment)_[a-z0-9_]+/i,
+  );
+  return match?.[0]?.toLowerCase() ?? null;
+}
+
+/**
+ * Converts stable server reason codes into operator-facing copy while preserving
+ * messages that are already written for people.
+ */
+export function friendlyChangeBookingError(message: string | null | undefined): string {
+  const trimmed = message?.trim() ?? '';
+  if (!trimmed) return '';
+
+  const code = errorCodeFromMessage(trimmed);
+  if (!code) return trimmed;
+
+  const exact = CHANGE_BOOKING_ERROR_MESSAGES[code];
+  if (exact) return exact;
+
+  if (code.startsWith('admin_adjustment_refund_disposition_required')) {
+    return 'Choose how to handle the removed adjustment value before continuing.';
+  }
+  if (
+    code.includes('expired') ||
+    code.includes('hash_mismatch') ||
+    code.includes('revision_mismatch') ||
+    code.includes('receipt_mismatch') ||
+    code.includes('status_mismatch') ||
+    code.includes('stale')
+  ) {
+    return 'This booking or price changed after the page was opened. Refresh it and try again.';
+  }
+  if (code.includes('capacity') || code.includes('unavailable')) {
+    return 'The selected booking option is no longer available. Choose another option and try again.';
+  }
+  if (code.includes('required') || code.includes('missing')) {
+    return 'More information is required before this booking change can be completed. Review the selections and try again.';
+  }
+  if (code.includes('invalid') || code.includes('mismatch')) {
+    return 'This booking change could not be verified. Refresh the booking and try again.';
+  }
+
+  return 'This booking change cannot be completed with the selected options. Review the selections and try again.';
+}

package/src/components/booking/change-booking-flow-helpers.ts

@@ -95,6 +95,70 @@ export function resolveTicketQtyFromQuantities(
   return undefined;
 }
 
+/**
+ * Carry the original ticket counts into an amendment only when the selected
+ * availability can price those categories. This prevents a private shuttle's
+ * hidden RESOURCE count from leaking into a regular-tour quote (and vice versa).
+ */
+export function deriveCompatibleInitialBookingQuantities(
+  bookingItems: ReadonlyArray<{ category?: string | null; count?: number | null }>,
+  availability: Availability,
+): Record<string, number> {
+  const allowedCategories = new Map<string, string>();
+  for (const category of [
+    ...(availability.rates ?? []).map((rate) => rate.category),
+    ...(availability.pricesByCategory?.retailPrices ?? []).map((price) => price.category),
+  ]) {
+    const trimmed = category?.trim();
+    if (trimmed) allowedCategories.set(trimmed.toUpperCase(), trimmed);
+  }
+
+  const quantities: Record<string, number> = {};
+  for (const item of bookingItems) {
+    const sourceCategory = item.category?.trim();
+    if (!sourceCategory) continue;
+    const normalizedCategory = sourceCategory.toUpperCase();
+    const matchedCategory = allowedCategories.get(normalizedCategory);
+    if (allowedCategories.size > 0 && !matchedCategory) continue;
+    if (allowedCategories.size === 0 && availability.productType === 'STANDARD' && normalizedCategory === 'RESOURCE') {
+      continue;
+    }
+    if (allowedCategories.size === 0 && availability.productType === 'PRIVATE_SHUTTLE' && normalizedCategory !== 'RESOURCE') {
+      continue;
+    }
+    quantities[matchedCategory ?? sourceCategory] = Math.max(0, Number(item.count) || 0);
+  }
+  return quantities;
+}
+
+export function resolveChangeBookingCancellationPolicyId(
+  currentPolicyId: string | null | undefined,
+  policies: NonNullable<PricingConfig['cancellationPolicies']>,
+  currency: string,
+  forceTargetDefault: boolean,
+): string | null {
+  if (policies.length === 0) return null;
+  const current = currentPolicyId?.trim();
+  if (!forceTargetDefault && current && policies.some((policy) => policy.id === current)) {
+    return current;
+  }
+  return [...policies]
+    .sort((a, b) => (a.feeByCurrency[currency] ?? 0) - (b.feeByCurrency[currency] ?? 0))[0]
+    ?.id ?? null;
+}
+
+export function isProductFamilyReceiptConversion(
+  originalLines: PriceSummaryLine[],
+  resultingLines: PriceSummaryLine[],
+): boolean {
+  if (resultingLines.length === 0) return false;
+  const containsResourceTicket = (lines: PriceSummaryLine[]): boolean =>
+    lines.some(
+      (line) => line.kind === 'ticket' && line.category.trim().toUpperCase() === 'RESOURCE',
+    );
+  return containsResourceTicket(originalLines) !== containsResourceTicket(resultingLines);
+}
+
 export function mergePickerTicketQtyIntoPriceSummaryLines(
   lines: PriceSummaryLine[],
   quantities: Record<string, number>,
@@ -632,7 +696,8 @@ export function resolveInitialAvailabilityFromBooking(
   bookingItems: Array<{ category: string; count: number }> | null | undefined,
   precomputedPricesByOption: Record<string, PrecomputedPricesByCategory> | null | undefined,
   currency: Currency,
-  originalSubtotalBeforeTax: number | undefined
+  originalSubtotalBeforeTax: number | undefined,
+  preferredFallbackProductOptionId?: string | null
 ): { selection: Availability | null; defer: boolean } {
   const availId = initialAvailabilityId?.trim() || null;
   const optId = initialProductOptionId?.trim() || null;
@@ -719,7 +784,17 @@ export function resolveInitialAvailabilityFromBooking(
     }
   }
 
-  const fallback = timesForSelectedDate.find((a) => a.vacancies > 0) ?? null;
+  const preferredFallback = preferredFallbackProductOptionId
+    ? timesForSelectedDate.find(
+        (availability) =>
+          availability.productOptionId === preferredFallbackProductOptionId &&
+          availability.vacancies > 0,
+      )
+    : null;
+  const fallback =
+    preferredFallback ??
+    timesForSelectedDate.find((availability) => availability.vacancies > 0) ??
+    null;
   return { selection: fallback, defer: false };
 }
 

package/src/components/booking/change-booking-quote-guards.ts

@@ -5,6 +5,7 @@ import {
   roundMoney,
   type ChangeQuoteUiSlice,
 } from '../../lib/booking/change-flow-pricing';
+import { friendlyChangeBookingError } from './change-booking-error-message';
 
 const CHANGE_PAYMENT_CONFIRMATION_ERROR =
   'This change requires payment, but the price could not be confirmed. Please refresh and try again.';
@@ -162,7 +163,9 @@ export function evaluateChangeBookingQuoteForCheckout(
   } = params;
 
   if (!quoteSlice.canProceed) {
-    throw new Error(quote.reasonIfBlocked || 'This booking change cannot be completed right now.');
+    throw new Error(friendlyChangeBookingError(
+      quote.reasonIfBlocked || 'This booking change cannot be completed right now.',
+    ));
   }
 
   const signedBalanceMajor = resolveSignedBalanceMajor(quote);

package/src/components/booking/change-booking-quote-state.ts

@@ -1,4 +1,7 @@
-import type { ChangeBookingQuoteResponse } from '../../lib/booking-api';
+import type {
+  ChangeBookingQuoteResponse,
+  ItineraryDisplayStep,
+} from '../../lib/booking-api';
 import {
   type ChangeQuoteUiSlice,
   sliceChangeQuoteForUi,
@@ -11,10 +14,47 @@ import {
   buildChangeBookingServerPreview,
 } from '../../lib/booking/change-booking-server-preview';
 import type { Currency } from './CurrencySwitcher';
+import { selectableAdminAdjustmentComponentsFromQuote } from './admin-adjustment-components';
 
 export type ChangeBookingServerPreview = ReturnType<typeof buildChangeBookingServerPreview>;
 export type ChangeBookingMergedQuoteState = ReturnType<typeof mergeQuoteSliceWithServerPreview>;
 
+function isItineraryDisplayStep(value: unknown): value is ItineraryDisplayStep {
+  if (value == null || typeof value !== 'object') return false;
+  const step = value as Partial<ItineraryDisplayStep>;
+  return (
+    typeof step.stepType === 'string' &&
+    typeof step.time === 'string' &&
+    typeof step.place === 'string'
+  );
+}
+
+/**
+ * Reads the canonical itinerary embedded in a Pricing V2 amendment quote.
+ *
+ * The server merges confirmed dependent add-on sessions into this itinerary, so change-booking
+ * comparison UIs must prefer it over a client-side product itinerary recomputation.
+ */
+export function authoritativeItineraryDisplayFromChangeQuote(
+  quote: ChangeBookingQuoteResponse,
+): ItineraryDisplayStep[] | null {
+  const pricingQuote = quote.pricingQuote ?? quote.quote;
+  const rawItinerary = pricingQuote?.amendment?.targetState?.nonPriceState?.itinerary;
+  if (rawItinerary == null) return null;
+
+  let parsed: unknown = rawItinerary;
+  if (typeof rawItinerary === 'string') {
+    try {
+      parsed = JSON.parse(rawItinerary);
+    } catch {
+      return null;
+    }
+  }
+
+  if (!Array.isArray(parsed) || !parsed.every(isItineraryDisplayStep)) return null;
+  return parsed.map((step) => ({ ...step }));
+}
+
 export function mergeQuoteSliceWithServerPreview(
   slice: ChangeQuoteUiSlice,
   quote: ChangeBookingQuoteResponse,
@@ -25,8 +65,11 @@ export function mergeQuoteSliceWithServerPreview(
     ...slice,
     currency: (slice.currency || currency) as Currency,
     serverPreview: buildChangeBookingServerPreview(quote, fallbackCart, currency),
+    authoritativeItineraryDisplay: authoritativeItineraryDisplayFromChangeQuote(quote),
     pricingDriftDetail: normalizePricingDriftDetailFromQuote(quote),
     ticketPricingTrace: normalizeTicketPricingTraceFromQuote(quote),
+    selectableAdjustmentComponents: selectableAdminAdjustmentComponentsFromQuote(quote),
+    reversibleAdjustments: quote.reversibleAdjustments ?? [],
     /** Same cent pair the BE uses for `amountDueCents` / intent & receipt "New Booking Difference". */
     quotePreviousTotalCents: quote.previousTotalCents,
     quoteNewTotalCents: quote.newTotalCents,

package/src/components/booking/incompatible-add-on-selections.ts

@@ -0,0 +1,19 @@
+import type { AddOn } from '../../lib/booking-api';
+import type { AddOnSelection } from './AddOnsSection';
+
+export function incompatibleAddOnSelections(
+  selections: AddOnSelection[],
+  availableAddOns: AddOn[],
+  catalogLoaded: boolean,
+): AddOnSelection[] {
+  if (!catalogLoaded) return [];
+  const availableIds = new Set(availableAddOns.map((addOn) => addOn.addOnId));
+  return selections.filter((selection) => !availableIds.has(selection.addOnId));
+}
+
+export function removeAddOnSelections(
+  selections: AddOnSelection[],
+  addOnId: string,
+): AddOnSelection[] {
+  return selections.filter((selection) => selection.addOnId !== addOnId);
+}

package/src/components/booking/private-shuttle-availability.ts

@@ -20,6 +20,20 @@ export function parseAvailabilityDateTime(value: string): Date {
   return parseISO(hasExplicitOffset ? value : `${value}Z`);
 }
 
+export function privateShuttleInitialDateKey(
+  value: string | null | undefined,
+  timezone: string,
+): string {
+  const trimmed = value?.trim();
+  if (!trimmed) return '';
+  if (DATE_ONLY_REGEX.test(trimmed)) return trimmed;
+  try {
+    return formatInTimeZone(parseAvailabilityDateTime(trimmed), timezone, 'yyyy-MM-dd');
+  } catch {
+    return '';
+  }
+}
+
 export function privateShuttleStartDateTime(dateStr: string, timeStr: string, timezone: string): Date {
   return fromZonedTime(parseISO(`${dateStr}T${timeStr}:00`), timezone);
 }

package/src/components/booking/private-shuttle-cancellation-policy.ts

@@ -0,0 +1,9 @@
+export function resolvePrivateShuttleCancellationPolicyId(
+  currentPolicyId: string | null | undefined,
+  availablePolicyIds: readonly string[],
+): string | null {
+  const validIds = availablePolicyIds.map((id) => id.trim()).filter(Boolean);
+  const current = currentPolicyId?.trim();
+  if (current && validIds.includes(current)) return current;
+  return validIds[0] ?? null;
+}

package/src/components/booking/private-shuttle-checkout-controller.ts

@@ -309,7 +309,9 @@ export function usePrivateShuttleCheckoutController({
       if (isProviderChangeMode && onChangeBooking) {
         await applyPrivateShuttleProviderChange({
           onChangeBooking,
+          parentProductId: productId,
           selectedOption,
+          selectedAvailabilityId: selectedAvailability?.availabilityId ?? null,
           selectedDate,
           selectedStartTime,
           billableResourceCount,
@@ -325,6 +327,9 @@ export function usePrivateShuttleCheckoutController({
           activePromoCode,
           totalPrice,
           additionalHoursCount,
+          draftItineraryDestinations,
+          draftItineraryPlanningNotes,
+          itineraryDisplayItems,
           isAdmin,
           providerChangeAuthoritativeReceipt,
         });