@ticketboothapp/booking 1.2.181 → 1.2.182

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ticketboothapp/booking",
-  "version": "1.2.181",
+  "version": "1.2.182",
   "private": false,
   "sideEffects": [
     "**/*.css",

package/src/components/booking/NewBookingFlow.tsx

@@ -69,13 +69,14 @@ export function NewBookingFlow({
   bookingSourceAttribution,
   partnerPortalBooking = false,
   availabilityPricingProfileId,
+  availabilityPricingProfileOverrides,
   availabilityCancellationPolicyProfileId,
 }: NewBookingFlowProps) {
   const { env, analytics, catalog } = useBookingHost();
   const { t } = useTranslations();
   const { locale } = useLocale();
   const companyTimezone = useCompanyTimezone(); // Get timezone from context
-  const pricingProfileIdForAvailabilities = (availabilityPricingProfileId ?? '').trim() || null;
+  const fallbackPricingProfileIdForAvailabilities = (availabilityPricingProfileId ?? '').trim() || null;
   const cancellationPolicyProfileIdForAvailabilities =
     (availabilityCancellationPolicyProfileId ?? '').trim() || null;
   const {
@@ -162,6 +163,7 @@ export function NewBookingFlow({
     setSelectedReturnOption,
     selectedDate,
     setSelectedDate,
+    pricingProfileIdForAvailabilities,
     loadingAvailabilities,
     isFetchingMoreAvailabilities,
     pricingConfig,
@@ -182,7 +184,8 @@ export function NewBookingFlow({
     isAdmin,
     companyTimezone,
     appliedPromoCode,
-    pricingProfileIdForAvailabilities,
+    pricingProfileIdForAvailabilities: fallbackPricingProfileIdForAvailabilities,
+    pricingProfileOverridesForAvailabilities: availabilityPricingProfileOverrides,
     cancellationPolicyProfileIdForAvailabilities,
     bookingCutoffNow,
     bookingCutoffMinutes,

package/src/components/booking/PrivateShuttleBookingFlow.tsx

@@ -59,6 +59,10 @@ import {
   resolveInitialPrivateShuttlePassengerCount,
 } from './private-shuttle-passenger-count';
 import { privateShuttleHiddenLunchAddOnId } from './private-shuttle-lunch-visibility';
+import {
+  resolvePartnerPricingProfileId,
+  type PartnerPricingProfileOverride,
+} from '../../lib/booking/partner-pricing-profile';
 
 interface PrivateShuttleBookingFlowProps {
   product: Product;
@@ -85,6 +89,8 @@ interface PrivateShuttleBookingFlowProps {
   partnerPortalBooking?: boolean;
   /** When set (e.g. partner portal), get-availabilities requests this pricing profile from the API. */
   availabilityPricingProfileId?: string | null;
+  /** Month-specific partner profiles resolved against selectedDate. */
+  availabilityPricingProfileOverrides?: readonly PartnerPricingProfileOverride[];
   /** When set (e.g. partner portal), get-availabilities filters cancellation policies by this profile. */
   availabilityCancellationPolicyProfileId?: string | null;
   initialValues?: {
@@ -117,6 +123,7 @@ export function PrivateShuttleBookingFlow({
   bookingSourceAttribution,
   partnerPortalBooking = false,
   availabilityPricingProfileId,
+  availabilityPricingProfileOverrides,
   availabilityCancellationPolicyProfileId,
   initialValues,
   initialBooking,
@@ -126,7 +133,7 @@ export function PrivateShuttleBookingFlow({
   const { t } = useTranslations();
   const { locale } = useLocale();
   const companyTimezone = useCompanyTimezone();
-  const pricingProfileIdForAvailabilities = (availabilityPricingProfileId ?? '').trim() || null;
+  const fallbackPricingProfileIdForAvailabilities = (availabilityPricingProfileId ?? '').trim() || null;
   const cancellationPolicyProfileIdForAvailabilities =
     (availabilityCancellationPolicyProfileId ?? '').trim() || null;
   const {
@@ -145,6 +152,19 @@ export function PrivateShuttleBookingFlow({
       companyTimezone,
     )
   );
+  const pricingProfileIdForAvailabilities = useMemo(
+    () => resolvePartnerPricingProfileId(
+      fallbackPricingProfileIdForAvailabilities,
+      availabilityPricingProfileOverrides,
+      selectedDate || formatInTimeZone(new Date(), companyTimezone, 'yyyy-MM-dd'),
+    ),
+    [
+      availabilityPricingProfileOverrides,
+      companyTimezone,
+      fallbackPricingProfileIdForAvailabilities,
+      selectedDate,
+    ],
+  );
   const [selectedAvailability, setSelectedAvailability] = useState<Availability | null>(null);
   const [selectedOption, setSelectedOption] = useState<string>('');
   const [selectedStartTime, setSelectedStartTime] = useState<string>('');

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

@@ -6,6 +6,7 @@ import type {
   Product,
 } from '../../lib/booking-api';
 import type { BookingSourceMetadata } from '../../lib/booking/source-metadata';
+import type { PartnerPricingProfileOverride } from '../../lib/booking/partner-pricing-profile';
 import type { Currency } from './CurrencySwitcher';
 import type { PriceSummaryLine } from './PriceSummary';
 import type { BookingFlowUiOptions } from './booking-flow-ui';
@@ -129,6 +130,8 @@ export interface BookingFlowBaseProps {
   partnerPortalBooking?: boolean;
   /** When set (e.g. partner portal), get-availabilities requests this pricing profile from the API. */
   availabilityPricingProfileId?: string | null;
+  /** Month-specific partner pricing profiles resolved against the selected booking date. */
+  availabilityPricingProfileOverrides?: readonly PartnerPricingProfileOverride[];
   /** When set (e.g. partner portal), get-availabilities filters cancellation policies by this profile. */
   availabilityCancellationPolicyProfileId?: string | null;
   /** Admin change-booking: available destination products for switching the booking to another product. */

package/src/components/booking/use-standard-booking-availability.ts

@@ -40,6 +40,10 @@ import {
   shouldSyncSelectedAvailability,
 } from './standard-booking-availability';
 import { shouldRevalidateAvailabilityCache } from './availability-cache-policy';
+import {
+  resolvePartnerPricingProfileId,
+  type PartnerPricingProfileOverride,
+} from '../../lib/booking/partner-pricing-profile';
 
 interface UseStandardBookingAvailabilityParams {
   product: Product;
@@ -51,6 +55,7 @@ interface UseStandardBookingAvailabilityParams {
   companyTimezone: string;
   appliedPromoCode: string | null;
   pricingProfileIdForAvailabilities: string | null;
+  pricingProfileOverridesForAvailabilities?: readonly PartnerPricingProfileOverride[];
   cancellationPolicyProfileIdForAvailabilities: string | null;
   bookingCutoffNow: Date;
   bookingCutoffMinutes?: number | null;
@@ -152,7 +157,8 @@ export function useStandardBookingAvailability({
   isAdmin,
   companyTimezone,
   appliedPromoCode,
-  pricingProfileIdForAvailabilities,
+  pricingProfileIdForAvailabilities: fallbackPricingProfileIdForAvailabilities,
+  pricingProfileOverridesForAvailabilities,
   cancellationPolicyProfileIdForAvailabilities,
   bookingCutoffNow,
   bookingCutoffMinutes,
@@ -179,6 +185,21 @@ export function useStandardBookingAvailability({
   const selectedDateHydrationInFlightKeyRef = useRef<string | null>(null);
   const lastVisibleRangeRef = useRef<DateRange | null>(null);
   const activeOptionsLength = activeOptions.length;
+  const pricingProfileResolutionDate = selectedDate || (visibleRange
+    ? formatInTimeZone(visibleRange.start, companyTimezone, 'yyyy-MM-dd')
+    : formatInTimeZone(new Date(), companyTimezone, 'yyyy-MM-dd'));
+  const pricingProfileIdForAvailabilities = useMemo(
+    () => resolvePartnerPricingProfileId(
+      fallbackPricingProfileIdForAvailabilities,
+      pricingProfileOverridesForAvailabilities,
+      pricingProfileResolutionDate,
+    ),
+    [
+      fallbackPricingProfileIdForAvailabilities,
+      pricingProfileOverridesForAvailabilities,
+      pricingProfileResolutionDate,
+    ],
+  );
 
   const applyPricingConfig = useCallback((next?: PricingConfig | null) => {
     setPricingConfig((prev) => {
@@ -415,6 +436,14 @@ export function useStandardBookingAvailability({
     }
   }, [companyTimezone, visibleRange]);
 
+  useEffect(() => {
+    fetchedRangesRef.current = [];
+  }, [
+    appliedPromoCode,
+    pricingProfileIdForAvailabilities,
+    cancellationPolicyProfileIdForAvailabilities,
+  ]);
+
   useEffect(() => {
     if (isPartialLaunch) {
       setLoadingAvailabilities(false);
@@ -605,14 +634,6 @@ export function useStandardBookingAvailability({
     visibleRange,
   ]);
 
-  useEffect(() => {
-    fetchedRangesRef.current = [];
-  }, [
-    appliedPromoCode,
-    pricingProfileIdForAvailabilities,
-    cancellationPolicyProfileIdForAvailabilities,
-  ]);
-
   const handleVisibleRangeChange = useCallback((start: Date, end: Date) => {
     const lastRange = lastVisibleRangeRef.current;
     const rangeChanged =
@@ -797,6 +818,7 @@ export function useStandardBookingAvailability({
     selectedReturnOption,
     setSelectedReturnOption,
     selectedDate,
+    pricingProfileIdForAvailabilities,
     setSelectedDate,
     loadingAvailabilities,
     isFetchingMoreAvailabilities,

package/src/index.ts

@@ -10,6 +10,11 @@ export {
   type PublicPartnerAgent,
   type PublicStaffPortalSignInOption,
 } from './public-partners';
+export {
+  parsePartnerPricingProfileOverrides,
+  resolvePartnerPricingProfileId,
+  type PartnerPricingProfileOverride,
+} from './lib/booking/partner-pricing-profile';
 
 /** Canonical Via Via booking UI — same modules as `@/components/booking/*` on the site. */
 export { BookingFlow } from './components/booking/BookingFlow';

package/src/lib/booking/partner-pricing-profile.ts

@@ -0,0 +1,74 @@
+export type PartnerPricingProfileOverride = {
+  pricingProfileId: string;
+  months?: number[];
+  startMonth?: number | null;
+  endMonth?: number | null;
+};
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+function validMonth(value: unknown): number | null {
+  return typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= 12
+    ? value
+    : null;
+}
+
+export function parsePartnerPricingProfileOverrides(
+  value: unknown,
+): PartnerPricingProfileOverride[] {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((row) => {
+    const record = asRecord(row);
+    const pricingProfileId =
+      typeof record?.pricingProfileId === 'string' ? record.pricingProfileId.trim() : '';
+    if (!pricingProfileId) return [];
+    const months = Array.isArray(record?.months)
+      ? record.months.map(validMonth).filter((month): month is number => month != null)
+      : [];
+    const startMonth = validMonth(record?.startMonth);
+    const endMonth = validMonth(record?.endMonth);
+    return [{
+      pricingProfileId,
+      ...(months.length > 0 ? { months } : {}),
+      ...(startMonth != null ? { startMonth } : {}),
+      ...(endMonth != null ? { endMonth } : {}),
+    }];
+  });
+}
+
+function bookingMonth(value: string | null | undefined): number | null {
+  const normalized = value?.trim();
+  if (!normalized) return null;
+  const match = /^(?:\d{4})-(\d{2})(?:-\d{2})?/.exec(normalized);
+  if (!match) return null;
+  const month = Number(match[1]);
+  return Number.isInteger(month) && month >= 1 && month <= 12 ? month : null;
+}
+
+function overrideMatchesMonth(override: PartnerPricingProfileOverride, month: number): boolean {
+  if (override.months?.length) return override.months.includes(month);
+  const start = override.startMonth;
+  const end = override.endMonth;
+  if (start == null || end == null) return false;
+  return start <= end ? month >= start && month <= end : month >= start || month <= end;
+}
+
+/** First matching seasonal override wins; the single profile remains the fallback. */
+export function resolvePartnerPricingProfileId(
+  fallbackPricingProfileId: string | null | undefined,
+  overrides: readonly PartnerPricingProfileOverride[] | null | undefined,
+  bookingDate: string | null | undefined,
+): string | null {
+  const fallback = fallbackPricingProfileId?.trim() || null;
+  const month = bookingMonth(bookingDate);
+  if (month == null) return fallback;
+  const matchingProfile = overrides
+    ?.find((override) => overrideMatchesMonth(override, month))
+    ?.pricingProfileId
+    ?.trim();
+  return matchingProfile || fallback;
+}

package/src/lib/booking/reservation-attempt.ts

@@ -0,0 +1,138 @@
+export interface ReservationAttemptStorage {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+}
+
+export interface ReservationAttemptContext<T extends object> {
+  idempotencyKey: string;
+  request: T & { idempotencyKey: string };
+  clear: () => void;
+}
+
+interface StoredReservationAttempt {
+  idempotencyKey: string;
+  createdAt: number;
+}
+
+export function reservationIdempotencyEnabled(
+  value: string | undefined = process.env.NEXT_PUBLIC_RESERVATION_IDEMPOTENCY_ENABLED
+): boolean {
+  return value?.trim().toLowerCase() === 'true';
+}
+
+export async function getOrCreateReservationAttempt<T extends object>(
+  request: T,
+  options: {
+    storage?: ReservationAttemptStorage | null;
+    now?: number;
+    createId?: () => string;
+    digest?: (value: string) => Promise<string>;
+  } = {}
+): Promise<ReservationAttemptContext<T>> {
+  const now = options.now ?? Date.now();
+  const requestWithoutKey = { ...request } as T & { idempotencyKey?: string };
+  delete requestWithoutKey.idempotencyKey;
+  const digest = options.digest ?? sha256Hex;
+  const fingerprint = await digest(stableStringify(requestWithoutKey));
+  const storageKey = `${STORAGE_PREFIX}${fingerprint}`;
+  const storage = options.storage === undefined ? browserSessionStorage() : options.storage;
+  const stored = readStoredAttempt(storage, storageKey, now);
+  const idempotencyKey = stored?.idempotencyKey ?? (options.createId ?? createAttemptId)();
+  if (!IDEMPOTENCY_KEY_PATTERN.test(idempotencyKey)) {
+    throw new Error('Could not create a valid reservation attempt identifier.');
+  }
+  if (!stored) {
+    writeStoredAttempt(storage, storageKey, { idempotencyKey, createdAt: now });
+  }
+  return {
+    idempotencyKey,
+    request: { ...requestWithoutKey, idempotencyKey },
+    clear: () => storage?.removeItem(storageKey),
+  };
+}
+
+function browserSessionStorage(): ReservationAttemptStorage | null {
+  try {
+    return typeof window !== 'undefined' ? window.sessionStorage : null;
+  } catch {
+    return null;
+  }
+}
+
+function readStoredAttempt(
+  storage: ReservationAttemptStorage | null,
+  key: string,
+  now: number
+): StoredReservationAttempt | null {
+  if (!storage) return null;
+  try {
+    const parsed = JSON.parse(storage.getItem(key) || '') as Partial<StoredReservationAttempt>;
+    if (
+      typeof parsed.idempotencyKey !== 'string' ||
+      !IDEMPOTENCY_KEY_PATTERN.test(parsed.idempotencyKey) ||
+      typeof parsed.createdAt !== 'number' ||
+      now - parsed.createdAt < 0 ||
+      now - parsed.createdAt > ATTEMPT_TTL_MS
+    ) {
+      storage.removeItem(key);
+      return null;
+    }
+    return { idempotencyKey: parsed.idempotencyKey, createdAt: parsed.createdAt };
+  } catch {
+    storage.removeItem(key);
+    return null;
+  }
+}
+
+function writeStoredAttempt(
+  storage: ReservationAttemptStorage | null,
+  key: string,
+  attempt: StoredReservationAttempt
+): void {
+  if (!storage) return;
+  try {
+    storage.setItem(key, JSON.stringify(attempt));
+  } catch {
+    // A storage failure reduces reload recovery but must not block a protected in-memory attempt.
+  }
+}
+
+function createAttemptId(): string {
+  const cryptoApi = globalThis.crypto;
+  if (typeof cryptoApi?.randomUUID === 'function') {
+    return `attempt_${cryptoApi.randomUUID().replaceAll('-', '')}`;
+  }
+  if (typeof cryptoApi?.getRandomValues === 'function') {
+    const bytes = cryptoApi.getRandomValues(new Uint8Array(16));
+    return `attempt_${Array.from(bytes, (value) => value.toString(16).padStart(2, '0')).join('')}`;
+  }
+  throw new Error('Secure random identifiers are unavailable in this browser.');
+}
+
+async function sha256Hex(value: string): Promise<string> {
+  if (!globalThis.crypto?.subtle) {
+    throw new Error('Secure request fingerprinting is unavailable in this browser.');
+  }
+  const digest = await globalThis.crypto.subtle.digest('SHA-256', new TextEncoder().encode(value));
+  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+
+function stableStringify(value: unknown): string {
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(',')}]`;
+  }
+  if (value && typeof value === 'object') {
+    const entries = Object.entries(value as Record<string, unknown>)
+      .filter(([, child]) => child !== undefined)
+      .sort(([left], [right]) => left.localeCompare(right));
+    return `{${entries
+      .map(([key, child]) => `${JSON.stringify(key)}:${stableStringify(child)}`)
+      .join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+const STORAGE_PREFIX = 'viavia:reservation-attempt:';
+const ATTEMPT_TTL_MS = 30 * 60 * 1000;
+const IDEMPOTENCY_KEY_PATTERN = /^[A-Za-z0-9_-]{16,128}$/;

package/src/lib/booking-api.ts

@@ -22,6 +22,11 @@ import {
   sanitizeBookingSourceUrl,
   type BookingSourceMetadata,
 } from './booking/source-metadata';
+import {
+  getOrCreateReservationAttempt,
+  reservationIdempotencyEnabled,
+  type ReservationAttemptContext,
+} from './booking/reservation-attempt';
 
 const API_BASE = ENV.API_URL.replace(/\/$/, '');
 const BOOKING_READ_API_BASE = ENV.BOOKING_READ_API_URL.replace(/\/$/, '');
@@ -283,6 +288,8 @@ function createUserError(
     ? 'This reservation hold has expired. Close this window and restart checkout to get current availability and pricing.'
     : bookingApiErrorCode === 'RESERVATION_NOT_ACTIVE'
       ? 'This reservation has already been completed or closed. Refresh before trying again.'
+      : bookingApiErrorCode === 'RESERVATION_OUTCOME_UNKNOWN'
+        ? 'We could not safely confirm whether your reservation was created. Please keep this page open and try recovery again; do not start another checkout yet.'
       : `${getUserFacingMessage(endpoint)} (${supportCode})`;
   const error = new Error(userMessage) as BookingClientError;
   error.debugMessage = debugMessage;
@@ -2320,6 +2327,8 @@ export interface ReserveRequest {
   source?: string;
   sourceMetadata?: BookingSourceMetadata;
   source_metadata?: BookingSourceMetadata;
+  /** One key per logical hold attempt; generated and retained by createReservation when enabled. */
+  idempotencyKey?: string;
 }
 
 /** Safe subset of reserve payload for telemetry (no free-text traveler fields). */
@@ -2497,9 +2506,107 @@ export interface ReserveResponse {
   currency?: string;
 }
 
+interface ReserveApiEnvelope {
+  data?: Partial<ReserveResponse> & { state?: string; retryAfterMs?: number };
+  errorCode?: string;
+  errorMessage?: string;
+  error?: string;
+  message?: string;
+}
+
+function parseReserveEnvelope(text: string): ReserveApiEnvelope {
+  try {
+    return JSON.parse(text) as ReserveApiEnvelope;
+  } catch {
+    return { errorMessage: text || 'Invalid response from server' };
+  }
+}
+
+function normalizedReserveResponse(data: ReserveApiEnvelope['data']): ReserveResponse | null {
+  if (!data?.reservationReference) return null;
+  const expiration = data.reservationExpiration ?? data.expiresAt;
+  if (!expiration) return null;
+  return {
+    reservationReference: data.reservationReference,
+    reservationExpiration: expiration,
+    expiresAt: expiration,
+    totalAmount: data.totalAmount,
+    currency: data.currency,
+  };
+}
+
+function reserveEnvelopeError(payload: ReserveApiEnvelope, fallback: string): {
+  code?: string;
+  message: string;
+} {
+  return {
+    code: payload.errorCode,
+    message: payload.errorMessage || payload.error || payload.message || fallback,
+  };
+}
+
+async function recoverReservationAttempt(
+  reservePayload: ReserveRequest,
+  attempt: ReservationAttemptContext<ReserveRequest>
+): Promise<ReserveResponse> {
+  const endpoint = '/1/reserve/status';
+  const delays = [0, 250, 750, 1500];
+  let lastMessage = 'The reservation outcome is still unknown.';
+  for (const delay of delays) {
+    if (delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    let response: Response;
+    try {
+      response = await fetch(`${API_BASE}${endpoint}`, {
+        method: 'POST',
+        headers: getAuthHeaders(),
+        body: JSON.stringify({ data: reservePayload }),
+      });
+    } catch (error) {
+      lastMessage = error instanceof Error ? error.message : String(error);
+      continue;
+    }
+    const payload = parseReserveEnvelope(await response.text());
+    const recovered = normalizedReserveResponse(payload.data);
+    if (response.ok && recovered) {
+      attempt.clear();
+      return recovered;
+    }
+    if (response.status === 202 || payload.data?.state === 'IN_PROGRESS') {
+      lastMessage = 'The reservation is still being processed.';
+      continue;
+    }
+    const failure = reserveEnvelopeError(payload, `Recovery failed with HTTP ${response.status}`);
+    lastMessage = failure.message;
+    if (response.status === 422) {
+      attempt.clear();
+      throw createUserError(endpoint, 'HTTP', failure.message, failure.code);
+    }
+    if (response.status === 400 || response.status === 409) {
+      throw createUserError(endpoint, 'HTTP', failure.message, failure.code);
+    }
+  }
+  reportClientFetchError({
+    endpoint,
+    errorClass: 'NETWORK',
+    message: lastMessage,
+    errorCode: 'RESERVATION_OUTCOME_UNKNOWN',
+    metadata: {
+      failureKind: 'RESERVATION_RECOVERY_EXHAUSTED',
+      reserveRequest: summarizeReserveRequestForTelemetry(reservePayload),
+    },
+  });
+  throw createUserError(endpoint, 'NETWORK', lastMessage, 'RESERVATION_OUTCOME_UNKNOWN');
+}
+
 export async function createReservation(request: ReserveRequest): Promise<ReserveResponse> {
   const endpoint = '/1/reserve';
-  const reservePayload = withExplicitBookingSource(request);
+  const baseReservePayload = withExplicitBookingSource(request);
+  const attempt = reservationIdempotencyEnabled()
+    ? await getOrCreateReservationAttempt(baseReservePayload)
+    : null;
+  const reservePayload = attempt?.request ?? baseReservePayload;
   let res: Response;
   try {
     res = await fetch(`${API_BASE}${endpoint}`, {
@@ -2509,6 +2616,9 @@ export async function createReservation(request: ReserveRequest): Promise<Reserv
     });
   } catch (err) {
     const debugMessage = err instanceof Error ? err.message : String(err);
+    if (attempt) {
+      return recoverReservationAttempt(reservePayload, attempt);
+    }
     reportClientFetchError({
       endpoint,
       errorClass: 'NETWORK',
@@ -2521,15 +2631,23 @@ export async function createReservation(request: ReserveRequest): Promise<Reserv
     throw createUserError(endpoint, 'NETWORK', debugMessage);
   }
   const text = await res.text();
+  const payload = parseReserveEnvelope(text);
+  if (res.status === 202 && attempt) {
+    return recoverReservationAttempt(reservePayload, attempt);
+  }
   if (!res.ok) {
-    let err: { errorMessage?: string; error?: string; errorCode?: string };
-    try {
-      err = JSON.parse(text);
-    } catch {
-      err = { errorMessage: text || 'Failed to create reservation' };
+    const failure = reserveEnvelopeError(payload, 'Failed to create reservation');
+    const ambiguousTransportOutcome =
+      failure.code === 'RESERVATION_OUTCOME_UNKNOWN' ||
+      (res.status >= 500 && failure.code !== 'IDEMPOTENCY_UNAVAILABLE');
+    if (attempt && ambiguousTransportOutcome) {
+      return recoverReservationAttempt(reservePayload, attempt);
+    }
+    if (attempt && failure.code !== 'IDEMPOTENCY_CONFLICT') {
+      attempt.clear();
     }
-    const debugMessage = err.errorMessage || err.error || 'Failed to create reservation';
-    const insufficientCapacity = isInsufficientCapacityApiError(err.errorCode, debugMessage);
+    const debugMessage = failure.message;
+    const insufficientCapacity = isInsufficientCapacityApiError(failure.code, debugMessage);
     reportClientFetchError({
       endpoint,
       errorClass: 'HTTP',
@@ -2537,66 +2655,45 @@ export async function createReservation(request: ReserveRequest): Promise<Reserv
         ? `[RESERVE_INSUFFICIENT_CAPACITY] ${debugMessage}`
         : debugMessage,
       httpStatus: res.status,
-      errorCode: err.errorCode,
+      errorCode: failure.code,
       metadata: {
         failureKind: insufficientCapacity
           ? 'RESERVE_INSUFFICIENT_CAPACITY'
           : 'RESERVE_HTTP_ERROR',
         reserveRequest: summarizeReserveRequestForTelemetry(request),
         apiErrorMessage: debugMessage,
-        apiErrorCode: err.errorCode ?? null,
+        apiErrorCode: failure.code ?? null,
       },
     });
-    throw createUserError(endpoint, 'HTTP', debugMessage, err.errorCode);
+    throw createUserError(endpoint, 'HTTP', debugMessage, failure.code);
   }
-  let data: { data?: ReserveResponse; errorCode?: string; errorMessage?: string };
-  try {
-    data = JSON.parse(text);
-  } catch {
-    throw new Error('Invalid response from server');
-  }
-  if (data.errorCode || data.errorMessage) {
-    const debugMessage = data.errorMessage || 'Failed to create reservation';
-    const insufficientCapacity = isInsufficientCapacityApiError(data.errorCode, debugMessage);
+  if (payload.errorCode || payload.errorMessage) {
+    const failure = reserveEnvelopeError(payload, 'Failed to create reservation');
+    attempt?.clear();
+    const debugMessage = failure.message;
+    const insufficientCapacity = isInsufficientCapacityApiError(failure.code, debugMessage);
     reportClientFetchError({
       endpoint,
       errorClass: 'APP_ERROR_200',
       message: insufficientCapacity
         ? `[RESERVE_INSUFFICIENT_CAPACITY] ${debugMessage}`
         : debugMessage,
-      errorCode: data.errorCode,
+      errorCode: failure.code,
       metadata: {
         failureKind: insufficientCapacity
           ? 'RESERVE_INSUFFICIENT_CAPACITY'
           : 'RESERVE_APP_ERROR_200',
         reserveRequest: summarizeReserveRequestForTelemetry(request),
         apiErrorMessage: debugMessage,
-        apiErrorCode: data.errorCode ?? null,
+        apiErrorCode: failure.code ?? null,
       },
     });
-    throw createUserError(endpoint, 'APP_ERROR_200', debugMessage, data.errorCode);
-  }
-  if (!data.data?.reservationReference) {
-    throw new Error('Invalid response: missing reservationReference');
+    throw createUserError(endpoint, 'APP_ERROR_200', debugMessage, failure.code);
   }
-  const raw = data.data as {
-    reservationReference: string;
-    reservationExpiration?: string;
-    expiresAt?: string;
-    totalAmount?: number;
-    currency?: string;
-  };
-  const expiration = raw.reservationExpiration ?? raw.expiresAt;
-  if (!expiration) {
-    throw new Error('Invalid response: missing reservation hold expiration');
-  }
-  return {
-    reservationReference: raw.reservationReference,
-    reservationExpiration: expiration,
-    expiresAt: expiration,
-    totalAmount: raw.totalAmount,
-    currency: raw.currency,
-  };
+  const normalized = normalizedReserveResponse(payload.data);
+  if (!normalized) throw new Error('Invalid response: missing reservationReference or hold expiration');
+  attempt?.clear();
+  return normalized;
 }
 
 export async function cancelReservation(reservationReference: string): Promise<void> {

package/src/public-partners.ts

@@ -3,6 +3,11 @@
  * Uses NEXT_PUBLIC_* env from the consuming Next app at build time.
  */
 
+import {
+  parsePartnerPricingProfileOverrides,
+  type PartnerPricingProfileOverride,
+} from './lib/booking/partner-pricing-profile';
+
 function apiBase(): string {
   const u = process.env.NEXT_PUBLIC_API_URL;
   if (!u) {
@@ -51,6 +56,8 @@ export interface PublicPartner {
   anonymousBookAllowed?: boolean;
   /** B2B / partner pricing profile id when the API exposes it (optional). */
   pricingProfileId?: string;
+  /** Month-specific profiles; first matching rule wins and pricingProfileId is the fallback. */
+  pricingProfileOverrides?: PartnerPricingProfileOverride[];
   /** Partner cancellation-policy profile id when the API exposes it (optional). */
   cancellationPolicyProfileId?: string;
 }
@@ -67,7 +74,7 @@ export interface PublicStaffPortalSignInOption {
   displayName: string;
 }
 
-function mapPartnerApiRow(
+export function mapPartnerApiRow(
   r: Record<string, unknown> & { partnerId: string; name: string },
 ): PublicPartner {
   const pickupLocationIds = parsePickupLocationIds(r);
@@ -83,6 +90,9 @@ function mapPartnerApiRow(
         ? cap.pricingProfileId
         : '';
   const pricingProfileId = rawProfile.trim() || undefined;
+  const pricingProfileOverrides = parsePartnerPricingProfileOverrides(
+    r.pricingProfileOverrides ?? cap?.pricingProfileOverrides,
+  );
   const rawCancellationProfile =
     typeof r.cancellationPolicyProfileId === 'string'
       ? r.cancellationPolicyProfileId
@@ -96,6 +106,7 @@ function mapPartnerApiRow(
     anonymousBookAllowed,
     ...(pickupLocationIds?.length ? { pickupLocationIds } : {}),
     ...(pricingProfileId ? { pricingProfileId } : {}),
+    ...(pricingProfileOverrides.length > 0 ? { pricingProfileOverrides } : {}),
     ...(cancellationPolicyProfileId ? { cancellationPolicyProfileId } : {}),
   };
 }

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

@@ -10,6 +10,7 @@ import {
   type ChangeQuoteUiSlice,
 } from '../src/lib/booking/change-flow-pricing';
 import {
+  createReservation,
   mapAdminChangeBookingQuoteV2Data,
   type Availability,
   type ChangeBookingQuoteResponse,
@@ -72,6 +73,11 @@ import {
   resolveHydratedPrivateShuttleAvailability,
 } from '../src/components/booking/private-shuttle-availability';
 import { sanitizeBookingSourceUrl } from '../src/lib/booking/source-metadata';
+import {
+  getOrCreateReservationAttempt,
+  reservationIdempotencyEnabled,
+  type ReservationAttemptStorage,
+} from '../src/lib/booking/reservation-attempt';
 import {
   formatReservationHoldTime,
   reservationHoldHasExpired,
@@ -2357,3 +2363,125 @@ test('private shuttle checkout receipt labels add-on variants and quantities', (
     { name: 'Croissants (Butter Croissant) \u00d7 2', totalAmount: 11.98 },
   ]);
 });
+
+test('reservation attempt reuses one idempotency key for an identical retry', async () => {
+  const values = new Map<string, string>();
+  const storage: ReservationAttemptStorage = {
+    getItem: (key) => values.get(key) ?? null,
+    setItem: (key, value) => values.set(key, value),
+    removeItem: (key) => values.delete(key),
+  };
+  const request = {
+    productId: 'po_test123',
+    dateTime: '2026-08-02T08:00:00-06:00',
+    bookingItems: [{ category: 'ADULT', count: 2 }],
+  };
+  const options = {
+    storage,
+    now: 1_000,
+    createId: () => 'attempt_1234567890abcdef',
+    digest: async (value: string) => `digest-${value.length}`,
+  };
+
+  const first = await getOrCreateReservationAttempt(request, options);
+  const retry = await getOrCreateReservationAttempt(request, {
+    ...options,
+    now: 2_000,
+    createId: () => 'attempt_should_not_be_used',
+  });
+
+  assert.equal(first.idempotencyKey, 'attempt_1234567890abcdef');
+  assert.equal(retry.idempotencyKey, first.idempotencyKey);
+  assert.equal(retry.request.idempotencyKey, first.idempotencyKey);
+});
+
+test('completed reservation attempt is cleared before a later logical attempt', async () => {
+  const values = new Map<string, string>();
+  const storage: ReservationAttemptStorage = {
+    getItem: (key) => values.get(key) ?? null,
+    setItem: (key, value) => values.set(key, value),
+    removeItem: (key) => values.delete(key),
+  };
+  const request = { productId: 'po_test123', dateTime: '2026-08-02', bookingItems: [] };
+  const digest = async () => 'same-request';
+  const first = await getOrCreateReservationAttempt(request, {
+    storage,
+    digest,
+    createId: () => 'attempt_1234567890abcdef',
+  });
+  first.clear();
+  const later = await getOrCreateReservationAttempt(request, {
+    storage,
+    digest,
+    createId: () => 'attempt_fedcba0987654321',
+  });
+
+  assert.equal(later.idempotencyKey, 'attempt_fedcba0987654321');
+});
+
+test('reservation idempotency requires an explicit frontend build flag', () => {
+  assert.equal(reservationIdempotencyEnabled(undefined), false);
+  assert.equal(reservationIdempotencyEnabled('TRUE'), true);
+});
+
+test('lost reserve response is recovered without submitting a second reservation', async () => {
+  const originalFetch = globalThis.fetch;
+  const originalFlag = process.env.NEXT_PUBLIC_RESERVATION_IDEMPOTENCY_ENABLED;
+  const calls: Array<{ url: string; body: { data?: { idempotencyKey?: string } } }> = [];
+  let scenario: 'network-loss' | 'gateway-timeout' = 'network-loss';
+  process.env.NEXT_PUBLIC_RESERVATION_IDEMPOTENCY_ENABLED = 'true';
+  globalThis.fetch = async (input, init) => {
+    const url = String(input);
+    const body = JSON.parse(String(init?.body ?? '{}')) as { data?: { idempotencyKey?: string } };
+    calls.push({ url, body });
+    if (url.endsWith('/1/reserve')) {
+      if (scenario === 'network-loss') {
+        throw new Error('connection closed after request was sent');
+      }
+      return new Response('Gateway timeout', { status: 504 });
+    }
+    return new Response(
+      JSON.stringify({
+        data: {
+          reservationReference:
+            scenario === 'network-loss' ? 'resRef_RECOVERED' : 'resRef_TIMEOUT_RECOVERED',
+          reservationExpiration: '2026-08-01T18:10:00Z',
+        },
+      }),
+      { status: 200, headers: { 'Content-Type': 'application/json' } }
+    );
+  };
+
+  try {
+    const result = await createReservation({
+      productId: 'po_test123',
+      dateTime: '2026-08-02T08:00:00-06:00',
+      bookingItems: [{ category: 'ADULT', count: 2 }],
+    });
+
+    assert.equal(result.reservationReference, 'resRef_RECOVERED');
+    assert.equal(calls.filter((call) => call.url.endsWith('/1/reserve')).length, 1);
+    assert.equal(calls.filter((call) => call.url.endsWith('/1/reserve/status')).length, 1);
+    assert.match(calls[0].body.data?.idempotencyKey ?? '', /^attempt_[a-f0-9]{32}$/);
+    assert.equal(calls[1].body.data?.idempotencyKey, calls[0].body.data?.idempotencyKey);
+
+    scenario = 'gateway-timeout';
+    calls.length = 0;
+    const timeoutResult = await createReservation({
+      productId: 'po_test123',
+      dateTime: '2026-08-03T08:00:00-06:00',
+      bookingItems: [{ category: 'ADULT', count: 2 }],
+    });
+
+    assert.equal(timeoutResult.reservationReference, 'resRef_TIMEOUT_RECOVERED');
+    assert.equal(calls.filter((call) => call.url.endsWith('/1/reserve')).length, 1);
+    assert.equal(calls.filter((call) => call.url.endsWith('/1/reserve/status')).length, 1);
+  } finally {
+    globalThis.fetch = originalFetch;
+    if (originalFlag === undefined) {
+      delete process.env.NEXT_PUBLIC_RESERVATION_IDEMPOTENCY_ENABLED;
+    } else {
+      process.env.NEXT_PUBLIC_RESERVATION_IDEMPOTENCY_ENABLED = originalFlag;
+    }
+  }
+});

package/test/partner-pricing-profile.test.ts

@@ -0,0 +1,46 @@
+import assert from 'node:assert/strict';
+
+import { mapPartnerApiRow } from '../src/public-partners';
+import {
+  parsePartnerPricingProfileOverrides,
+  resolvePartnerPricingProfileId,
+} from '../src/lib/booking/partner-pricing-profile';
+
+const overrides = parsePartnerPricingProfileOverrides([
+  {
+    pricingProfileId: 'pp_banff_adventures_july_aug_sept',
+    months: [7, 8, 9],
+  },
+]);
+
+for (const bookingDate of ['2026-07-01', '2026-08-02', '2026-09-30']) {
+  assert.equal(
+    resolvePartnerPricingProfileId('pp_banff_adventures', overrides, bookingDate),
+    'pp_banff_adventures_july_aug_sept',
+  );
+}
+for (const bookingDate of ['2026-06-30', '2026-10-01']) {
+  assert.equal(
+    resolvePartnerPricingProfileId('pp_banff_adventures', overrides, bookingDate),
+    'pp_banff_adventures',
+  );
+}
+
+const mapped = mapPartnerApiRow({
+  partnerId: 'par_U4md9ZBsf3uR',
+  name: 'Banff Adventures',
+  capabilities: {
+    pricingProfileId: 'pp_banff_adventures',
+    pricingProfileOverrides: [
+      {
+        pricingProfileId: 'pp_banff_adventures_july_aug_sept',
+        months: [7, 8, 9],
+      },
+    ],
+  },
+});
+
+assert.equal(mapped.pricingProfileId, 'pp_banff_adventures');
+assert.deepEqual(mapped.pricingProfileOverrides, overrides);
+
+console.log('partner pricing profile tests passed');