@ticketboothapp/booking 1.2.167 → 1.2.168

package/test/change-booking-helpers.test.ts

@@ -24,12 +24,24 @@ import {
 } from '../src/components/booking/availability-date-selection';
 import {
   buildChangeBookingServerPreview,
+  labelAdminAmendmentPriceSummaryLines,
   mapQuoteLineItemsToPriceSummaryLines,
 } from '../src/lib/booking/change-booking-server-preview';
 import {
   buildAdminChangeQuoteRequestKey,
+  canRequestAdminChangeQuote,
   canReuseCompletedAdminChangeQuote,
 } from '../src/components/booking/admin-change-quote-request-key';
+import {
+  authoritativeItineraryDisplayFromChangeQuote,
+  sliceAndMergeChangeQuoteForUi,
+} from '../src/components/booking/change-booking-quote-state';
+import { selectableAdminAdjustmentComponentsFromQuote } from '../src/components/booking/admin-adjustment-components';
+import {
+  adminAdjustmentTaxBehaviorOptions,
+  normalizeAdminAdjustmentScopeForSign,
+  normalizeAdminAdjustmentTaxBehavior,
+} from '../src/components/booking/admin-adjustment-tax-behavior';
 import {
   buildAdminChangeV2QuoteRequest,
   quoteAdminChangeV2ForUi,
@@ -37,16 +49,21 @@ import {
 import {
   noRefundRemovedValue,
   normalizeReturnPriceTreatment,
+  adminRemovalOperationLabel,
+  refundTreatmentDisplayValue,
   refundDecisionsComplete,
   releaseRefundDispositionOptions,
   returnPriceTreatmentOptions,
 } from '../src/components/booking/admin-refund-disposition';
 import {
+  defaultKeepOriginalReturnPriceDispositions,
+  defaultPendingRefundDispositions,
   mergeAdminRefundDecisionContext,
   selectRefundDispositionsForOperations,
 } from '../src/components/booking/admin-refund-decision-context';
 import {
   applyResourceAdjustments,
+  privateShuttleInitialDateKey,
   privateShuttlePriceChanged,
   resolveHydratedPrivateShuttleAvailability,
 } from '../src/components/booking/private-shuttle-availability';
@@ -57,13 +74,36 @@ import {
   reservationHoldSecondsRemaining,
 } from '../src/components/booking/reservation-hold';
 import { buildAdminChangeProviderPayload } from '../src/components/booking/admin-change-provider-payload';
-import { buildPublicChangeAmountDueSummary } from '../src/components/booking/change-booking-flow-helpers';
+import {
+  buildPublicChangeAmountDueSummary,
+  deriveCompatibleInitialBookingQuantities,
+  isProductFamilyReceiptConversion,
+  resolveChangeBookingCancellationPolicyId,
+  resolveInitialAvailabilityFromBooking,
+} from '../src/components/booking/change-booking-flow-helpers';
 import { collapseAdminPromoLines } from '../src/components/booking/admin-change-receipt-lines';
 import {
   buildAdminChangePaymentChoiceData,
   buildAdminChangePayNowCheckoutModalData,
   shouldRestoreAdminChangePaymentChoiceAfterCheckoutClose,
 } from '../src/components/booking/admin-change-payment-choice-runner';
+import { shouldLockExistingAddOnQuantities } from '../src/components/booking/admin-change-flow-state-helpers';
+import { haveAddOnSelectionsChanged } from '../src/components/booking/useChangeBookingSelectionDetails';
+import {
+  incompatibleAddOnSelections,
+  removeAddOnSelections,
+} from '../src/components/booking/incompatible-add-on-selections';
+import {
+  friendlyChangeBookingError,
+  incompatibleAddOnChangeError,
+} from '../src/components/booking/change-booking-error-message';
+import { applyPrivateShuttleProviderChange } from '../src/components/booking/private-shuttle-provider-change-runner';
+import { resolvePrivateShuttleCancellationPolicyId } from '../src/components/booking/private-shuttle-cancellation-policy';
+import { hasEffectiveAdminChangeSelection } from '../src/components/booking/useAdminProviderPricingAdjustments';
+import {
+  lineFromActiveAdjustment,
+  reverseAdjustmentIdsForAdminCustomLines,
+} from '../src/components/booking/useAdminCustomReceiptLines';
 
 function quote(overrides: Partial<ChangeBookingQuoteResponse>): ChangeBookingQuoteResponse {
   return {
@@ -106,6 +146,195 @@ function calendarAvailability(dateTime: string, vacancies: number): Availability
   return { dateTime, vacancies, currency: 'CAD' };
 }
 
+test('complete percentage-only admin adjustment requests a server quote', () => {
+  assert.equal(
+    hasEffectiveAdminChangeSelection({
+      hasChangeSelection: false,
+      providerPricingOverrideCount: 0,
+      providerHasAdditionalAdjustments: false,
+      isProviderDashboardChange: false,
+      editableSummaryPreSubtotalDelta: 0,
+      adminStructuredAdjustmentCount: 1,
+    }),
+    true,
+  );
+});
+
+test('reversing an existing admin adjustment is an effective change', () => {
+  assert.equal(
+    hasEffectiveAdminChangeSelection({
+      hasChangeSelection: false,
+      providerPricingOverrideCount: 0,
+      providerHasAdditionalAdjustments: false,
+      isProviderDashboardChange: true,
+      editableSummaryPreSubtotalDelta: 0,
+      adminStructuredAdjustmentCount: 0,
+      adminReverseAdjustmentCount: 1,
+    }),
+    true,
+  );
+});
+
+test('existing admin adjustment hydrates for immutable reverse-and-replace editing', () => {
+  const line = lineFromActiveAdjustment({
+    adjustmentId: 'admin-rcpt-1',
+    operationId: 'op-1',
+    mode: 'FIXED_AMOUNT',
+    scope: 'CURRENT_ACTIVE_BOOKING',
+    basisCents: 0,
+    amountCents: 2_000,
+    taxDeltaCents: 170,
+    affectedComponentIds: [],
+    taxBehavior: 'TAXABLE',
+    reasonCode: 'STAFF_ADJUSTMENT',
+    reason: 'Local test service fee',
+    createdAt: '2026-07-27T00:00:00Z',
+  }, 'admin-edit-session-1');
+
+  assert.equal(line.label, 'Local test service fee');
+  assert.equal(line.amountInput, '20.00');
+  assert.equal(line.sourceAdjustmentId, 'admin-rcpt-1');
+  assert.equal(line.replacementAdjustmentId, 'admin-edit-session-1');
+  assert.deepEqual(reverseAdjustmentIdsForAdminCustomLines([line]), []);
+  assert.deepEqual(
+    reverseAdjustmentIdsForAdminCustomLines([{ ...line, isDirty: true }]),
+    ['admin-rcpt-1'],
+  );
+  assert.deepEqual(reverseAdjustmentIdsForAdminCustomLines([], ['admin-rcpt-1']), ['admin-rcpt-1']);
+});
+
+test('private resource quantity is not carried into a regular-tour conversion', () => {
+  const quantities = deriveCompatibleInitialBookingQuantities(
+    [{ category: 'RESOURCE', count: 1 }],
+    {
+      dateTime: '2026-08-10T09:00:00-06:00',
+      vacancies: 10,
+      currency: 'CAD',
+      productType: 'STANDARD',
+      rates: [
+        { rateId: 'adult', category: 'ADULT', available: 10 },
+        { rateId: 'child', category: 'CHILD', available: 10 },
+      ],
+    },
+  );
+
+  assert.deepEqual(quantities, {});
+});
+
+test('compatible original ticket quantities are preserved for a regular-tour change', () => {
+  const quantities = deriveCompatibleInitialBookingQuantities(
+    [
+      { category: 'ADULT', count: 2 },
+      { category: 'CHILD', count: 1 },
+    ],
+    {
+      dateTime: '2026-08-10T09:00:00-06:00',
+      vacancies: 10,
+      currency: 'CAD',
+      productType: 'STANDARD',
+      rates: [
+        { rateId: 'adult', category: 'ADULT', available: 10 },
+        { rateId: 'child', category: 'CHILD', available: 10 },
+      ],
+    },
+  );
+
+  assert.deepEqual(quantities, { ADULT: 2, CHILD: 1 });
+});
+
+test('family conversion selects the target cancellation policy default', () => {
+  const policies = [
+    { id: 'standard', label: 'Standard', feeByCurrency: { CAD: 0 } },
+    { id: 'flexible', label: 'Flexible', feeByCurrency: { CAD: 25 } },
+  ];
+
+  assert.equal(
+    resolveChangeBookingCancellationPolicyId('private_shuttle', policies, 'CAD', true),
+    'standard',
+  );
+  assert.equal(
+    resolveChangeBookingCancellationPolicyId('flexible', policies, 'CAD', false),
+    'flexible',
+  );
+});
+
+test('resource and passenger receipts are recognized as a product-family conversion', () => {
+  assert.equal(
+    isProductFamilyReceiptConversion(
+      [{ kind: 'ticket', category: 'RESOURCE', qty: 1, itemTotal: 2199.99 }],
+      [{ kind: 'ticket', category: 'ADULT', qty: 1, itemTotal: 120.99 }],
+    ),
+    true,
+  );
+});
+
+test('server preview exposes the resulting receipt separately from ledger allocation lines', () => {
+  const preview = buildChangeBookingServerPreview(
+    quote({
+      pricingQuote: {
+        currency: 'CAD',
+        payableTotal: 148.62,
+        netSubtotalBeforeTax: 136.98,
+        taxAmount: 11.64,
+        amountPreviouslyPaid: 836.85,
+        amountToCharge: 0,
+        refundCandidate: 688.23,
+        lines: [
+          {
+            type: 'BOOKING_CHANGE',
+            label: 'Balance reduction · RESOURCE',
+            amount: -1670.89,
+          },
+        ],
+        amendment: {
+          updatedReceipt: {
+            total: 148.62,
+            lineItems: [
+              { type: 'TICKET', label: 'ADULT', amount: 120.99, quantity: 1 },
+              { type: 'FEE', label: 'Moraine Lake Road Access Fee', amount: 15.99 },
+              { type: 'TAX', label: 'Taxes and fees', amount: 11.64 },
+            ],
+          },
+        },
+      },
+      refundCandidate: 688.23,
+    }),
+    { total: 148.62, subtotal: 136.98, tax: 11.64 },
+    'CAD',
+  );
+
+  assert.deepEqual(
+    preview?.resultingReceiptLines?.map((line) =>
+      line.kind === 'ticket' ? line.category : line.label,
+    ),
+    ['ADULT', 'Moraine Lake Road Access Fee', 'Taxes and fees'],
+  );
+  assert.equal(preview?.amountDue, -688.23);
+});
+
+test('existing add-on quantities are locked only for customer self-service changes', () => {
+  assert.equal(
+    shouldLockExistingAddOnQuantities({ isCustomerSelfServeChange: true, isAdmin: false }),
+    true,
+  );
+  assert.equal(
+    shouldLockExistingAddOnQuantities({ isCustomerSelfServeChange: true, isAdmin: true }),
+    false,
+  );
+  assert.equal(
+    shouldLockExistingAddOnQuantities({ isCustomerSelfServeChange: false, isAdmin: true }),
+    false,
+  );
+});
+
+test('removing every existing add-on is detected as a booking change', () => {
+  const initialAddOnQtyByKey = new Map([
+    ['addon_el_lunch::blackforest_ham_sandwich_gatorade', 1],
+  ]);
+
+  assert.equal(haveAddOnSelectionsChanged(initialAddOnQtyByKey, []), true);
+});
+
 test('admin amendment display combines one promo allocation across component rows', () => {
   const lines = collapseAdminPromoLines([
     { kind: 'ticket', category: 'ADULT', qty: 1, itemTotal: 170.49 },
@@ -179,6 +408,48 @@ test('calendar auto-selection advances when the selected day has no visible star
   );
 });
 
+test('product change falls back to the most-popular available pickup', () => {
+  const times: Availability[] = [
+    {
+      availabilityId: 'availability_725',
+      productOptionId: 'option_725',
+      dateTime: '2026-07-30T07:25:00-06:00',
+      vacancies: 10,
+      currency: 'CAD',
+    },
+    {
+      availabilityId: 'availability_900',
+      productOptionId: 'option_900',
+      dateTime: '2026-07-30T09:00:00-06:00',
+      vacancies: 25,
+      currency: 'CAD',
+    },
+    {
+      availabilityId: 'availability_1300',
+      productOptionId: 'option_1300',
+      dateTime: '2026-07-30T13:00:00-06:00',
+      vacancies: 13,
+      currency: 'CAD',
+    },
+  ];
+
+  const result = resolveInitialAvailabilityFromBooking(
+    times,
+    new Date('2026-07-30T08:00:00-06:00'),
+    'America/Edmonton',
+    'old_product_availability',
+    null,
+    [{ category: 'ADULT', count: 1 }],
+    null,
+    'CAD',
+    235.98,
+    'option_900',
+  );
+
+  assert.equal(result.defer, false);
+  assert.equal(result.selection?.availabilityId, 'availability_900');
+});
+
 test('admin payment choice countdown expires exactly at the reservation deadline', () => {
   const expiration = '2026-07-16T15:46:44+00:00';
   assert.equal(
@@ -325,6 +596,26 @@ test('admin quote dedupe refetches unchanged inputs after the published quote is
   assert.equal(canReuseCompletedAdminChangeQuote(inputKey, 'different-inputs', true), false);
 });
 
+test('admin quote gate allows adjustment-only changes', () => {
+  assert.equal(canRequestAdminChangeQuote({
+    isCustomerSelfServeChange: true,
+    hasEffectiveChangeSelection: true,
+    hasSelectedAvailability: true,
+    bookingReference: 'DIFG66OF',
+    lastName: 'Tauro',
+    missingRequiredReturnSelection: false,
+  }), true);
+
+  assert.equal(canRequestAdminChangeQuote({
+    isCustomerSelfServeChange: true,
+    hasEffectiveChangeSelection: false,
+    hasSelectedAvailability: true,
+    bookingReference: 'DIFG66OF',
+    lastName: 'Tauro',
+    missingRequiredReturnSelection: false,
+  }), false);
+});
+
 test('admin preview and checkout share the Pricing V2 request shape', () => {
   const request = buildAdminChangeV2QuoteRequest({
     bookingReference: ' VFSCAEKQ ',
@@ -345,6 +636,7 @@ test('admin preview and checkout share the Pricing V2 request shape', () => {
     promoCode: ' banffblog15 ',
     promoApplicationScope: 'ENTIRE_BOOKING',
     structuredAdjustments: [{ type: 'CUSTOM', amount: 5 }],
+    includeSelectableAdjustmentComponents: true,
     refundDispositionsByOperationId: { remove_1: 'PENDING_REFUND' },
     previousPassengerCount: 2,
     previousAvailabilityId: 'availability_old',
@@ -358,6 +650,7 @@ test('admin preview and checkout share the Pricing V2 request shape', () => {
   assert.equal(request.promoCode, 'banffblog15');
   assert.equal(request.promoApplicationScope, 'ENTIRE_BOOKING');
   assert.deepEqual(request.refundDispositionsByOperationId, { remove_1: 'PENDING_REFUND' });
+  assert.equal(request.includeSelectableAdjustmentComponents, true);
   assert.deepEqual(request.capacitySeatCredit, {
     enabled: true,
     previousPassengerCount: 2,
@@ -517,8 +810,22 @@ test('admin removal quote preserves explicit release refund decisions for the pr
     quantityDelta: -1,
   };
   const mapped = mapAdminChangeBookingQuoteV2Data({
-    oldReceipt: { currency: 'CAD', grossSubtotal: 357.46, taxAmount: 30.38, payableTotal: 387.84 },
-    newQuote: { currency: 'CAD', payableTotal: 193.92, balanceDelta: 0, amountToCharge: 0, refundCandidate: 0 },
+    oldReceipt: {
+      currency: 'CAD',
+      grossSubtotal: 357.46,
+      paymentCreditTotal: 50,
+      taxAmount: 30.38,
+      payableTotal: 387.84,
+    },
+    newQuote: {
+      currency: 'CAD',
+      payableTotal: 193.92,
+      paymentCreditTotal: 25,
+      amountPreviouslyPaid: 148.62,
+      balanceDelta: 0,
+      amountToCharge: 0,
+      refundCandidate: 0,
+    },
     canApply: false,
     reasonIfBlocked: 'admin_refund_disposition_required',
     refundDecisionOperations: [operation],
@@ -538,6 +845,10 @@ test('admin removal quote preserves explicit release refund decisions for the pr
   );
 
   assert.deepEqual(slice.refundDecisionOperations, [operation]);
+  assert.equal(slice.amountPreviouslyPaid, 148.62);
+  assert.equal(slice.currentPaymentCreditTotal, 50);
+  assert.equal(slice.projectedPaymentCreditTotal, 25);
+  assert.equal(slice.refundCandidate, 0);
   assert.equal(slice.removedValueByOperationId?.[operation.operationId], 193.92);
   assert.deepEqual(
     releaseRefundDispositionOptions(
@@ -643,11 +954,62 @@ test('admin refund decisions remain stable when successive quotes return only un
   );
 });
 
+test('admin removal decisions default every required operation to pending refund', () => {
+  const removeReturn = {
+    operationId: 'op_remove_return',
+    type: 'REMOVE_RETURN',
+    componentKey: 'return:rt_morning',
+    quantityDelta: -1,
+  };
+  const removeAdult = {
+    operationId: 'op_remove_adult',
+    type: 'REMOVE_QUANTITY',
+    componentKey: 'ticket:ADULT',
+    quantityDelta: -1,
+  };
+
+  assert.deepEqual(
+    defaultPendingRefundDispositions(
+      [removeReturn, removeAdult],
+      {
+        unrelated_operation: 'NO_REFUND',
+        [removeAdult.operationId]: 'NO_REFUND',
+      },
+    ),
+    {
+      unrelated_operation: 'NO_REFUND',
+      [removeReturn.operationId]: 'PENDING_REFUND',
+      [removeAdult.operationId]: 'PENDING_REFUND',
+    },
+  );
+});
+
+test('admin return-price decisions always default to keeping the original paid floor', () => {
+  const returnOperation = {
+    operationId: 'op_change_return',
+    type: 'CHANGE_RETURN',
+    componentKey: 'return:rt_early',
+    quantityDelta: 0,
+  };
+
+  assert.deepEqual(
+    defaultKeepOriginalReturnPriceDispositions(
+      [returnOperation],
+      {
+        op_remove_adult: 'PENDING_REFUND',
+        [returnOperation.operationId]: 'NO_REFUND',
+      },
+    ),
+    { op_remove_adult: 'PENDING_REFUND' },
+  );
+});
+
 test('admin move-service quote labels only its ticket price difference', () => {
   const moveOperation = {
     operationId: 'op_move_service',
     type: 'MOVE_SERVICE',
     componentKey: 'service',
+    changedFields: ['availabilityId', 'dateTime'],
   };
   const addOperation = {
     operationId: 'op_add_adult',
@@ -830,6 +1192,46 @@ test('admin return price treatment defaults to keep floor and maps optional repr
   );
 });
 
+test('admin cross-tour move labels its ticket delta as a tour price difference', () => {
+  const [line] = labelAdminAmendmentPriceSummaryLines(
+    [{
+      kind: 'ticket',
+      operationId: 'op_move_tour',
+      category: 'Refund · ADULT',
+      qty: 1,
+      itemTotal: -99,
+    }],
+    [{
+      operationId: 'op_move_tour',
+      type: 'MOVE_SERVICE',
+      componentKey: 'service',
+      changedFields: ['productId', 'availabilityId', 'dateTime'],
+    }],
+    [{
+      kind: 'ticket',
+      category: 'ADULT',
+      qty: 1,
+      itemTotal: 219.99,
+    }],
+  );
+
+  assert.equal(
+    line?.kind === 'ticket' ? line.category : null,
+    'Refund · ADULT — tour price difference',
+  );
+  assert.deepEqual(
+    line?.kind === 'ticket' ? line.unitPriceComparison : null,
+    {
+      previousLabel: 'Existing adult price',
+      updatedLabel: 'New-tour adult price',
+      differenceLabel: 'Difference per adult',
+      previousUnitAmount: 219.99,
+      updatedUnitAmount: 120.99,
+      differenceUnitAmount: -99,
+    },
+  );
+});
+
 test('unsupported immediate refund cannot become a return price treatment', () => {
   assert.equal(normalizeReturnPriceTreatment(undefined), 'KEEP_FLOOR');
   assert.equal(normalizeReturnPriceTreatment('REFUND_TO_ORIGINAL_PAYMENT'), 'KEEP_FLOOR');
@@ -951,6 +1353,142 @@ test('private shuttle pricing replaces the selected calendar summary with hydrat
   assert.equal(applyResourceAdjustments(1699.99, resolved, 'CAD'), 2099.99);
 });
 
+test('private conversion keeps the existing booking day in the company timezone', () => {
+  assert.equal(
+    privateShuttleInitialDateKey('2026-07-28T01:05:00Z', 'America/Edmonton'),
+    '2026-07-27',
+  );
+  assert.equal(
+    privateShuttleInitialDateKey('2026-07-27', 'America/Edmonton'),
+    '2026-07-27',
+  );
+});
+
+test('private conversion replaces an incompatible source cancellation policy with the target default', () => {
+  assert.equal(
+    resolvePrivateShuttleCancellationPolicyId('standard_flexible', ['private_shuttle']),
+    'private_shuttle',
+  );
+  assert.equal(
+    resolvePrivateShuttleCancellationPolicyId('private_shuttle', ['private_shuttle']),
+    'private_shuttle',
+  );
+});
+
+test('admin standard-to-private conversion sends complete private target identity and state', async () => {
+  let captured: Parameters<typeof applyPrivateShuttleProviderChange>[0] extends {
+    onChangeBooking: (data: infer T) => Promise<void>;
+  }
+    ? T
+    : never;
+
+  await applyPrivateShuttleProviderChange({
+    onChangeBooking: async (data) => {
+      captured = data;
+    },
+    parentProductId: 'p_private',
+    selectedOption: 'po_private',
+    selectedAvailabilityId: 'a_private',
+    selectedDate: '2026-07-29',
+    selectedStartTime: '09:15',
+    billableResourceCount: 2,
+    pickupLocationId: 'pickup_hotel',
+    selectedPickupLocationName: 'Banff Hotel',
+    initialBooking: {
+      bookingReference: 'bookRef_TEST1234',
+      productId: 'po_standard',
+      availabilityId: 'a_standard',
+      dateTime: '2026-07-29T08:00:00-06:00',
+      bookingItems: [{ category: 'ADULT', count: 5 }],
+      returnAvailabilityId: 'ret_standard',
+    },
+    passengerCount: 5,
+    childSafetySeatsCount: 1,
+    foodRestrictions: 'No nuts',
+    addOnSelections: [],
+    cancellationPolicyId: 'flexible',
+    activePromoCode: null,
+    totalPrice: 1200,
+    additionalHoursCount: 1,
+    draftItineraryDestinations: ['moraine_lake'],
+    draftItineraryPlanningNotes: 'Photo stop requested',
+    itineraryDisplayItems: [
+      { time: '9:15 AM', label: 'Banff Hotel' },
+      { time: null, label: 'Moraine Lake', isProposedStops: true },
+      { time: '3:15 PM', label: 'Banff Hotel' },
+    ],
+    isAdmin: true,
+    providerChangeAuthoritativeReceipt: undefined,
+  });
+
+  assert.equal(captured!.parentProductId, 'p_private');
+  assert.equal(captured!.productId, 'po_private');
+  assert.equal(captured!.availabilityId, 'a_private');
+  assert.deepEqual(captured!.bookingItems, [{ category: 'RESOURCE', count: 2 }]);
+  assert.equal(captured!.returnAvailabilityId, null);
+  assert.equal(captured!.passengerCount, 5);
+  assert.equal(captured!.startTime, '2026-07-29T09:15:00-06:00');
+  assert.deepEqual(captured!.draftItinerary, {
+    destinations: ['moraine_lake'],
+    planningNotes: 'Photo stop requested',
+  });
+  assert.deepEqual(captured!.itineraryDisplay?.map((step) => step.stepType), [
+    'pickup',
+    'draft',
+    'drop_off',
+  ]);
+});
+
+test('private conversion stores the first actual location as pickup when proposed stops come first', async () => {
+  let captured: Parameters<typeof applyPrivateShuttleProviderChange>[0] extends {
+    onChangeBooking: (data: infer T) => Promise<void>;
+  }
+    ? T
+    : never;
+
+  await applyPrivateShuttleProviderChange({
+    onChangeBooking: async (data) => {
+      captured = data;
+    },
+    parentProductId: 'p_private',
+    selectedOption: 'po_private',
+    selectedAvailabilityId: 'a_private',
+    selectedDate: '2026-07-29',
+    selectedStartTime: '07:00',
+    billableResourceCount: 1,
+    pickupLocationId: 'pickup_hotel',
+    selectedPickupLocationName: 'Banff Hotel',
+    initialBooking: {
+      bookingReference: 'bookRef_TEST1234',
+      productId: 'po_standard',
+      availabilityId: 'a_standard',
+      dateTime: '2026-07-29T08:00:00-06:00',
+      bookingItems: [{ category: 'ADULT', count: 1 }],
+    },
+    passengerCount: 1,
+    childSafetySeatsCount: 0,
+    foodRestrictions: '',
+    addOnSelections: [],
+    cancellationPolicyId: 'private_shuttle',
+    activePromoCode: null,
+    totalPrice: 1200,
+    additionalHoursCount: 0,
+    draftItineraryDestinations: ['moraine_lake', 'lake_louise'],
+    draftItineraryPlanningNotes: '',
+    itineraryDisplayItems: [
+      { time: null, label: 'Moraine Lake, Lake Louise', isProposedStops: true },
+      { time: '7:00 AM', label: 'Banff Hotel' },
+    ],
+    isAdmin: true,
+    providerChangeAuthoritativeReceipt: undefined,
+  });
+
+  assert.deepEqual(captured!.itineraryDisplay, [
+    { stepType: 'draft', time: 'Proposed stops', place: 'Moraine Lake, Lake Louise' },
+    { stepType: 'pickup', time: '7:00 AM', place: 'Banff Hotel' },
+  ]);
+});
+
 test('private shuttle checkout detects a quote total that differs from the displayed total', () => {
   assert.equal(privateShuttlePriceChanged(2247, 2681), true);
   assert.equal(privateShuttlePriceChanged(2681, 2681.0), false);
@@ -1260,3 +1798,315 @@ test('builds paid checkout modal data with trimmed customer and change totals',
     differenceTotal: 12,
   });
 });
+
+test('keeps an incompatible add-on visible until the admin explicitly removes it', () => {
+  const lunch = {
+    addOnId: 'addon_el_lunch',
+    name: 'Emerald Lake Lunch Package',
+    price: 28,
+    currency: 'CAD',
+    preCheckout: true,
+    postCheckout: false,
+    variantType: 'multi_quantity' as const,
+    variants: [
+      {
+        id: 'blackforest_ham_sandwich_gatorade',
+        label: 'Blackforest Ham Sandwich + Gatorade',
+        priceAdjustment: 0,
+      },
+    ],
+    productOptionIds: ['po_big_three'],
+  };
+  const selections = [
+    {
+      addOnId: lunch.addOnId,
+      variantId: lunch.variants[0].id,
+      quantity: 1,
+    },
+  ];
+
+  assert.deepEqual(incompatibleAddOnSelections(selections, [], false), []);
+  assert.deepEqual(incompatibleAddOnSelections(selections, [lunch], true), []);
+  assert.deepEqual(incompatibleAddOnSelections(selections, [], true), selections);
+  assert.deepEqual(removeAddOnSelections(selections, lunch.addOnId), []);
+});
+
+test('removing one incompatible add-on preserves other target selections', () => {
+  const selections = [
+    { addOnId: 'addon_el_lunch', variantId: 'ham', quantity: 1 },
+    { addOnId: 'addon_target_supported', quantity: 2 },
+  ];
+
+  assert.deepEqual(removeAddOnSelections(selections, 'addon_el_lunch'), [
+    { addOnId: 'addon_target_supported', quantity: 2 },
+  ]);
+});
+
+test('labels a service move with the source and target tour names', () => {
+  assert.equal(
+    adminRemovalOperationLabel(
+      {
+        operationId: 'op_move',
+        type: 'MOVE_SERVICE',
+        componentKey: 'service',
+        oldIdentity: 'p_big_three:a_source:2026-07-31',
+        targetIdentity: 'po_moraine:a_target:2026-07-31',
+      },
+      {
+        sourceProductName: 'Big 3 Lakes Tour: Moraine, Emerald, Louise',
+        targetProductName: 'Moraine Lake Adventure',
+      },
+    ),
+    'Change tour: Big 3 Lakes → Moraine Lake Adventure',
+  );
+});
+
+test('labels a whole-booking promo adjustment without exposing its internal id', () => {
+  const label = adminRemovalOperationLabel(
+    {
+      operationId: 'op_promo_adjustment',
+      type: 'ADD_MANUAL_ADJUSTMENT',
+      componentKey: 'manual_adjustment:promo_53ef0d9fe839aa8cd88e9b0f',
+      targetIdentity: '-3035',
+    },
+    { promoCode: 'banffblog15' },
+  );
+
+  assert.equal(label, 'Apply promo to entire booking: BANFFBLOG15');
+  assert.doesNotMatch(label, /promo_[a-f0-9]+/i);
+});
+
+test('limits adjustment tax treatments by charge or credit direction', () => {
+  assert.deepEqual(
+    adminAdjustmentTaxBehaviorOptions(1).map((option) => option.value),
+    ['TAXABLE', 'NON_TAXABLE'],
+  );
+  assert.deepEqual(
+    adminAdjustmentTaxBehaviorOptions(-1).map((option) => option.value),
+    ['PRE_TAX_DISCOUNT', 'POST_TAX_DISCOUNT'],
+  );
+  assert.equal(normalizeAdminAdjustmentTaxBehavior(-1, 'TAXABLE'), 'PRE_TAX_DISCOUNT');
+  assert.equal(
+    normalizeAdminAdjustmentTaxBehavior(-1, 'POST_TAX_DISCOUNT'),
+    'POST_TAX_DISCOUNT',
+  );
+  assert.equal(normalizeAdminAdjustmentTaxBehavior(1, 'PRE_TAX_DISCOUNT'), 'TAXABLE');
+});
+
+test('switching a new custom line to credit defaults its scope to active tickets', () => {
+  assert.equal(
+    normalizeAdminAdjustmentScopeForSign(-1, 'POSITIVE_AMENDMENT_VALUE'),
+    'CURRENT_ACTIVE_TICKETS',
+  );
+  assert.equal(
+    normalizeAdminAdjustmentScopeForSign(-1, 'CURRENT_ACTIVE_BOOKING'),
+    'CURRENT_ACTIVE_BOOKING',
+  );
+  assert.equal(
+    normalizeAdminAdjustmentScopeForSign(1, 'POSITIVE_AMENDMENT_VALUE'),
+    'POSITIVE_AMENDMENT_VALUE',
+  );
+});
+
+test('labels a custom adjustment refund decision with its operator-entered description', () => {
+  const label = adminRemovalOperationLabel(
+    {
+      operationId: 'op_admin_discount',
+      type: 'ADD_MANUAL_ADJUSTMENT',
+      componentKey: 'manual_adjustment:admin-rcpt-1',
+      targetIdentity: '-1000',
+    },
+    { manualAdjustmentLabelsById: { 'admin-rcpt-1': 'Local active-ticket discount' } },
+  );
+
+  assert.equal(label, 'Local active-ticket discount');
+  assert.doesNotMatch(label, /admin-rcpt/i);
+});
+
+test('labels an adjustment reversal from server metadata without exposing its internal id', () => {
+  const label = adminRemovalOperationLabel({
+    operationId: 'op_reverse_adjustment',
+    type: 'REVERSE_MANUAL_ADJUSTMENT',
+    componentKey: 'manual_adjustment:admin-edit-ms3ea4jv-1',
+    oldIdentity: '2500',
+    metadata: { displayName: 'Edited service fee' },
+  });
+
+  assert.equal(label, 'Remove adjustment: Edited service fee');
+  assert.doesNotMatch(label, /admin-edit/i);
+});
+
+test('shows the true refundable amount after an unpaid balance is reduced', () => {
+  const operation = {
+    operationId: 'op_reverse_adjustment',
+    type: 'REVERSE_MANUAL_ADJUSTMENT',
+    componentKey: 'manual_adjustment:admin-edit-ms3ea4jv-1',
+  };
+
+  assert.equal(
+    refundTreatmentDisplayValue(
+      operation,
+      [operation],
+      { op_reverse_adjustment: 27.13 },
+      5,
+    ),
+    5,
+  );
+  assert.equal(
+    noRefundRemovedValue(
+      [operation],
+      { op_reverse_adjustment: 'NO_REFUND' },
+      { op_reverse_adjustment: 27.13 },
+    ),
+    27.13,
+  );
+});
+
+test('translates booking-change reason codes into operator-facing messages', () => {
+  assert.equal(
+    friendlyChangeBookingError('pricing_v2_unsupported_features'),
+    'Some selected booking options do not work together. Review the highlighted selections before continuing.',
+  );
+  assert.equal(
+    friendlyChangeBookingError('quote_expired'),
+    'This booking or price changed after the page was opened. Refresh it and try again.',
+  );
+  assert.equal(
+    friendlyChangeBookingError('admin_adjustment_refund_disposition_required:op_adjustment'),
+    'Choose how to handle the removed adjustment value before continuing.',
+  );
+  assert.equal(
+    friendlyChangeBookingError('promo_change_only_no_eligible_new_value'),
+    'This promo only applies to new charges. Make a priced change, or choose Entire active booking.',
+  );
+  assert.equal(
+    friendlyChangeBookingError('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.',
+  );
+  assert.equal(
+    friendlyChangeBookingError('Remove the unavailable add-on before recalculating this amendment.'),
+    'Remove the unavailable add-on before recalculating this amendment.',
+  );
+  assert.doesNotMatch(
+    friendlyChangeBookingError('pricing_v2_future_unsupported_case'),
+    /pricing_v2|_/,
+  );
+});
+
+test('names the incompatible add-on and target tour in the operator error', () => {
+  assert.equal(
+    incompatibleAddOnChangeError(
+      ['Emerald Lake Lunch Package'],
+      'Moraine Lake Adventure',
+    ),
+    "Emerald Lake Lunch Package isn't available with Moraine Lake Adventure. Remove the add-on or choose a different tour.",
+  );
+  assert.equal(
+    incompatibleAddOnChangeError(['Lunch', 'Photo package'], 'Target Tour'),
+    "Lunch and Photo package aren't available with Target Tour. Remove these add-ons or choose a different tour.",
+  );
+});
+
+test('uses the authoritative quote itinerary with confirmed dependent sessions', () => {
+  const itinerary = [
+    { stepType: 'pickup', time: '8:05 AM', place: 'Banff Boundary Lodge' },
+    {
+      stepType: 'other',
+      time: '11:00 AM - 11:30 AM',
+      place: 'Friends, Family, & Couples add-on · Photographer: Will Lambert · 30 minutes',
+    },
+    { stepType: 'drop_off', time: '7:00 PM', place: 'Banff Boundary Lodge' },
+  ];
+  const response = quote({
+    pricingQuote: {
+      payableTotal: 212.64,
+      amendment: {
+        targetState: {
+          nonPriceState: {
+            itinerary: JSON.stringify(itinerary),
+          },
+        },
+      },
+    },
+  });
+
+  assert.deepEqual(authoritativeItineraryDisplayFromChangeQuote(response), itinerary);
+  assert.deepEqual(
+    sliceAndMergeChangeQuoteForUi(
+      response,
+      { total: 212.64, subtotal: 195.98, tax: 16.66 },
+      'CAD',
+    ).mergedQuote.authoritativeItineraryDisplay,
+    itinerary,
+  );
+});
+
+test('falls back when the authoritative quote itinerary is malformed', () => {
+  assert.equal(
+    authoritativeItineraryDisplayFromChangeQuote(quote({
+      pricingQuote: {
+        amendment: {
+          targetState: {
+            nonPriceState: {
+              itinerary: '{not-json',
+            },
+          },
+        },
+      },
+    })),
+    null,
+  );
+});
+
+test('exposes only authoritative selectable amendment components to admin adjustments', () => {
+  const response = quote({
+    pricingQuote: {
+      amendment: {
+        updatedReceipt: {
+          total: 256.04,
+          lineItems: [
+            {
+              type: 'TICKET',
+              label: 'ADULT',
+              amount: 219.99,
+              identity: { componentId: 'ticket_adult_1' },
+            },
+            {
+              type: 'FEE',
+              label: 'Moraine Lake Road Access Fee',
+              amount: 15.99,
+              identity: { componentId: 'fee_road_access' },
+            },
+            {
+              type: 'TAX',
+              label: 'Taxes and fees',
+              amount: 20.06,
+              identity: { componentId: 'tax_1' },
+            },
+            {
+              type: 'PROMO_CODE',
+              label: 'Promo',
+              amount: -15,
+              identity: { componentId: 'incentive_1' },
+            },
+          ],
+        },
+      },
+    },
+  });
+
+  assert.deepEqual(selectableAdminAdjustmentComponentsFromQuote(response), [
+    {
+      componentId: 'ticket_adult_1',
+      label: 'ADULT',
+      amount: 219.99,
+      type: 'TICKET',
+    },
+    {
+      componentId: 'fee_road_access',
+      label: 'Moraine Lake Road Access Fee',
+      amount: 15.99,
+      type: 'FEE',
+    },
+  ]);
+});