@ticketboothapp/booking 1.2.166 → 1.2.168

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

@@ -11,18 +11,59 @@ import {
 } from '../src/lib/booking/change-flow-pricing';
 import {
   mapAdminChangeBookingQuoteV2Data,
+  type Availability,
   type ChangeBookingQuoteResponse,
 } from '../src/lib/booking-api';
-import { buildAdminChangeQuoteRequestKey } from '../src/components/booking/admin-change-quote-request-key';
+import {
+  filterAvailabilitiesAfterCurrentTime,
+  filterAvailabilitiesAfterPublicBookingCutoff,
+} from '../src/lib/booking/booking-cutoffs';
+import {
+  findFirstDateWithBookableAvailability,
+  selectedDateHasVisibleAvailability,
+} 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,
+} from '../src/components/booking/admin-change-v2-quote-request';
 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';
@@ -33,12 +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 {
@@ -57,16 +122,334 @@ function quoteSlice(overrides: Partial<ChangeQuoteUiSlice>): ChangeQuoteUiSlice
   };
 }
 
-function test(name: string, fn: () => void): void {
+function test(name: string, fn: () => void | Promise<void>): void {
   try {
-    fn();
-    console.log(`ok - ${name}`);
+    const result = fn();
+    if (result instanceof Promise) {
+      void result.then(
+        () => console.log(`ok - ${name}`),
+        (error) => {
+          console.error(`not ok - ${name}`);
+          throw error;
+        },
+      );
+    } else {
+      console.log(`ok - ${name}`);
+    }
   } catch (error) {
     console.error(`not ok - ${name}`);
     throw error;
   }
 }
 
+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 },
+    { kind: 'line', label: 'Moraine Lake Road Access Fee', amount: 15.99, type: 'FEE' },
+    { kind: 'line', label: 'Discount · Moraine Lake Road Access Fee', amount: -2.4, type: 'DISCOUNT' },
+    { kind: 'line', label: 'Discount · ADULT', amount: -25.57, type: 'DISCOUNT' },
+  ], 'banffblog15');
+
+  assert.deepEqual(lines, [
+    { kind: 'ticket', category: 'ADULT', qty: 1, itemTotal: 170.49 },
+    { kind: 'line', label: 'Moraine Lake Road Access Fee', amount: 15.99, type: 'FEE' },
+    { kind: 'line', label: 'Promo: BANFFBLOG15', amount: -27.97, type: 'PROMO_CODE' },
+  ]);
+});
+
+test('admin amendment display leaves unrelated manual discounts separate', () => {
+  const lines = collapseAdminPromoLines([
+    { kind: 'line', label: 'Promo retained booking value', amount: -10, type: 'DISCOUNT' },
+    { kind: 'line', label: 'Manager courtesy', amount: -5, type: 'DISCOUNT' },
+    { kind: 'line', label: 'Discount · ADULT', amount: -20, type: 'PROMO_CODE' },
+  ], 'SAVE20');
+
+  assert.deepEqual(lines, [
+    { kind: 'line', label: 'Promo: SAVE20', amount: -30, type: 'PROMO_CODE' },
+    { kind: 'line', label: 'Manager courtesy', amount: -5, type: 'DISCOUNT' },
+  ]);
+});
+
+test('admin availability filtering removes only starts that have passed', () => {
+  const now = new Date('2026-07-21T17:00:00-06:00');
+  const rows = [
+    calendarAvailability('2026-07-21T16:59:00-06:00', 4),
+    calendarAvailability('2026-07-21T17:01:00-06:00', 4),
+    calendarAvailability('2026-07-22T08:00:00-06:00', 4),
+  ];
+
+  assert.deepEqual(
+    filterAvailabilitiesAfterCurrentTime(rows, now).map((row) => row.dateTime),
+    ['2026-07-21T17:01:00-06:00', '2026-07-22T08:00:00-06:00'],
+  );
+});
+
+test('public availability filtering keeps its stricter advance cutoff', () => {
+  const now = new Date('2026-07-21T17:00:00-06:00');
+  const rows = [
+    calendarAvailability('2026-07-21T17:30:00-06:00', 4),
+    calendarAvailability('2026-07-21T18:30:00-06:00', 4),
+  ];
+
+  assert.deepEqual(
+    filterAvailabilitiesAfterPublicBookingCutoff(rows, now, 60).map((row) => row.dateTime),
+    ['2026-07-21T18:30:00-06:00'],
+  );
+});
+
+test('calendar auto-selection advances when the selected day has no visible starts', () => {
+  const rowsByDate: Record<string, Availability[]> = {
+    '2026-07-22': [calendarAvailability('2026-07-22T08:00:00-06:00', 0)],
+    '2026-07-23': [calendarAvailability('2026-07-23T08:00:00-06:00', 3)],
+  };
+  const getRowsForDate = (date: string) => rowsByDate[date] ?? [];
+
+  assert.equal(selectedDateHasVisibleAvailability('2026-07-21', getRowsForDate), false);
+  assert.equal(
+    findFirstDateWithBookableAvailability(
+      ['2026-07-22', '2026-07-23'],
+      getRowsForDate,
+      (availability) => availability.vacancies > 0,
+    ),
+    '2026-07-23',
+  );
+});
+
+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(
@@ -206,6 +589,122 @@ test('admin quote response display state cannot invalidate its request identity'
   assert.equal(keyAfterResponse, keyBeforeResponse);
 });
 
+test('admin quote dedupe refetches unchanged inputs after the published quote is cleared', () => {
+  const inputKey = 'same-admin-change-inputs';
+  assert.equal(canReuseCompletedAdminChangeQuote(inputKey, inputKey, true), true);
+  assert.equal(canReuseCompletedAdminChangeQuote(inputKey, inputKey, false), false);
+  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 ',
+    lastName: ' Tauro ',
+    parentProductId: 'product_1',
+    optionId: 'option_1',
+    selectedAvailability: {
+      availabilityId: 'availability_1',
+      productId: 'option_1',
+      dateTime: '2026-07-28T08:35:00-06:00',
+      vacancies: 10,
+    } as Parameters<typeof buildAdminChangeV2QuoteRequest>[0]['selectedAvailability'],
+    pickupLocationId: 'pickup_1',
+    returnAvailabilityId: null,
+    bookingItems: [{ category: 'ADULT', count: 3 }],
+    addOnSelections: [],
+    cancellationPolicyId: 'policy_1',
+    promoCode: ' banffblog15 ',
+    promoApplicationScope: 'ENTIRE_BOOKING',
+    structuredAdjustments: [{ type: 'CUSTOM', amount: 5 }],
+    includeSelectableAdjustmentComponents: true,
+    refundDispositionsByOperationId: { remove_1: 'PENDING_REFUND' },
+    previousPassengerCount: 2,
+    previousAvailabilityId: 'availability_old',
+    previousReturnAvailabilityId: null,
+  });
+
+  assert.equal(request.bookingReference, 'VFSCAEKQ');
+  assert.equal(request.lastName, 'Tauro');
+  assert.equal(request.newProductId, 'option_1');
+  assert.deepEqual(request.newPassengerCounts, [{ category: 'ADULT', count: 3 }]);
+  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,
+    previousAvailabilityId: 'availability_old',
+    previousReturnAvailabilityId: null,
+  });
+  assert.equal('clientProposedTotal' in request, false);
+});
+
+test('admin checkout maps the fresh Pricing V2 quote id instead of a legacy response', async () => {
+  const request = buildAdminChangeV2QuoteRequest({
+    bookingReference: 'VFSCAEKQ',
+    lastName: 'Tauro',
+    parentProductId: 'product_1',
+    optionId: 'option_1',
+    selectedAvailability: {
+      availabilityId: 'availability_1',
+      productId: 'option_1',
+      dateTime: '2026-07-28T08:35:00-06:00',
+      vacancies: 10,
+    } as Parameters<typeof buildAdminChangeV2QuoteRequest>[0]['selectedAvailability'],
+    pickupLocationId: 'pickup_1',
+    returnAvailabilityId: null,
+    bookingItems: [{ category: 'ADULT', count: 3 }],
+    addOnSelections: [],
+    cancellationPolicyId: 'policy_1',
+    structuredAdjustments: [],
+    refundDispositionsByOperationId: {},
+    previousPassengerCount: 2,
+    previousAvailabilityId: 'availability_old',
+    previousReturnAvailabilityId: null,
+  });
+  const mergedQuote = await quoteAdminChangeV2ForUi(
+    request,
+    { total: 768.11, subtotal: 707.94, tax: 60.17 },
+    'CAD',
+    async () => quote({
+      pricingQuote: {
+        quoteId: 'quote_v2_checkout',
+        currency: 'CAD',
+        payableTotal: 768.11,
+        amountToCharge: 256.03,
+        balanceDelta: 256.03,
+        lines: [],
+      },
+      balanceDeltaMajorUnits: 256.03,
+    }),
+  );
+
+  assert.equal(mergedQuote.quoteId, 'quote_v2_checkout');
+  assert.equal(mergedQuote.priceDiff, 256.03);
+  assert.equal(mergedQuote.quotedTotal, 768.11);
+});
+
 test('admin no-charge provider payload carries the selected pickup itinerary', () => {
   const itineraryDisplay: NonNullable<
     Parameters<typeof buildAdminChangeProviderPayload>[0]['itineraryDisplay']
@@ -235,6 +734,7 @@ test('admin no-charge provider payload carries the selected pickup itinerary', (
     cancellationPolicyId: 'standard',
     initialCancellationPolicyId: 'standard',
     appliedPromoCode: null,
+    promoApplicationScope: 'CHANGE_ONLY',
     newTotalAmount: 202.87,
     providerPricingOverrides: [],
     mergedProviderAdditionalAdjustments: [],
@@ -255,6 +755,7 @@ test('admin no-charge provider payload carries the selected pickup itinerary', (
   assert.deepEqual(payload?.addOnSelections, []);
   assert.equal(payload?.pricingV2QuoteId, 'quote_reviewed');
   assert.equal(payload?.pricingV2QuotedTotal, 202.87);
+  assert.equal(payload?.promoApplicationScope, null);
 });
 
 test('public paid change preview shows amendment-only charges before combined tax', () => {
@@ -309,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],
@@ -330,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(
@@ -349,6 +868,300 @@ test('admin removal quote preserves explicit release refund decisions for the pr
   );
 });
 
+test('admin refund decisions remain stable when successive quotes return only unresolved operations', () => {
+  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,
+  };
+  const allowed = ['PENDING_REFUND', 'NO_REFUND'] as const;
+
+  const initial = mergeAdminRefundDecisionContext({
+    current: null,
+    selectionKey: 'selection-a',
+    operations: [removeReturn, removeAdult],
+    allowedByOperationId: {
+      [removeReturn.operationId]: [...allowed],
+      [removeAdult.operationId]: [...allowed],
+    },
+    removedValueByOperationId: {
+      [removeReturn.operationId]: 42.32,
+      [removeAdult.operationId]: 220.83,
+    },
+  });
+  const afterReturnDecision = mergeAdminRefundDecisionContext({
+    current: initial,
+    selectionKey: 'selection-a',
+    // The server now returns only the still-unanswered quantity removal.
+    operations: [removeAdult],
+    allowedByOperationId: { [removeAdult.operationId]: [...allowed] },
+    removedValueByOperationId: { [removeAdult.operationId]: 220.83 },
+  });
+
+  assert.deepEqual(
+    afterReturnDecision?.operations.map((operation) => operation.operationId),
+    [removeReturn.operationId, removeAdult.operationId],
+  );
+  assert.deepEqual(
+    selectRefundDispositionsForOperations(afterReturnDecision, [], {
+      [removeReturn.operationId]: 'PENDING_REFUND',
+    }),
+    { [removeReturn.operationId]: 'PENDING_REFUND' },
+  );
+
+  const complete = mergeAdminRefundDecisionContext({
+    current: afterReturnDecision,
+    selectionKey: 'selection-a',
+    operations: [],
+    allowedByOperationId: {},
+    removedValueByOperationId: {},
+  });
+  assert.deepEqual(
+    selectRefundDispositionsForOperations(complete, [], {
+      [removeReturn.operationId]: 'PENDING_REFUND',
+      [removeAdult.operationId]: 'NO_REFUND',
+    }),
+    {
+      [removeReturn.operationId]: 'PENDING_REFUND',
+      [removeAdult.operationId]: 'NO_REFUND',
+    },
+  );
+
+  const nextSelection = mergeAdminRefundDecisionContext({
+    current: complete,
+    selectionKey: 'selection-b',
+    operations: [removeAdult],
+    allowedByOperationId: { [removeAdult.operationId]: [...allowed] },
+    removedValueByOperationId: { [removeAdult.operationId]: 220.83 },
+  });
+  assert.deepEqual(
+    nextSelection?.operations.map((operation) => operation.operationId),
+    [removeAdult.operationId],
+  );
+  assert.deepEqual(
+    selectRefundDispositionsForOperations(nextSelection, [], {
+      [removeReturn.operationId]: 'PENDING_REFUND',
+      [removeAdult.operationId]: 'NO_REFUND',
+    }),
+    { [removeAdult.operationId]: 'NO_REFUND' },
+  );
+});
+
+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',
+    type: 'ADD_QUANTITY',
+    componentKey: 'ticket:ADULT',
+    quantityDelta: 1,
+  };
+  const mapped = mapAdminChangeBookingQuoteV2Data({
+    oldReceipt: {
+      currency: 'CAD',
+      grossSubtotal: 247.96,
+      taxAmount: 21.08,
+      payableTotal: 269.04,
+      lines: [
+        {
+          type: 'TICKET',
+          label: 'ADULT',
+          quantity: 2,
+          amount: 215.98,
+          billable: true,
+          priceBasis: {
+            baseUnitAmount: 139.99,
+            finalUnitAmount: 107.99,
+            currency: 'CAD',
+            adjustments: [
+              {
+                type: 'DYNAMIC_PRICING',
+                id: 'rule_early_booking',
+                name: 'Early booking discount',
+                amount: -32,
+                adjustmentType: 'FIXED',
+                adjustmentValue: 32,
+              },
+            ],
+          },
+        },
+      ],
+    },
+    newQuote: {
+      currency: 'CAD',
+      payableTotal: 455.64,
+      balanceDelta: 186.60,
+      amendment: { operations: [moveOperation, addOperation] },
+      lines: [
+        {
+          type: 'TICKET',
+          label: 'ADULT',
+          quantity: 2,
+          amount: 48,
+          billable: true,
+          metadata: { category: 'ADULT', operationId: moveOperation.operationId },
+          priceBasis: {
+            baseUnitAmount: 149.99,
+            finalUnitAmount: 131.99,
+            currency: 'CAD',
+            adjustments: [
+              {
+                type: 'dynamic',
+                id: 'rule_new_date',
+                name: 'New-date adjustment',
+                amount: -18,
+                adjustmentType: 'fixed',
+                adjustmentValue: -18,
+              },
+            ],
+          },
+        },
+        {
+          type: 'TICKET',
+          label: 'ADULT',
+          quantity: 1,
+          amount: 124,
+          billable: true,
+          metadata: { category: 'ADULT', operationId: addOperation.operationId },
+        },
+      ],
+    },
+    canApply: true,
+  });
+  assert.deepEqual(mapped.originalReceipt?.lineItems?.[0]?.priceBasis, {
+    baseUnitAmount: 139.99,
+    finalUnitAmount: 107.99,
+    currency: 'CAD',
+    adjustments: [
+      {
+        type: 'DYNAMIC_PRICING',
+        id: 'rule_early_booking',
+        name: 'Early booking discount',
+        amount: -32,
+        adjustmentType: 'FIXED',
+        adjustmentValue: 32,
+      },
+    ],
+  });
+  const existingPurchaseLines = mapQuoteLineItemsToPriceSummaryLines(
+    mapped.originalReceipt?.lineItems,
+  );
+  assert.deepEqual(
+    existingPurchaseLines[0]?.kind === 'ticket'
+      ? existingPurchaseLines[0].breakdown?.lineItems
+      : null,
+    [
+      { type: 'base', name: 'Base price', amountInDisplayCurrency: 139.99 },
+      {
+        type: 'adjustment',
+        id: 'rule_early_booking',
+        name: 'Early booking discount',
+        amountInDisplayCurrency: -32,
+        adjustmentType: 'FIXED',
+        adjustmentValue: 32,
+        sourceType: 'dynamic',
+      },
+    ],
+  );
+  const preview = buildChangeBookingServerPreview(
+    mapped,
+    { total: 455.64, subtotal: 419.94, tax: 35.70 },
+    'CAD',
+  );
+  const lines = preview?.priceSummaryLines ?? [];
+
+  assert.equal(lines[0]?.kind, 'ticket');
+  assert.equal(lines[0]?.kind === 'ticket' ? lines[0].category : null, 'ADULT — new date price difference');
+  assert.deepEqual(
+    lines[0]?.kind === 'ticket' ? lines[0].unitPriceComparison : null,
+    {
+      previousLabel: 'Existing adult price',
+      updatedLabel: 'New-date adult price',
+      differenceLabel: 'Difference per adult',
+      previousUnitAmount: 107.99,
+      updatedUnitAmount: 131.99,
+      differenceUnitAmount: 24,
+    },
+  );
+  assert.deepEqual(
+    lines[0]?.kind === 'ticket' ? lines[0].breakdown?.lineItems : null,
+    [
+      { type: 'base', name: 'Base price', amountInDisplayCurrency: 149.99 },
+      {
+        type: 'adjustment',
+        id: 'rule_new_date',
+        name: 'New-date adjustment',
+        amountInDisplayCurrency: -18,
+        adjustmentType: 'fixed',
+        adjustmentValue: -18,
+        sourceType: 'dynamic',
+      },
+    ],
+  );
+  assert.equal(lines[1]?.kind === 'ticket' ? lines[1].category : null, 'ADULT');
+});
+
 test('admin return price treatment defaults to keep floor and maps optional reprice choices', () => {
   const operation = {
     operationId: 'op_change_return',
@@ -379,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');
@@ -443,9 +1296,20 @@ test('admin cancellation policy and structured adjustments are authoritative quo
     ...base,
     structuredAdjustments: [{ adjustmentId: 'adj_1', mode: 'FIXED_AMOUNT', fixedAmount: 10 }],
   });
+  const wholeBookingPromo = buildAdminChangeQuoteRequestKey({
+    ...base,
+    promoCode: 'BANFFBLOG15',
+    promoApplicationScope: 'ENTIRE_BOOKING',
+  });
+  const changeOnlyPromo = buildAdminChangeQuoteRequestKey({
+    ...base,
+    promoCode: 'BANFFBLOG15',
+    promoApplicationScope: 'CHANGE_ONLY',
+  });
 
   assert.notEqual(original, policyChanged);
   assert.notEqual(original, adjustmentChanged);
+  assert.notEqual(changeOnlyPromo, wholeBookingPromo);
 });
 
 test('private shuttle pricing replaces the selected calendar summary with hydrated rate details', () => {
@@ -489,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);
@@ -798,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',
+    },
+  ]);
+});