letsfg 2026.5.54 → 2026.5.55

package/dist/chunk-7C3EKQ37.mjs

@@ -0,0 +1,1768 @@
+// src/offer-details.ts
+var MEAL_RE = /\b(meal|meals|meal service|hot meal|catering|breakfast|lunch|dinner|santan)\b/i;
+var REFRESHMENT_RE = /\b(refreshment|refreshments|drink|drinks|beverage|beverages|snack|snacks|food and drink)\b/i;
+var INSURANCE_RE = /\b(insurance|coverage|protection|travel insurance|disruption cover)\b/i;
+var LOUNGE_RE = /\b(lounge|vip lounge|priority pass|airport lounge)\b/i;
+var WIFI_RE = /\b(wi[ -]?fi|wifi|internet access|onboard internet|wireless internet)\b/i;
+var POWER_RE = /\b(in[- ]?seat power|usb outlets?|usb ports?|usb power|power outlets?|power sockets?|ac power|seat power|charging ports?|charging outlets?)\b/i;
+var ENTERTAINMENT_RE = /\b(in[- ]?flight entertainment|ife|seatback screen|entertainment screen|personal entertainment|stream(?:ing)? media(?: to your device)?|stream to your device|watch on your device)\b/i;
+var WIFI_BARE_RE = /\b(wi[ -]?fi|wifi|internet access|onboard internet|wireless internet)\b/i;
+var POWER_BARE_RE = /\b(in[- ]?seat power|usb outlets?|usb ports?|usb power|power outlets?|power sockets?|ac power|seat power|charging ports?|charging outlets?)\b/i;
+var ENTERTAINMENT_BARE_RE = /\b(in[- ]?flight entertainment|ife|seatback screen|entertainment screen|personal entertainment|stream(?:ing)? media(?: to your device)?|stream to your device|watch on your device)\b/i;
+var SERVICE_INCLUDED_RE = /\b(included?|incl\.?|includes?|including|with|complimentary|provided|free of charge|free)\b/i;
+var SERVICE_AVAILABLE_RE = /\b(available|optional|option|add[- ]?on|extra|for a fee|with a fee|fee|charges may apply|buy[- ]?on[- ]?board|sold separately|upgrade)\b/i;
+var SERVICE_UNAVAILABLE_RE = /\b(not available|unavailable|not offered|not included|not possible|sold[- ]?out)\b/i;
+var REFUND_TEXT_RE = /\b(refund|refundable|cancell|cancel)\b/i;
+var REFUND_NOT_ALLOWED_RE = /\b(non[- ]?refundable|not refundable|no refunds?|refunds? not allowed|cancellations? not allowed)\b/i;
+var REFUND_WITH_FEE_RE = /\b(refund|refundable|cancell|cancel)\b.*\b(with fee|fee|penalty|charges may apply)\b/i;
+var REFUND_ALLOWED_RE = /\b(refundable|refunds? allowed|cancellations? allowed|cancel(?:lation)? allowed|free of charge)\b/i;
+var CHANGE_TEXT_RE = /\b(change|changes|changeable|rebook|rebooking)\b/i;
+var CHANGE_NOT_ALLOWED_RE = /\b(no changes?|changes? not allowed|not changeable|not possible)\b/i;
+var CHANGE_WITH_FEE_RE = /\b(change|changes|rebook|rebooking)\b.*\b(with fee|fee|penalty|charges may apply)\b/i;
+var CHANGE_ALLOWED_RE = /\b(changes? allowed|changeable|rebook(?:ing)? allowed|free of charge)\b/i;
+var SEAT_SELECTION_RE = /\b(seat selection|select your seat|choose your seat|choose seats?|seat choice|standard seat|extra legroom|preferred seat)\b/i;
+var LEGROOM_RE = /\b(?:average\s+legroom|extra legroom|legroom|pitch)\b/i;
+function normalizeDetailText(value) {
+  const withoutKey = value.replace(/^[a-z][a-z_ ]{0,40}:\s*/i, "");
+  return withoutKey.replace(/\s+/g, " ").trim();
+}
+function truncateDetailText(value, maxLength = 96) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, maxLength - 3).trimEnd()}...`;
+}
+function pushUniqueNote(notes, note) {
+  if (!note || notes.includes(note)) {
+    return;
+  }
+  notes.push(note);
+}
+function getConditionValue(offer, ...keys) {
+  for (const key of keys) {
+    const value = offer.conditions?.[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+  return null;
+}
+function summarizeConditionList(value, maxItems = 3) {
+  if (!value) {
+    return null;
+  }
+  const parts = splitDetailText(value).map((part) => normalizeDetailText(part)).filter((part) => part.length > 0);
+  if (parts.length === 0) {
+    return null;
+  }
+  return truncateDetailText(parts.slice(0, maxItems).join("; "));
+}
+function collectOfferSegments(offer) {
+  return [
+    ...offer.segments ?? [],
+    ...offer.inbound?.segments ?? []
+  ];
+}
+function collectUniqueDetailValues(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const output = [];
+  for (const value of values) {
+    const normalized = typeof value === "string" ? value.trim() : "";
+    if (!normalized) {
+      continue;
+    }
+    const key = normalized.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    output.push(normalized);
+  }
+  return output;
+}
+function collectFlightNumbers(offer) {
+  const segmentFlightNumbers = collectOfferSegments(offer).map((segment) => segment.flight_number);
+  return collectUniqueDetailValues([
+    ...segmentFlightNumbers,
+    offer.flight_number
+  ]);
+}
+function collectAircraftTypes(offer) {
+  return collectUniqueDetailValues(
+    collectOfferSegments(offer).map((segment) => segment.aircraft?.replace(/\s*\([^)]*\)/g, "").trim())
+  );
+}
+function collectOperatingCarriers(offer) {
+  return collectUniqueDetailValues(
+    collectOfferSegments(offer).map((segment) => segment.airline)
+  );
+}
+function findMatchingSourceText(sources, pattern) {
+  for (const source of sources) {
+    if (!pattern.test(source.text)) {
+      continue;
+    }
+    const cleaned = normalizeDetailText(source.text);
+    if (cleaned.length > 0) {
+      return truncateDetailText(cleaned);
+    }
+  }
+  return null;
+}
+function formatFareFamilyBadgeLabel(value) {
+  return truncateDetailText(`Fare: ${value}`, 28);
+}
+function splitDetailText(value) {
+  return value.split(/(?:\r?\n|;|•|\|)+/).map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function collectTextSources(offer) {
+  const sources = [];
+  const ancillaries = offer.ancillaries;
+  for (const ancillary of [ancillaries?.cabin_bag, ancillaries?.checked_bag, ancillaries?.seat_selection]) {
+    if (typeof ancillary?.description === "string" && ancillary.description.trim().length > 0) {
+      for (const fragment of splitDetailText(ancillary.description.trim())) {
+        sources.push({
+          text: fragment,
+          included: ancillary.included,
+          source: "ancillary"
+        });
+      }
+    }
+  }
+  for (const [key, value] of Object.entries(offer.conditions ?? {})) {
+    if (key === "refund_before_departure" || key === "change_before_departure") {
+      continue;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+      for (const fragment of splitDetailText(value.trim())) {
+        sources.push({
+          text: `${key.replace(/_/g, " ")}: ${fragment}`,
+          source: "condition"
+        });
+      }
+    }
+  }
+  return sources;
+}
+function buildUnknownAmenityAssessment() {
+  return {
+    state: "unknown",
+    confidence: "unknown",
+    source: "unknown"
+  };
+}
+function scoreAmenityAssessment(assessment) {
+  const confidenceScore = assessment.confidence === "verified" ? 20 : assessment.confidence === "inferred" ? 10 : 0;
+  const stateScore = assessment.state === "included" ? 3 : assessment.state === "available" ? 2 : assessment.state === "unavailable" ? 1 : 0;
+  return confidenceScore + stateScore;
+}
+function chooseAmenityAssessment(current, next) {
+  return scoreAmenityAssessment(next) > scoreAmenityAssessment(current) ? next : current;
+}
+function normalizeAmenitySignal(assessment) {
+  if (assessment.confidence !== "verified") {
+    return null;
+  }
+  if (assessment.state === "included" || assessment.state === "available") {
+    return assessment.state;
+  }
+  return null;
+}
+function assessServiceSignal(pattern, sources, options) {
+  let best = buildUnknownAmenityAssessment();
+  for (const source of sources) {
+    if (!pattern.test(source.text)) {
+      continue;
+    }
+    const normalized = source.text.toLowerCase();
+    let candidate;
+    if (SERVICE_UNAVAILABLE_RE.test(normalized)) {
+      candidate = {
+        state: "unavailable",
+        confidence: "verified",
+        source: source.source,
+        evidence: source.text
+      };
+    } else if (SERVICE_AVAILABLE_RE.test(normalized) || source.included === false) {
+      candidate = {
+        state: "available",
+        confidence: "verified",
+        source: source.source,
+        evidence: source.text
+      };
+    } else if (SERVICE_INCLUDED_RE.test(normalized)) {
+      candidate = {
+        state: "included",
+        confidence: "verified",
+        source: source.source,
+        evidence: source.text
+      };
+    } else if (options?.barePattern?.test(normalized)) {
+      candidate = {
+        state: options.bareState ?? "included",
+        confidence: "verified",
+        source: source.source,
+        evidence: source.text
+      };
+    } else if (source.included === true) {
+      candidate = {
+        state: "included",
+        confidence: "inferred",
+        source: source.source,
+        evidence: source.text
+      };
+    } else {
+      candidate = {
+        state: "available",
+        confidence: "inferred",
+        source: source.source,
+        evidence: source.text
+      };
+    }
+    best = chooseAmenityAssessment(best, candidate);
+  }
+  return best;
+}
+function classifyConditionStateFromText(sources, textRe, notAllowedRe, withFeeRe, allowedRe) {
+  for (const source of sources) {
+    const normalized = source.text.toLowerCase();
+    if (!textRe.test(normalized)) {
+      continue;
+    }
+    if (notAllowedRe.test(normalized)) {
+      return "not_allowed";
+    }
+    if (withFeeRe.test(normalized)) {
+      return "allowed_with_fee";
+    }
+    if (allowedRe.test(normalized)) {
+      return "allowed";
+    }
+  }
+  return null;
+}
+function extractOfferDetailSignals(offer) {
+  const textSources = collectTextSources(offer);
+  const mealAssessment = assessServiceSignal(MEAL_RE, textSources);
+  const refreshmentAssessment = assessServiceSignal(REFRESHMENT_RE, textSources);
+  const insuranceAssessment = assessServiceSignal(INSURANCE_RE, textSources);
+  const loungeAssessment = assessServiceSignal(LOUNGE_RE, textSources);
+  const wifiAssessment = assessServiceSignal(WIFI_RE, textSources, {
+    barePattern: WIFI_BARE_RE,
+    bareState: "available"
+  });
+  const powerAssessment = assessServiceSignal(POWER_RE, textSources, {
+    barePattern: POWER_BARE_RE,
+    bareState: "included"
+  });
+  const entertainmentAssessment = assessServiceSignal(ENTERTAINMENT_RE, textSources, {
+    barePattern: ENTERTAINMENT_BARE_RE,
+    bareState: "included"
+  });
+  return {
+    refundability: offer.conditions?.refund_before_departure ?? classifyConditionStateFromText(
+      textSources,
+      REFUND_TEXT_RE,
+      REFUND_NOT_ALLOWED_RE,
+      REFUND_WITH_FEE_RE,
+      REFUND_ALLOWED_RE
+    ),
+    changeability: offer.conditions?.change_before_departure ?? classifyConditionStateFromText(
+      textSources,
+      CHANGE_TEXT_RE,
+      CHANGE_NOT_ALLOWED_RE,
+      CHANGE_WITH_FEE_RE,
+      CHANGE_ALLOWED_RE
+    ),
+    meals: normalizeAmenitySignal(mealAssessment),
+    refreshments: normalizeAmenitySignal(refreshmentAssessment),
+    insurance: normalizeAmenitySignal(insuranceAssessment),
+    lounge: normalizeAmenitySignal(loungeAssessment),
+    wifi: normalizeAmenitySignal(wifiAssessment),
+    power: normalizeAmenitySignal(powerAssessment),
+    entertainment: normalizeAmenitySignal(entertainmentAssessment),
+    amenities: {
+      meals: mealAssessment,
+      refreshments: refreshmentAssessment,
+      insurance: insuranceAssessment,
+      lounge: loungeAssessment,
+      wifi: wifiAssessment,
+      power: powerAssessment,
+      entertainment: entertainmentAssessment
+    }
+  };
+}
+var AMENITY_BADGE_META = [
+  {
+    key: "meals",
+    included: { key: "meal_included", label: "Meal included", tone: "positive" },
+    available: { key: "meal_option", label: "Meal option", tone: "neutral" },
+    includedNote: "Meal included in the fare data",
+    availableNote: "Meal option shown in the fare data"
+  },
+  {
+    key: "refreshments",
+    included: { key: "refreshments_included", label: "Refreshments included", tone: "positive" },
+    available: { key: "refreshments_option", label: "Refreshments available", tone: "neutral" },
+    includedNote: "Refreshments included in the fare data",
+    availableNote: "Refreshments shown in the fare data"
+  },
+  {
+    key: "wifi",
+    included: { key: "wifi_included", label: "Wi-Fi included", tone: "positive" },
+    available: { key: "wifi_available", label: "Wi-Fi available", tone: "neutral" },
+    includedNote: "Wi-Fi included in the fare data",
+    availableNote: "Wi-Fi availability shown in the fare data"
+  },
+  {
+    key: "power",
+    included: { key: "power_included", label: "USB / power at seat", tone: "positive" },
+    available: { key: "power_available", label: "USB / power available", tone: "neutral" },
+    includedNote: "USB or power outlet shown in the fare data",
+    availableNote: "USB or power availability shown in the fare data"
+  },
+  {
+    key: "entertainment",
+    included: { key: "ife_included", label: "In-flight entertainment", tone: "positive" },
+    available: { key: "ife_available", label: "Entertainment available", tone: "neutral" },
+    includedNote: "In-flight entertainment shown in the fare data",
+    availableNote: "Entertainment availability shown in the fare data"
+  },
+  {
+    key: "insurance",
+    included: { key: "insurance_included", label: "Insurance included", tone: "positive" },
+    available: { key: "insurance_option", label: "Insurance option", tone: "neutral" },
+    includedNote: "Insurance included in the fare data",
+    availableNote: "Insurance option shown in the fare data"
+  },
+  {
+    key: "lounge",
+    included: { key: "lounge_included", label: "Lounge included", tone: "positive" },
+    available: { key: "lounge_option", label: "Lounge option", tone: "neutral" },
+    includedNote: "Lounge access included in the fare data",
+    availableNote: "Lounge access option shown in the fare data"
+  }
+];
+function getOfferDetailBadges(offer) {
+  const signals = extractOfferDetailSignals(offer);
+  const badges = [];
+  const fareFamily = getConditionValue(offer, "fare_family", "fare_bundle");
+  if (signals.refundability === "allowed" && signals.changeability === "allowed") {
+    badges.push({ key: "flexible", label: "Flexible fare", tone: "positive" });
+  } else {
+    if (signals.refundability === "allowed") {
+      badges.push({ key: "refund_allowed", label: "Refundable", tone: "positive" });
+    } else if (signals.refundability === "allowed_with_fee") {
+      badges.push({ key: "refund_fee", label: "Refund with fee", tone: "neutral" });
+    } else if (signals.refundability === "not_allowed") {
+      badges.push({ key: "refund_none", label: "No refund", tone: "negative" });
+    }
+    if (signals.changeability === "allowed") {
+      badges.push({ key: "change_allowed", label: "Changes allowed", tone: "positive" });
+    } else if (signals.changeability === "allowed_with_fee") {
+      badges.push({ key: "change_fee", label: "Changes with fee", tone: "neutral" });
+    } else if (signals.changeability === "not_allowed") {
+      badges.push({ key: "change_none", label: "No changes", tone: "negative" });
+    }
+  }
+  if (fareFamily) {
+    badges.push({ key: "fare_family", label: formatFareFamilyBadgeLabel(fareFamily), tone: "neutral" });
+  }
+  for (const amenity of AMENITY_BADGE_META) {
+    const signal = signals[amenity.key];
+    if (signal === "included") {
+      badges.push(amenity.included);
+    } else if (signal === "available") {
+      badges.push(amenity.available);
+    }
+  }
+  return badges.slice(0, 4);
+}
+function getOfferDetailPromptNotes(offer) {
+  const signals = extractOfferDetailSignals(offer);
+  const textSources = collectTextSources(offer);
+  const notes = [];
+  const fareFamily = getConditionValue(offer, "fare_family", "fare_bundle");
+  const fareBenefits = summarizeConditionList(getConditionValue(offer, "fare_bundle_benefits", "fare_bundle_description"));
+  if (fareFamily) {
+    notes.push(`Fare family shown: ${fareFamily}`);
+  }
+  if (fareBenefits) {
+    notes.push(`Fare bundle benefits shown: ${fareBenefits}`);
+  }
+  if (signals.refundability === "allowed") {
+    notes.push("Refunds allowed before departure");
+  } else if (signals.refundability === "allowed_with_fee") {
+    notes.push("Refunds allowed before departure with a fee");
+  } else if (signals.refundability === "not_allowed") {
+    notes.push("No refunds shown before departure");
+  }
+  if (signals.changeability === "allowed") {
+    notes.push("Changes allowed before departure");
+  } else if (signals.changeability === "allowed_with_fee") {
+    notes.push("Changes allowed before departure with a fee");
+  } else if (signals.changeability === "not_allowed") {
+    notes.push("No changes shown before departure");
+  }
+  for (const amenity of AMENITY_BADGE_META) {
+    const signal = signals[amenity.key];
+    if (signal === "included") {
+      notes.push(amenity.includedNote);
+    } else if (signal === "available") {
+      notes.push(amenity.availableNote);
+    }
+  }
+  const seatSelectionEvidence = findMatchingSourceText(textSources, SEAT_SELECTION_RE);
+  if (seatSelectionEvidence && !(fareBenefits && fareBenefits.toLowerCase().includes(seatSelectionEvidence.toLowerCase()))) {
+    pushUniqueNote(notes, `Seat selection shown in fare data: ${seatSelectionEvidence}`);
+  }
+  const legroomEvidence = findMatchingSourceText(textSources, LEGROOM_RE);
+  if (legroomEvidence) {
+    pushUniqueNote(notes, `Legroom shown in fare data: ${legroomEvidence}`);
+  }
+  const flightNumbers = collectFlightNumbers(offer);
+  if (flightNumbers.length > 0) {
+    pushUniqueNote(notes, `Flight numbers shown: ${flightNumbers.join(", ")}`);
+  }
+  const aircraftTypes = collectAircraftTypes(offer);
+  if (aircraftTypes.length > 0) {
+    pushUniqueNote(notes, `Aircraft shown: ${aircraftTypes.join(", ")}`);
+  }
+  const operatingCarriers = collectOperatingCarriers(offer);
+  const normalizedOfferAirline = typeof offer.airline === "string" ? offer.airline.trim().toLowerCase() : "";
+  if (operatingCarriers.length === 1 && operatingCarriers[0].toLowerCase() !== normalizedOfferAirline) {
+    pushUniqueNote(notes, `Operating carrier shown: ${operatingCarriers[0]}`);
+  } else if (operatingCarriers.length > 1) {
+    pushUniqueNote(notes, `Operating carriers shown: ${operatingCarriers.join(", ")}`);
+  }
+  return notes;
+}
+
+// src/trip-purpose.ts
+var TRIP_PURPOSES = [
+  "honeymoon",
+  "special_occasion",
+  "business",
+  "ski",
+  "beach",
+  "city_break",
+  "family_holiday",
+  "graduation",
+  "concert_festival",
+  "sports_event",
+  "spring_break"
+];
+function normalizeTripPurposes({ tripPurpose, tripPurposes }) {
+  const normalized = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const purpose of tripPurposes ?? []) {
+    if (!purpose || seen.has(purpose)) continue;
+    seen.add(purpose);
+    normalized.push(purpose);
+  }
+  if (tripPurpose && !seen.has(tripPurpose)) {
+    normalized.push(tripPurpose);
+  }
+  return normalized;
+}
+function getPrimaryTripPurpose(options) {
+  return normalizeTripPurposes(options)[0];
+}
+
+// src/ranking.ts
+var GF_SAVINGS_COMPARISON_ENABLED = false;
+function normalizeGoogleFlightsComparisonPrice(googleFlightsPrice, _travelerCount = 1) {
+  if (!Number.isFinite(googleFlightsPrice)) {
+    return null;
+  }
+  const normalized = Math.round(googleFlightsPrice * 100) / 100;
+  return normalized > 0 ? normalized : null;
+}
+function getOfferInstanceKey(offer) {
+  return [
+    offer.id,
+    offer.departure_time,
+    offer.arrival_time,
+    offer.stops,
+    offer.inbound?.departure_time ?? "",
+    offer.inbound?.arrival_time ?? "",
+    offer.inbound?.stops ?? ""
+  ].join("|");
+}
+var W = {
+  // Generic solo / default — price-driven
+  default: {
+    price: 0.34,
+    stops: 0.22,
+    duration: 0.12,
+    depTime: 0.08,
+    arrivalTime: 0.04,
+    baggage: 0.02,
+    savings: 0.06,
+    comfortHours: 0.04,
+    layover: 0.08
+  },
+  // Business — time and directness > price; long layovers are unacceptable
+  business_traveler: {
+    price: 0.1,
+    stops: 0.26,
+    duration: 0.2,
+    depTime: 0.18,
+    arrivalTime: 0.04,
+    baggage: 0.06,
+    savings: 0,
+    comfortHours: 0.06,
+    layover: 0.1
+  },
+  // Family — directness + baggage practicality; kids + 8h layover = nightmare
+  family: {
+    price: 0.12,
+    stops: 0.2,
+    duration: 0.16,
+    depTime: 0.08,
+    arrivalTime: 0.04,
+    baggage: 0.2,
+    savings: 0.04,
+    comfortHours: 0.08,
+    layover: 0.08
+  },
+  // Couple — balance of price, comfort, arrival time, savings
+  couple: {
+    price: 0.22,
+    stops: 0.2,
+    duration: 0.12,
+    depTime: 0.1,
+    arrivalTime: 0.14,
+    baggage: 0.02,
+    savings: 0.1,
+    comfortHours: 0.04,
+    layover: 0.06
+  },
+  // Honeymoon — direct > everything; no one wants a 10h layover on their honeymoon
+  honeymoon: {
+    price: 0.08,
+    stops: 0.28,
+    duration: 0.1,
+    depTime: 0.14,
+    arrivalTime: 0.18,
+    baggage: 0.02,
+    savings: 0.02,
+    comfortHours: 0.08,
+    layover: 0.1
+  },
+  // Special occasion — still prioritize smooth timing/directness, but keep price meaningful.
+  special_occasion: {
+    price: 0.14,
+    stops: 0.24,
+    duration: 0.1,
+    depTime: 0.12,
+    arrivalTime: 0.16,
+    baggage: 0.02,
+    savings: 0.06,
+    comfortHours: 0.08,
+    layover: 0.08
+  },
+  // Ski — bag essential (equipment); early arrival to maximize slopes
+  ski: {
+    price: 0.12,
+    stops: 0.16,
+    duration: 0.1,
+    depTime: 0.16,
+    arrivalTime: 0.08,
+    baggage: 0.24,
+    savings: 0.04,
+    comfortHours: 0.02,
+    layover: 0.08
+  },
+  // Beach — arrive early to enjoy the day; price matters
+  beach: {
+    price: 0.24,
+    stops: 0.16,
+    duration: 0.1,
+    depTime: 0.1,
+    arrivalTime: 0.14,
+    baggage: 0.1,
+    savings: 0.06,
+    comfortHours: 0.04,
+    layover: 0.06
+  },
+  // City break — maximize time on the ground; 2-day trip loses half a day to a 6h layover
+  city_break: {
+    price: 0.26,
+    stops: 0.2,
+    duration: 0.08,
+    depTime: 0.12,
+    arrivalTime: 0.16,
+    baggage: 0.02,
+    savings: 0.04,
+    comfortHours: 0.04,
+    layover: 0.08
+  },
+  // Quick flight — user explicitly wants shortest possible total duration
+  quick_flight: {
+    price: 0.14,
+    stops: 0.2,
+    duration: 0.4,
+    depTime: 0.06,
+    arrivalTime: 0.04,
+    baggage: 0.02,
+    savings: 0.04,
+    comfortHours: 0.04,
+    layover: 0.06
+  },
+  // Cheapest — user explicitly asked for lowest price; price overwhelms all other factors
+  cheapest: {
+    price: 0.88,
+    stops: 0.06,
+    duration: 0.03,
+    depTime: 0.01,
+    arrivalTime: 0.01,
+    baggage: 0.01,
+    savings: 0,
+    comfortHours: 0,
+    layover: 0
+  },
+  // Cheapest direct — user asked for BOTH cheapest AND direct/nonstop.
+  // Stops must dominate enough that a direct flight wins even if it costs more;
+  // price wins within the same stop tier (all directs sorted by price, all 1-stops sorted
+  // by price below them, etc.). The scoreStops delta between 0-stop (1.00) and 1-stop (0.40)
+  // is 0.60; with stops weight 0.38 that gap is worth 0.228, which means a 1-stop would
+  // need an enormous price advantage to beat a direct — effectively "direct first".
+  cheapest_direct: {
+    price: 0.52,
+    stops: 0.38,
+    duration: 0.04,
+    depTime: 0.02,
+    arrivalTime: 0.01,
+    baggage: 0.01,
+    savings: 0,
+    comfortHours: 0,
+    layover: 0.02
+  }
+};
+var PURPOSE_WEIGHT_PROFILES = {
+  honeymoon: W.honeymoon,
+  special_occasion: W.special_occasion,
+  business: W.business_traveler,
+  ski: W.ski,
+  beach: W.beach,
+  city_break: W.city_break,
+  family_holiday: W.family,
+  graduation: W.city_break,
+  concert_festival: W.city_break,
+  sports_event: W.city_break,
+  spring_break: W.beach
+};
+var EARLY_ARRIVAL_PURPOSES = /* @__PURE__ */ new Set([
+  "city_break",
+  "beach",
+  "special_occasion",
+  "graduation",
+  "concert_festival",
+  "sports_event",
+  "spring_break"
+]);
+function blendWeights(profiles) {
+  if (profiles.length === 0) return { ...W.default };
+  const blended = {
+    price: 0,
+    stops: 0,
+    duration: 0,
+    depTime: 0,
+    arrivalTime: 0,
+    baggage: 0,
+    savings: 0,
+    comfortHours: 0,
+    layover: 0
+  };
+  for (const profile of profiles) {
+    blended.price += profile.price;
+    blended.stops += profile.stops;
+    blended.duration += profile.duration;
+    blended.depTime += profile.depTime;
+    blended.arrivalTime += profile.arrivalTime;
+    blended.baggage += profile.baggage;
+    blended.savings += profile.savings;
+    blended.comfortHours += profile.comfortHours;
+    blended.layover += profile.layover;
+  }
+  return {
+    price: blended.price / profiles.length,
+    stops: blended.stops / profiles.length,
+    duration: blended.duration / profiles.length,
+    depTime: blended.depTime / profiles.length,
+    arrivalTime: blended.arrivalTime / profiles.length,
+    baggage: blended.baggage / profiles.length,
+    savings: blended.savings / profiles.length,
+    comfortHours: blended.comfortHours / profiles.length,
+    layover: blended.layover / profiles.length
+  };
+}
+function resolveWeights(ctx) {
+  if (ctx.preferCheapest && ctx.preferDirect) return { ...W.cheapest_direct };
+  if (ctx.preferCheapest) return { ...W.cheapest };
+  const tripPurposes = normalizeTripPurposes({
+    tripPurpose: ctx.tripPurpose,
+    tripPurposes: ctx.tripPurposes
+  });
+  const purposeProfiles = tripPurposes.map((purpose) => PURPOSE_WEIGHT_PROFILES[purpose]);
+  const w = ctx.preferQuickFlight ? { ...W.quick_flight } : purposeProfiles.length > 0 ? blendWeights(purposeProfiles) : ctx.tripContext === "business_traveler" ? { ...W.business_traveler } : ctx.tripContext === "family" ? { ...W.family } : ctx.tripContext === "couple" ? { ...W.couple } : { ...W.default };
+  if (ctx.preferDirect) {
+    const boost = 0.2;
+    w.stops = Math.min(0.5, w.stops + boost);
+    const fromPrice = Math.min(boost * 0.6, Math.max(0.04, w.price) - 0.04);
+    const fromDuration = Math.min(boost - fromPrice, Math.max(0.02, w.duration) - 0.02);
+    w.price -= fromPrice;
+    w.duration -= fromDuration;
+  }
+  if (ctx.maxStops !== void 0 && !ctx.preferDirect) {
+    const boost = 0.12;
+    w.stops = Math.min(0.44, w.stops + boost);
+    const fromPrice = Math.min(boost * 0.6, Math.max(0.04, w.price) - 0.04);
+    const fromDuration = Math.min(boost - fromPrice, Math.max(0.02, w.duration) - 0.02);
+    w.price -= fromPrice;
+    w.duration -= fromDuration;
+  }
+  if (ctx.preferLongLayover) {
+    const boost = 0.12;
+    w.layover = Math.min(0.24, w.layover + boost);
+    const fromPrice = Math.min(boost * 0.6, Math.max(0.04, w.price) - 0.04);
+    const fromDuration = Math.min(boost - fromPrice, Math.max(0.02, w.duration) - 0.02);
+    w.price -= fromPrice;
+    w.duration -= fromDuration;
+  }
+  if (ctx.depTimePref) {
+    const boost = 0.13;
+    w.depTime = Math.min(0.36, w.depTime + boost);
+    const fromArrival = Math.min(boost * 0.65, Math.max(0, w.arrivalTime - 0.03));
+    const fromDuration = Math.min(boost - fromArrival, Math.max(0, w.duration - 0.03));
+    w.arrivalTime -= fromArrival;
+    w.duration -= fromDuration;
+  }
+  if (ctx.requireBag && w.baggage < 0.15) {
+    const boost = 0.12;
+    w.baggage += boost;
+    w.price = Math.max(0.04, w.price - boost * 0.6);
+    w.duration = Math.max(0.02, w.duration - boost * 0.4);
+  }
+  return w;
+}
+function timeConstraintPenalty(depMins, afterMins, beforeMins) {
+  if (afterMins !== void 0 && depMins < afterMins) return 0.05;
+  if (beforeMins !== void 0 && depMins > beforeMins) return 0.05;
+  return 1;
+}
+function depTimeMismatchMultiplier(depMins, depTimePref) {
+  if (!depTimePref) return 1;
+  const s = scoreDepTime(depMins, depTimePref);
+  if (s >= 0.55) return 1;
+  if (s >= 0.3) return 0.8;
+  return 0.55;
+}
+function retDepTimeMismatchMultiplier(offer, retTimePref) {
+  if (!retTimePref) return 1;
+  const retDep = offer.inbound?.departure_time;
+  if (!retDep) return 1;
+  const retDepMins = isoToMins(retDep);
+  const s = scoreDepTime(retDepMins, retTimePref);
+  if (s >= 0.55) return 1;
+  if (s >= 0.15) return 0.88;
+  return 0.7;
+}
+function deduplicateOffers(offers) {
+  const mergeAncillary = (current, next) => {
+    if (!current) return next ? { ...next } : void 0;
+    if (!next) return current;
+    return {
+      included: typeof current.included === "boolean" ? current.included : next.included,
+      price: typeof current.price === "number" ? current.price : next.price,
+      currency: current.currency || next.currency,
+      description: current.description || next.description
+    };
+  };
+  const mergeOfferDetails = (representative, bucketOffers, representativePrice) => {
+    const samePriceMatches = bucketOffers.filter((candidate) => Math.abs((candidate.displayPrice ?? candidate.price) - representativePrice) < 0.01);
+    if (samePriceMatches.length <= 1) {
+      return representative;
+    }
+    let mergedAncillaries = representative.ancillaries ? {
+      cabin_bag: representative.ancillaries.cabin_bag,
+      checked_bag: representative.ancillaries.checked_bag,
+      seat_selection: representative.ancillaries.seat_selection
+    } : void 0;
+    let mergedConditions = representative.conditions ? { ...representative.conditions } : void 0;
+    for (const candidate of samePriceMatches) {
+      if (candidate.ancillaries) {
+        mergedAncillaries = {
+          cabin_bag: mergeAncillary(mergedAncillaries?.cabin_bag, candidate.ancillaries.cabin_bag),
+          checked_bag: mergeAncillary(mergedAncillaries?.checked_bag, candidate.ancillaries.checked_bag),
+          seat_selection: mergeAncillary(mergedAncillaries?.seat_selection, candidate.ancillaries.seat_selection)
+        };
+      }
+      if (candidate.conditions) {
+        const nextConditions = { ...mergedConditions ?? {} };
+        for (const [conditionKey, conditionValue] of Object.entries(candidate.conditions)) {
+          if (!conditionValue) continue;
+          const currentValue = nextConditions[conditionKey];
+          if (!currentValue || currentValue === "unknown") {
+            nextConditions[conditionKey] = conditionValue;
+          }
+        }
+        mergedConditions = nextConditions;
+      }
+    }
+    return {
+      ...representative,
+      ancillaries: mergedAncillaries,
+      conditions: mergedConditions
+    };
+  };
+  const bucket = (iso) => Math.round(isoToMins(iso) / 30);
+  const dayKey = (iso) => {
+    if (!iso) return "";
+    const d = new Date(iso);
+    return isNaN(d.getTime()) ? "" : d.toISOString().slice(0, 10);
+  };
+  const legKey = (departureTime, arrivalTime, origin, destination, stops, segments) => {
+    const intermediate = segments && segments.length > 1 ? segments.slice(0, -1).map((s) => (s.destination ?? "").toUpperCase()).filter(Boolean).sort().join(",") : "";
+    return [
+      dayKey(departureTime),
+      (origin ?? "").toUpperCase(),
+      (destination ?? "").toUpperCase(),
+      departureTime ? bucket(departureTime) : "",
+      arrivalTime ? bucket(arrivalTime) : "",
+      stops ?? "",
+      intermediate
+    ].join("_");
+  };
+  const normRefund = (c) => c === "allowed" || c === "allowed_with_fee" ? c : "nonrefundable";
+  const key = (o) => [
+    (o.airline ?? "").toUpperCase(),
+    legKey(o.departure_time, o.arrival_time, o.origin, o.destination, o.stops, o.segments),
+    o.inbound ? legKey(
+      o.inbound.departure_time,
+      o.inbound.arrival_time,
+      o.inbound.origin,
+      o.inbound.destination,
+      o.inbound.stops,
+      o.inbound.segments
+    ) : "oneway",
+    normRefund(o.conditions?.refund_before_departure)
+  ].join("_");
+  const buckets = /* @__PURE__ */ new Map();
+  offers.forEach((offer, index) => {
+    const offerKey = key(offer);
+    const effectivePrice = offer.displayPrice ?? offer.price;
+    const bucketState = buckets.get(offerKey);
+    if (!bucketState) {
+      buckets.set(offerKey, {
+        minPrice: effectivePrice,
+        representative: offer,
+        representativeIndex: index,
+        offers: [offer]
+      });
+      return;
+    }
+    bucketState.offers.push(offer);
+    if (effectivePrice < bucketState.minPrice - 0.01) {
+      bucketState.minPrice = effectivePrice;
+      bucketState.representative = offer;
+      bucketState.representativeIndex = index;
+    }
+  });
+  return [...buckets.values()].sort((left, right) => left.representativeIndex - right.representativeIndex).map((bucketState) => mergeOfferDetails(bucketState.representative, bucketState.offers, bucketState.minPrice));
+}
+function isoToMins(iso) {
+  if (!iso) return 0;
+  const match = /T(\d{2}):(\d{2})/.exec(iso);
+  if (match) return parseInt(match[1], 10) * 60 + parseInt(match[2], 10);
+  const d = new Date(iso);
+  if (isNaN(d.getTime())) return 0;
+  return d.getUTCHours() * 60 + d.getUTCMinutes();
+}
+function daysBetween(depIso, arrIso) {
+  if (!depIso || !arrIso) return 0;
+  const dep = new Date(depIso);
+  const arr = new Date(arrIso);
+  if (isNaN(dep.getTime()) || isNaN(arr.getTime())) return 0;
+  const depDay = Math.floor(dep.getTime() / 864e5);
+  const arrDay = Math.floor(arr.getTime() / 864e5);
+  return Math.max(0, arrDay - depDay);
+}
+function formatMins(mins) {
+  const h = Math.floor(mins / 60) % 24;
+  const m = mins % 60;
+  const ampm = h >= 12 ? "pm" : "am";
+  const h12 = h === 0 ? 12 : h > 12 ? h - 12 : h;
+  return `${h12}:${m.toString().padStart(2, "0")}${ampm}`;
+}
+function p5p95(arr) {
+  if (arr.length === 0) return [0, 0];
+  const s = [...arr].sort((a, b) => a - b);
+  const lo = s[Math.floor(s.length * 0.05)] ?? s[0];
+  const hi = s[Math.min(s.length - 1, Math.ceil(s.length * 0.95) - 1)];
+  return [lo, hi];
+}
+function scorePrice(price, lo, hi) {
+  if (hi <= lo) return 1;
+  return 1 - Math.max(0, Math.min(1, (price - lo) / (hi - lo)));
+}
+function scoreDuration(mins, lo, hi) {
+  if (hi <= lo) return 0.8;
+  return 1 - Math.max(0, Math.min(1, (mins - lo) / (hi - lo)));
+}
+function scoreStops(stops) {
+  if (stops === 0) return 1;
+  if (stops === 1) return 0.4;
+  if (stops === 2) return 0.14;
+  return 0.04;
+}
+var TIME_RANGES = {
+  // [perfectLo, perfectHi, okLo, okHi] — all in minutes from midnight
+  early_morning: [0, 330, 330, 420],
+  morning: [360, 660, 300, 750],
+  afternoon: [720, 1020, 660, 1140],
+  evening: [1080, 1320, 1020, 1380],
+  // "night" is later/stricter than "evening" — when a user says "Sunday night
+  // back" they mean ~21:00+, not 18:00. Perfect 21:00–23:30, ok 20:00–23:59.
+  // A 18:20 return fails this gate while still passing the evening gate.
+  night: [1260, 1410, 1200, 1439],
+  red_eye: [1320, 1439, 0, 420]
+};
+function scoreDepTime(depMins, pref) {
+  if (!pref) {
+    if (depMins >= 360 && depMins <= 1260) return 0.8;
+    if (depMins >= 270 && depMins <= 1380) return 0.5;
+    return 0.2;
+  }
+  const r = TIME_RANGES[pref];
+  if (!r) return 0.5;
+  const [pLo, pHi, oLo, oHi] = r;
+  if (depMins >= pLo && depMins <= pHi) return 1;
+  if (depMins >= oLo && depMins <= oHi) return 0.6;
+  const distBelowOk = Math.max(0, oLo - depMins);
+  const distAboveOk = Math.max(0, depMins - oHi);
+  const dist = distBelowOk > 0 ? distBelowOk : distAboveOk;
+  const span = oHi - oLo;
+  return Math.max(0.05, 0.2 * Math.exp(-dist / Math.max(span * 1.5, 60)));
+}
+function scoreArrivalTime(arrMins, pref, tripPurposes, dayOffset = 0) {
+  const isExploring = (tripPurposes ?? []).some((purpose) => EARLY_ARRIVAL_PURPOSES.has(purpose));
+  if (!pref && !isExploring) return 0.5;
+  let base;
+  if (pref === "morning") {
+    if (arrMins < 720) base = 1;
+    else if (arrMins < 900) base = 0.65;
+    else base = 0.25;
+  } else if (pref === "afternoon") {
+    if (arrMins >= 720 && arrMins < 1020) base = 1;
+    else if (arrMins < 1140) base = 0.65;
+    else base = 0.25;
+  } else if (pref === "evening") {
+    if (arrMins >= 1020 && arrMins < 1320) base = 1;
+    else if (arrMins >= 900) base = 0.65;
+    else base = 0.25;
+  } else {
+    if (arrMins < 360) {
+      base = dayOffset >= 1 ? 0.15 : 0.3;
+    } else if (arrMins < 600) base = 1;
+    else if (arrMins < 720) base = 0.85;
+    else if (arrMins < 900) base = 0.7;
+    else if (arrMins < 1080) base = 0.55;
+    else if (arrMins < 1260) base = 0.35;
+    else base = 0.15;
+  }
+  if (dayOffset >= 2) {
+    const extraDays = dayOffset - 1;
+    const penalty = isExploring ? Math.min(base, extraDays * 0.45) : Math.min(base, extraDays * 0.25);
+    base = Math.max(0, base - penalty);
+  }
+  return base;
+}
+function scoreBaggage(offer, requireBag) {
+  const bag = offer.ancillaries?.checked_bag;
+  const isIncluded = bag?.included === true;
+  const fee = bag?.included === false ? bag?.price ?? null : null;
+  if (!requireBag) {
+    return isIncluded ? 0.8 : 0.5;
+  }
+  if (isIncluded) return 1;
+  if (fee === null) return 0.3;
+  const ratio = fee / Math.max(offer.price, 1);
+  if (ratio < 0.05) return 0.72;
+  if (ratio < 0.12) return 0.52;
+  if (ratio < 0.22) return 0.32;
+  return 0.12;
+}
+function scoreSavings(offer, travelerCount) {
+  const gfp = normalizeGoogleFlightsComparisonPrice(offer.google_flights_price, travelerCount);
+  if (!gfp || gfp <= 0) return 0.5;
+  const pct = (gfp - offer.price) / gfp;
+  if (pct >= 0.2) return 1;
+  if (pct >= 0.12) return 0.85;
+  if (pct >= 0.06) return 0.72;
+  if (pct >= 0.01) return 0.6;
+  if (pct >= -0.05) return 0.48;
+  return 0.22;
+}
+function scoreComfortHours(depMins) {
+  if (depMins >= 360 && depMins <= 1320) return 1;
+  if (depMins >= 270 && depMins <= 1380) return 0.6;
+  if (depMins >= 180) return 0.3;
+  return 0.1;
+}
+function scoreLayover(offer, preferLong = false) {
+  const outStops = offer.stops ?? 0;
+  const inStops = offer.inbound?.stops ?? 0;
+  if (outStops === 0 && inStops === 0) return preferLong ? 0.7 : 1;
+  const layoverMins = [
+    ...offer.segments ?? [],
+    ...offer.inbound?.segments ?? []
+  ].filter((s) => (s.layover_minutes ?? 0) > 0).map((s) => s.layover_minutes);
+  if (layoverMins.length === 0) return 0.5;
+  const worst = Math.max(...layoverMins);
+  if (preferLong) {
+    if (worst < 40) return 0.1;
+    if (worst < 120) return 0.3;
+    if (worst < 240) return 0.55;
+    if (worst < 480) return 0.78;
+    if (worst <= 900) return 1;
+    if (worst <= 1440) return 0.92;
+    return 0.75;
+  }
+  if (worst < 40) return 0.1;
+  if (worst < 60) return 0.35;
+  if (worst <= 180) return 1;
+  if (worst <= 240) return 0.82;
+  if (worst <= 360) return 0.55;
+  if (worst <= 480) return 0.28;
+  if (worst <= 660) return 0.12;
+  return 0.04;
+}
+function combinedStops(offer) {
+  const out = offer.stops ?? 0;
+  const inb = offer.inbound?.stops ?? 0;
+  return Math.max(out, inb);
+}
+function totalRoundTripDuration(offer) {
+  const out = offer.duration_minutes ?? 0;
+  if (!offer.inbound) return out;
+  const inb = offer.inbound.duration_minutes ?? 0;
+  return out + inb;
+}
+function refundabilityMultiplier(offer, requireCancellation) {
+  if (!requireCancellation) return 1;
+  const refundability = offer.conditions?.refund_before_departure;
+  if (refundability === "allowed") return 1;
+  if (refundability === "allowed_with_fee") return 0.82;
+  if (refundability === "unknown" || refundability === void 0) return 0.58;
+  return 0.08;
+}
+function mealPreferenceMultiplier(offer, requireMeals) {
+  if (!requireMeals) return 1;
+  const mealSignal = extractOfferDetailSignals(offer).meals;
+  if (mealSignal === "included") return 1;
+  if (mealSignal === "available") return 0.84;
+  return 0.56;
+}
+function generateFacts(offer, bd, refPrice, fastestMins, ctx, travelerCount, isHero) {
+  const heroFacts = [];
+  const tradeoffs = [];
+  const cur = offer.currency;
+  const priceDiff = Math.round(offer.price - refPrice);
+  if (isHero) {
+    if (priceDiff <= 5) {
+      heroFacts.push(`cheapest available (${Math.round(offer.price)} ${cur})`);
+    } else {
+      tradeoffs.push(`${priceDiff} ${cur} above the cheapest option`);
+    }
+  } else {
+    if (priceDiff < -5) {
+      heroFacts.push(`${Math.abs(priceDiff)} ${cur} cheaper than the top pick`);
+    } else if (priceDiff > 5) {
+      tradeoffs.push(`${priceDiff} ${cur} more expensive than the top pick`);
+    }
+  }
+  if (offer.stops === 0) {
+    heroFacts.push("direct flight \u2014 no layovers or connections");
+  } else if (offer.stops === 1) {
+    tradeoffs.push("1 stop");
+  } else {
+    tradeoffs.push(`${offer.stops} stops`);
+  }
+  const normalizedGooglePrice = normalizeGoogleFlightsComparisonPrice(offer.google_flights_price, travelerCount);
+  if (GF_SAVINGS_COMPARISON_ENABLED && normalizedGooglePrice && normalizedGooglePrice > offer.price + 8) {
+    const saving = Math.round(normalizedGooglePrice - offer.price);
+    heroFacts.push(
+      `${saving} ${cur} cheaper than Google Flights (Google shows ${Math.round(normalizedGooglePrice)} ${cur})`
+    );
+  } else if (GF_SAVINGS_COMPARISON_ENABLED && normalizedGooglePrice && offer.price > normalizedGooglePrice + 8) {
+    const extra = Math.round(offer.price - normalizedGooglePrice);
+    tradeoffs.push(`${extra} ${cur} more expensive than Google Flights shows`);
+  }
+  const durDiff = offer.duration_minutes - fastestMins;
+  if (durDiff === 0) {
+    heroFacts.push(
+      `fastest flight on this route (${Math.floor(offer.duration_minutes / 60)}h ${offer.duration_minutes % 60}m)`
+    );
+  } else if (durDiff > 90) {
+    tradeoffs.push(
+      `${Math.floor(durDiff / 60)}h ${durDiff % 60}m longer than the fastest option`
+    );
+  }
+  const depMins = isoToMins(offer.departure_time);
+  if (bd.depTime >= 0.88 && ctx.depTimePref) {
+    heroFacts.push(
+      `departs ${formatMins(depMins)} \u2014 matches your ${ctx.depTimePref.replace("_", " ")} preference`
+    );
+  } else if (bd.depTime <= 0.25 && ctx.depTimePref) {
+    tradeoffs.push(
+      `departure at ${formatMins(depMins)} doesn't match your ${ctx.depTimePref.replace("_", " ")} preference`
+    );
+  }
+  const arrMins = isoToMins(offer.arrival_time);
+  const tripPurposes = normalizeTripPurposes({
+    tripPurpose: ctx.tripPurpose,
+    tripPurposes: ctx.tripPurposes
+  });
+  const isExploring = tripPurposes.some((purpose) => EARLY_ARRIVAL_PURPOSES.has(purpose));
+  if (bd.arrivalTime >= 0.88) {
+    heroFacts.push(
+      `arrives ${formatMins(arrMins)}${isExploring ? " \u2014 full day to explore" : ""}`
+    );
+  } else if (bd.arrivalTime <= 0.25) {
+    tradeoffs.push(`late arrival (${formatMins(arrMins)})`);
+  }
+  const bagIncluded = offer.ancillaries?.checked_bag?.included === true;
+  const bagFee = offer.ancillaries?.checked_bag?.included === false ? offer.ancillaries.checked_bag.price : null;
+  if (ctx.requireBag && bagIncluded) {
+    heroFacts.push("checked bag already included in the ticket price");
+  } else if (ctx.requireBag && bagFee != null) {
+    tradeoffs.push(
+      `bag costs extra (${Math.round(bagFee)} ${offer.ancillaries?.checked_bag?.currency ?? cur})`
+    );
+  } else if (ctx.requireBag && bagFee === null && !bagIncluded) {
+    tradeoffs.push("bag fee unknown \u2014 check at booking");
+  }
+  const refundability = offer.conditions?.refund_before_departure;
+  if (ctx.requireCancellation && refundability === "allowed") {
+    heroFacts.push("refundable before departure");
+  } else if (ctx.requireCancellation && refundability === "allowed_with_fee") {
+    tradeoffs.push("refunds allowed with a fee");
+  } else if (ctx.requireCancellation && refundability === "not_allowed") {
+    tradeoffs.push("not refundable before departure");
+  } else if (ctx.requireCancellation) {
+    tradeoffs.push("refund policy not shown in the fare data");
+  }
+  const mealSignal = extractOfferDetailSignals(offer).meals;
+  if (ctx.requireMeals && mealSignal === "included") {
+    heroFacts.push("meal included in fare");
+  } else if (ctx.requireMeals && mealSignal === "available") {
+    heroFacts.push("meal option shown in fare data");
+  } else if (ctx.requireMeals) {
+    tradeoffs.push("meal availability not shown in the fare data");
+  }
+  if (ctx.preferredAirline) {
+    const airLower = offer.airline.toLowerCase();
+    const prefLower = ctx.preferredAirline.toLowerCase();
+    if (airLower.includes(prefLower) || prefLower.includes(airLower.split(" ")[0])) {
+      heroFacts.push(`with ${offer.airline} as you mentioned`);
+    } else {
+      tradeoffs.push(`not ${ctx.preferredAirline} (which you mentioned)`);
+    }
+  }
+  return { heroFacts, tradeoffs };
+}
+function premiumPenalty(offerPrice, cheapestPrice) {
+  if (cheapestPrice <= 0) return 1;
+  const ratio = (offerPrice - cheapestPrice) / cheapestPrice;
+  if (ratio <= 0) return 1;
+  if (ratio <= 0.08) return 1;
+  if (ratio <= 0.18) return 0.96;
+  if (ratio <= 0.3) return 0.88;
+  if (ratio <= 0.5) return 0.76;
+  if (ratio <= 0.8) return 0.58;
+  if (ratio <= 1.2) return 0.4;
+  if (ratio <= 2) return 0.26;
+  return 0.14;
+}
+function selectHeroByGates(sorted, ctx) {
+  if (sorted.length === 0) throw new Error("selectHeroByGates: empty input");
+  const gates = [];
+  if (ctx.requireCancellation) {
+    gates.push({
+      name: "refund",
+      pred: (o) => o.conditions?.refund_before_departure === "allowed"
+    });
+  }
+  if (ctx.requireBag) {
+    gates.push({
+      name: "bag",
+      pred: (o) => o.ancillaries?.checked_bag?.included === true
+    });
+  }
+  const timePreds = [];
+  if (ctx.depTimePref) {
+    timePreds.push((o) => scoreDepTime(isoToMins(o.departure_time), ctx.depTimePref) >= 0.55);
+  }
+  if (ctx.retTimePref) {
+    timePreds.push((o) => {
+      const retDep = o.inbound?.departure_time;
+      if (!retDep) return true;
+      return scoreDepTime(isoToMins(retDep), ctx.retTimePref) >= 0.55;
+    });
+  }
+  if (ctx.arrivalTimePref) {
+    const tripPurposes = normalizeTripPurposes({
+      tripPurpose: ctx.tripPurpose,
+      tripPurposes: ctx.tripPurposes
+    });
+    timePreds.push((o) => {
+      const arrMins = isoToMins(o.arrival_time);
+      const dayOffset = daysBetween(o.departure_time, o.arrival_time);
+      return scoreArrivalTime(arrMins, ctx.arrivalTimePref, tripPurposes, dayOffset) >= 0.55;
+    });
+  }
+  if (timePreds.length > 0) {
+    gates.push({ name: "time", pred: (o) => timePreds.every((p) => p(o)) });
+  }
+  if (ctx.maxStops !== void 0 && !ctx.preferDirect) {
+    const cap = ctx.maxStops;
+    gates.push({ name: "max_stops", pred: (o) => combinedStops(o) <= cap });
+  }
+  if (ctx.preferDirect) {
+    gates.push({ name: "direct", pred: (o) => combinedStops(o) === 0 });
+  }
+  gates.push({ name: "not_suspect", pred: (o) => o.quality !== "suspect" });
+  const topByScore = sorted.reduce((best, s) => s.score > best.score ? s : best, sorted[0]);
+  const gateByName = new Map(gates.map((g) => [g.name, g.pred]));
+  const trulyRelaxed = (names, hero) => names.filter((name) => {
+    const pred = gateByName.get(name);
+    return pred ? !pred(hero.offer) : true;
+  });
+  const relaxed = [];
+  for (let dropCount = 0; dropCount <= gates.length; dropCount++) {
+    const active = gates.slice(dropCount);
+    const candidate = sorted.find((s) => active.every((g) => g.pred(s.offer)));
+    if (candidate) {
+      if (!relaxed.includes("bag") && ctx.requireBag) {
+        const otherActive = active.filter((g) => g.name !== "bag");
+        const altCandidate = sorted.find((s) => otherActive.every((g) => g.pred(s.offer)));
+        if (altCandidate && altCandidate !== candidate && altCandidate === topByScore) {
+          const ratio = candidate.score / altCandidate.score;
+          if (ratio < 0.75) {
+            relaxed.push("bag");
+            continue;
+          }
+        }
+      }
+      return { hero: candidate, relaxed: trulyRelaxed(relaxed, candidate) };
+    }
+    if (dropCount < gates.length) relaxed.push(gates[dropCount].name);
+  }
+  return { hero: sorted[0], relaxed: trulyRelaxed(relaxed, sorted[0]) };
+}
+function rankOffers(offers, ctx, options) {
+  if (offers.length === 0) return [];
+  const pool = options?.skipDedup ? offers : deduplicateOffers(offers);
+  const plausible = pool.filter((o) => {
+    const out = o.duration_minutes ?? 0;
+    if (out < 10 || out > 2880) return false;
+    const inb = o.inbound?.duration_minutes;
+    if (typeof inb === "number" && (inb < 10 || inb > 2880)) return false;
+    return totalRoundTripDuration(o) <= 5760;
+  });
+  const weights = resolveWeights(ctx);
+  const effectivePrice = (o) => o.displayPrice ?? o.price;
+  const prices = plausible.map(effectivePrice);
+  const durations = plausible.map(totalRoundTripDuration);
+  const [pLo, pHi] = p5p95(prices);
+  const [dLo, dHi] = p5p95(durations);
+  const cheapestPrice = Math.min(...prices);
+  const cheapestDirectPrice = ctx.preferDirect ? (() => {
+    const dp = plausible.filter((o) => (o.stops ?? 0) === 0).map(effectivePrice).filter((p) => isFinite(p));
+    return dp.length > 0 ? Math.min(...dp) : cheapestPrice;
+  })() : cheapestPrice;
+  const fastestMins = Math.min(...durations);
+  const outboundDurations = plausible.map((o) => o.duration_minutes);
+  const fastestOutboundMins = outboundDurations.length > 0 ? Math.min(...outboundDurations) : 0;
+  const cheapestQuickPrice = ctx.preferQuickFlight ? (() => {
+    const qp = plausible.filter((o) => totalRoundTripDuration(o) <= fastestMins * 2.5).map(effectivePrice).filter((p) => isFinite(p));
+    return qp.length > 0 ? Math.min(...qp) : cheapestPrice;
+  })() : cheapestPrice;
+  const tripPurposes = normalizeTripPurposes({
+    tripPurpose: ctx.tripPurpose,
+    tripPurposes: ctx.tripPurposes
+  });
+  const scored = plausible.map((offer) => {
+    const depMins = isoToMins(offer.departure_time);
+    const arrMins = isoToMins(offer.arrival_time);
+    const dayOffset = daysBetween(offer.departure_time, offer.arrival_time);
+    const ep = effectivePrice(offer);
+    const bd = {
+      price: scorePrice(ep, pLo, pHi),
+      stops: scoreStops(combinedStops(offer)),
+      duration: scoreDuration(totalRoundTripDuration(offer), dLo, dHi),
+      depTime: scoreDepTime(depMins, ctx.depTimePref),
+      arrivalTime: scoreArrivalTime(arrMins, ctx.arrivalTimePref, tripPurposes, dayOffset),
+      baggage: scoreBaggage(offer, ctx.requireBag),
+      savings: scoreSavings(offer, ctx.travelerCount),
+      comfortHours: scoreComfortHours(depMins),
+      layover: scoreLayover(offer, ctx.preferLongLayover)
+    };
+    const rawScore = (bd.price * weights.price + bd.stops * weights.stops + bd.duration * weights.duration + bd.depTime * weights.depTime + bd.arrivalTime * weights.arrivalTime + bd.baggage * weights.baggage + bd.savings * weights.savings + bd.comfortHours * weights.comfortHours + bd.layover * weights.layover) * 100;
+    const penaltyRef = ctx.preferDirect && (offer.stops ?? 0) === 0 ? cheapestDirectPrice : ctx.preferQuickFlight && totalRoundTripDuration(offer) <= fastestMins * 2.5 ? cheapestQuickPrice : cheapestPrice;
+    const score = rawScore * premiumPenalty(ep, penaltyRef) * timeConstraintPenalty(depMins, ctx.departAfterMins, ctx.departBeforeMins) * depTimeMismatchMultiplier(depMins, ctx.depTimePref) * retDepTimeMismatchMultiplier(offer, ctx.retTimePref) * mealPreferenceMultiplier(offer, ctx.requireMeals) * refundabilityMultiplier(offer, ctx.requireCancellation);
+    return { offer, score, rank: 0, breakdown: bd, heroFacts: [], tradeoffs: [] };
+  });
+  scored.sort((a, b) => {
+    if (ctx.preferDirect) {
+      const aDirect = combinedStops(a.offer) === 0 ? 0 : 1;
+      const bDirect = combinedStops(b.offer) === 0 ? 0 : 1;
+      if (aDirect !== bDirect) return aDirect - bDirect;
+    }
+    if (ctx.maxStops !== void 0 && !ctx.preferDirect) {
+      const aIn = combinedStops(a.offer) <= ctx.maxStops ? 0 : 1;
+      const bIn = combinedStops(b.offer) <= ctx.maxStops ? 0 : 1;
+      if (aIn !== bIn) return aIn - bIn;
+    }
+    const scoreDelta = b.score - a.score;
+    if (Math.abs(scoreDelta) > 1e-3) return scoreDelta;
+    const priceDelta = effectivePrice(a.offer) - effectivePrice(b.offer);
+    if (Math.abs(priceDelta) > 1e-3) return priceDelta;
+    const stopsDelta = a.offer.stops - b.offer.stops;
+    if (stopsDelta !== 0) return stopsDelta;
+    const durationDelta = a.offer.duration_minutes - b.offer.duration_minutes;
+    if (durationDelta !== 0) return durationDelta;
+    const depDelta = isoToMins(a.offer.departure_time) - isoToMins(b.offer.departure_time);
+    if (depDelta !== 0) return depDelta;
+    return a.offer.id.localeCompare(b.offer.id);
+  });
+  if (scored.length > 0) {
+    const { hero, relaxed } = selectHeroByGates(scored, ctx);
+    const idx = scored.indexOf(hero);
+    if (idx > 0) {
+      scored.splice(idx, 1);
+      scored.unshift(hero);
+    }
+    if (relaxed.length > 0) scored[0].relaxedGates = relaxed;
+  }
+  const heroPrice = scored[0]?.offer.price ?? cheapestPrice;
+  for (let i = 0; i < scored.length; i++) {
+    scored[i].rank = i + 1;
+    const isHero = i === 0;
+    const refPrice = isHero ? cheapestPrice : heroPrice;
+    const { heroFacts, tradeoffs } = generateFacts(
+      scored[i].offer,
+      scored[i].breakdown,
+      refPrice,
+      fastestOutboundMins,
+      ctx,
+      ctx.travelerCount,
+      isHero
+    );
+    scored[i].heroFacts = heroFacts;
+    scored[i].tradeoffs = tradeoffs;
+  }
+  return scored;
+}
+function selectDiverseTop(ranked, n) {
+  if (ranked.length === 0) return [];
+  const result = [ranked[0]];
+  const depSlot = (iso) => Math.floor(isoToMins(iso) / 180);
+  for (const candidate of ranked.slice(1)) {
+    if (result.length >= n) break;
+    const isDiverse = result.every(
+      (sel) => Math.abs(depSlot(candidate.offer.departure_time) - depSlot(sel.offer.departure_time)) >= 1 || Math.abs(candidate.offer.stops - sel.offer.stops) >= 1
+    );
+    if (isDiverse) result.push(candidate);
+  }
+  for (const candidate of ranked.slice(1)) {
+    if (result.length >= n) break;
+    if (!result.some((r) => getOfferInstanceKey(r.offer) === getOfferInstanceKey(candidate.offer))) {
+      result.push(candidate);
+    }
+  }
+  return result;
+}
+function getProfileLabel(ctx) {
+  const tripPurpose = getPrimaryTripPurpose({
+    tripPurpose: ctx.tripPurpose,
+    tripPurposes: ctx.tripPurposes
+  });
+  if (tripPurpose === "honeymoon") return "Honeymoon";
+  if (tripPurpose === "special_occasion") return "Special occasion";
+  if (tripPurpose === "business") return "Business travel";
+  if (tripPurpose === "ski") return "Ski trip";
+  if (tripPurpose === "beach") return "Beach holiday";
+  if (tripPurpose === "city_break") return "City break";
+  if (tripPurpose === "family_holiday") return "Family holiday";
+  if (tripPurpose === "graduation") return "Graduation trip";
+  if (tripPurpose === "concert_festival") return "Concert / festival";
+  if (tripPurpose === "sports_event") return "Sports event";
+  if (tripPurpose === "spring_break") return "Spring break";
+  if (ctx.tripContext === "family") return "Family trip";
+  if (ctx.tripContext === "couple") return "Couple";
+  if (ctx.tripContext === "business_traveler") return "Business traveler";
+  if (ctx.requireBag) return "Checked bag needed";
+  return null;
+}
+
+// src/index.ts
+var ErrorCode = {
+  // Transient (safe to retry after short delay)
+  SUPPLIER_TIMEOUT: "SUPPLIER_TIMEOUT",
+  RATE_LIMITED: "RATE_LIMITED",
+  SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  // Validation (fix input, then retry)
+  INVALID_IATA: "INVALID_IATA",
+  INVALID_DATE: "INVALID_DATE",
+  INVALID_PASSENGERS: "INVALID_PASSENGERS",
+  UNSUPPORTED_ROUTE: "UNSUPPORTED_ROUTE",
+  MISSING_PARAMETER: "MISSING_PARAMETER",
+  INVALID_PARAMETER: "INVALID_PARAMETER",
+  // Business (requires human decision)
+  AUTH_INVALID: "AUTH_INVALID",
+  PAYMENT_REQUIRED: "PAYMENT_REQUIRED",
+  PAYMENT_DECLINED: "PAYMENT_DECLINED",
+  OFFER_EXPIRED: "OFFER_EXPIRED",
+  OFFER_NOT_UNLOCKED: "OFFER_NOT_UNLOCKED",
+  FARE_CHANGED: "FARE_CHANGED",
+  ALREADY_BOOKED: "ALREADY_BOOKED",
+  BOOKING_FAILED: "BOOKING_FAILED"
+};
+var ErrorCategory = {
+  TRANSIENT: "transient",
+  VALIDATION: "validation",
+  BUSINESS: "business"
+};
+var CODE_TO_CATEGORY = {
+  [ErrorCode.SUPPLIER_TIMEOUT]: ErrorCategory.TRANSIENT,
+  [ErrorCode.RATE_LIMITED]: ErrorCategory.TRANSIENT,
+  [ErrorCode.SERVICE_UNAVAILABLE]: ErrorCategory.TRANSIENT,
+  [ErrorCode.NETWORK_ERROR]: ErrorCategory.TRANSIENT,
+  [ErrorCode.INVALID_IATA]: ErrorCategory.VALIDATION,
+  [ErrorCode.INVALID_DATE]: ErrorCategory.VALIDATION,
+  [ErrorCode.INVALID_PASSENGERS]: ErrorCategory.VALIDATION,
+  [ErrorCode.UNSUPPORTED_ROUTE]: ErrorCategory.VALIDATION,
+  [ErrorCode.MISSING_PARAMETER]: ErrorCategory.VALIDATION,
+  [ErrorCode.INVALID_PARAMETER]: ErrorCategory.VALIDATION,
+  [ErrorCode.AUTH_INVALID]: ErrorCategory.BUSINESS,
+  [ErrorCode.PAYMENT_REQUIRED]: ErrorCategory.BUSINESS,
+  [ErrorCode.PAYMENT_DECLINED]: ErrorCategory.BUSINESS,
+  [ErrorCode.OFFER_EXPIRED]: ErrorCategory.BUSINESS,
+  [ErrorCode.OFFER_NOT_UNLOCKED]: ErrorCategory.BUSINESS,
+  [ErrorCode.FARE_CHANGED]: ErrorCategory.BUSINESS,
+  [ErrorCode.ALREADY_BOOKED]: ErrorCategory.BUSINESS,
+  [ErrorCode.BOOKING_FAILED]: ErrorCategory.BUSINESS
+};
+function inferErrorCode(statusCode, detail) {
+  const d = detail.toLowerCase();
+  if (statusCode === 401) return ErrorCode.AUTH_INVALID;
+  if (statusCode === 402) return d.includes("declined") ? ErrorCode.PAYMENT_DECLINED : ErrorCode.PAYMENT_REQUIRED;
+  if (statusCode === 410) return ErrorCode.OFFER_EXPIRED;
+  if (statusCode === 422) {
+    if (d.includes("iata") || d.includes("airport")) return ErrorCode.INVALID_IATA;
+    if (d.includes("date")) return ErrorCode.INVALID_DATE;
+    if (d.includes("passenger")) return ErrorCode.INVALID_PASSENGERS;
+    if (d.includes("route")) return ErrorCode.UNSUPPORTED_ROUTE;
+    return ErrorCode.INVALID_PARAMETER;
+  }
+  if (statusCode === 429) return ErrorCode.RATE_LIMITED;
+  if (statusCode === 503) return ErrorCode.SERVICE_UNAVAILABLE;
+  if (statusCode === 504) return ErrorCode.SUPPLIER_TIMEOUT;
+  if (statusCode === 409) return ErrorCode.ALREADY_BOOKED;
+  return statusCode >= 500 ? ErrorCode.BOOKING_FAILED : ErrorCode.INVALID_PARAMETER;
+}
+var LetsFGError = class extends Error {
+  statusCode;
+  response;
+  errorCode;
+  errorCategory;
+  isRetryable;
+  constructor(message, statusCode = 0, response = {}, errorCode = "") {
+    super(message);
+    this.name = "LetsFGError";
+    this.statusCode = statusCode;
+    this.response = response;
+    this.errorCode = errorCode || response.error_code || "";
+    this.errorCategory = CODE_TO_CATEGORY[this.errorCode] || ErrorCategory.BUSINESS;
+    this.isRetryable = this.errorCategory === ErrorCategory.TRANSIENT;
+  }
+};
+var AuthenticationError = class extends LetsFGError {
+  constructor(message, response = {}) {
+    super(message, 401, response, ErrorCode.AUTH_INVALID);
+    this.name = "AuthenticationError";
+  }
+};
+var PaymentRequiredError = class extends LetsFGError {
+  constructor(message, response = {}) {
+    const code = message.toLowerCase().includes("declined") ? ErrorCode.PAYMENT_DECLINED : ErrorCode.PAYMENT_REQUIRED;
+    super(message, 402, response, code);
+    this.name = "PaymentRequiredError";
+  }
+};
+var OfferExpiredError = class extends LetsFGError {
+  constructor(message, response = {}) {
+    super(message, 410, response, ErrorCode.OFFER_EXPIRED);
+    this.name = "OfferExpiredError";
+  }
+};
+var ValidationError = class extends LetsFGError {
+  constructor(message, statusCode = 422, response = {}, errorCode = "") {
+    super(message, statusCode, response, errorCode || ErrorCode.INVALID_PARAMETER);
+    this.name = "ValidationError";
+  }
+};
+function routeStr(route) {
+  if (!route.segments.length) return "";
+  const codes = [route.segments[0].origin, ...route.segments.map((s) => s.destination)];
+  return codes.join(" -> ");
+}
+function durationHuman(seconds) {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  return `${h}h${m.toString().padStart(2, "0")}m`;
+}
+function offerSummary(offer) {
+  const route = routeStr(offer.outbound);
+  const dur = durationHuman(offer.outbound.total_duration_seconds);
+  const airline = offer.owner_airline || offer.airlines[0] || "?";
+  return `${offer.currency} ${offer.price.toFixed(2)} | ${airline} | ${route} | ${dur} | ${offer.outbound.stopovers} stop(s)`;
+}
+function cheapestOffer(result) {
+  if (!result.offers.length) return null;
+  return result.offers.reduce((min, o) => o.price < min.price ? o : min, result.offers[0]);
+}
+var DEFAULT_BASE_URL = "https://letsfg.co";
+var PFS_POLL_INTERVAL_MS = 1e4;
+var PFS_POLL_TIMEOUT_MS = 12e4;
+var LetsFG = class {
+  bearerToken;
+  apiKey;
+  baseUrl;
+  timeout;
+  constructor(config = {}) {
+    this.bearerToken = config.bearerToken || process.env.LETSFG_BEARER_TOKEN || "";
+    this.apiKey = config.apiKey || process.env.LETSFG_API_KEY || "";
+    this.baseUrl = (config.baseUrl || process.env.LETSFG_BASE_URL || DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.timeout = config.timeout || 3e4;
+  }
+  requireAuth() {
+    if (!this.bearerToken && !this.apiKey) {
+      throw new AuthenticationError(
+        "Authentication required. Set bearerToken (from `letsfg auth`) or apiKey in config, or set LETSFG_BEARER_TOKEN / LETSFG_API_KEY env vars."
+      );
+    }
+  }
+  requireApiKey() {
+    if (!this.apiKey) {
+      throw new AuthenticationError(
+        "Developer API key required for this operation. Set apiKey in config or LETSFG_API_KEY env var. Register at letsfg.co/developers."
+      );
+    }
+  }
+  /** True when using PFS Bearer token (free search path) */
+  get usingPFS() {
+    return !!this.bearerToken;
+  }
+  // ── Core methods ─────────────────────────────────────────────────────
+  /**
+   * Search for flights — FREE.
+   *
+   * Uses PFS (Bearer token) or Developer API (X-API-Key) depending on config.
+   * PFS: async polling (POST /api/search -> poll /api/results/<id> every 10s).
+   * Developer API: synchronous 60-90s call.
+   *
+   * @param origin - IATA code (e.g., "GDN", "LON")
+   * @param destination - IATA code (e.g., "BER", "BCN")
+   * @param dateFrom - Departure date "YYYY-MM-DD"
+   * @param options - Optional search parameters
+   */
+  async search(origin, destination, dateFrom, options = {}) {
+    this.requireAuth();
+    const body = {
+      origin: origin.toUpperCase(),
+      destination: destination.toUpperCase(),
+      date_from: dateFrom,
+      adults: options.adults ?? 1,
+      children: options.children ?? 0,
+      currency: options.currency ?? "EUR",
+      limit: options.limit ?? 50
+    };
+    if (options.returnDate) body.return_date = options.returnDate;
+    if (options.cabinClass) body.cabin_class = options.cabinClass;
+    if (options.maxStopovers != null) body.max_stopovers = options.maxStopovers;
+    if (options.sort) body.sort = options.sort;
+    if (this.usingPFS) {
+      return this.searchPFS(body);
+    }
+    return this.post("/developers/api/v1/flights/search", body);
+  }
+  /** PFS path: POST /api/search -> poll /api/results/<id> */
+  async searchPFS(body) {
+    const { search_id } = await this.postWithBearer("/api/search", body);
+    const deadline = Date.now() + PFS_POLL_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, PFS_POLL_INTERVAL_MS));
+      const result = await this.getNoAuth(
+        `/api/results/${search_id}`
+      );
+      if (result.status !== "pending") {
+        return result;
+      }
+    }
+    throw new LetsFGError("Search timed out after 120s. Try polling /api/results/<id> directly.", 504);
+  }
+  /**
+   * Resolve a city/airport name to IATA codes.
+   */
+  async resolveLocation(query) {
+    this.requireAuth();
+    const path = this.usingPFS ? `/api/locations?q=${encodeURIComponent(query)}` : `/developers/api/v1/flights/locations/${encodeURIComponent(query)}`;
+    const data = await this.getWithAuth(path);
+    return Array.isArray(data) ? data : data.locations || [];
+  }
+  /**
+   * Unlock a flight offer — confirms live price, reveals direct airline booking URL.
+   * Cost: 1% of ticket price, min $3. Free with Developer API.
+   */
+  async unlock(offerId) {
+    this.requireAuth();
+    const path = this.usingPFS ? "/api/unlock" : "/developers/api/v1/bookings/unlock";
+    return this.postWithAuth(path, { offer_id: offerId });
+  }
+  /**
+   * Book a flight via Developer API — charges ticket price via Stripe, creates real PNR.
+   * Always provide idempotencyKey to prevent double-bookings on retry.
+   */
+  async book(offerId, passengers, contactEmail, contactPhone = "", idempotencyKey = "") {
+    this.requireApiKey();
+    const body = {
+      offer_id: offerId,
+      booking_type: "flight",
+      passengers,
+      contact_email: contactEmail,
+      contact_phone: contactPhone
+    };
+    if (idempotencyKey) body.idempotency_key = idempotencyKey;
+    return this.post("/developers/api/v1/bookings/book", body);
+  }
+  /**
+   * Set up payment method (required before unlock/booking).
+   */
+  async setupPayment(token = "tok_visa") {
+    this.requireApiKey();
+    return this.post("/developers/api/v1/agents/setup-payment", { token });
+  }
+  /**
+   * Get current agent profile and usage stats.
+   */
+  async me() {
+    this.requireApiKey();
+    return this.get("/developers/api/v1/agents/me");
+  }
+  // ── Static methods ───────────────────────────────────────────────────
+  /**
+   * Register a new Developer API agent — no auth needed.
+   */
+  static async register(agentName, email, baseUrl, ownerName = "", description = "") {
+    const url = (baseUrl || DEFAULT_BASE_URL).replace(/\/$/, "");
+    const resp = await fetch(`${url}/developers/api/v1/agents/register`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ agent_name: agentName, email, owner_name: ownerName, description })
+    });
+    const data = await resp.json();
+    if (!resp.ok) {
+      throw new LetsFGError(
+        data.detail || `Registration failed (${resp.status})`,
+        resp.status,
+        data
+      );
+    }
+    return data;
+  }
+  // ── Internal ────────────────────────────────────────────────────────
+  async postWithBearer(path, body) {
+    return this.requestWithHeaders(path, "POST", { "Authorization": `Bearer ${this.bearerToken}` }, body);
+  }
+  async getNoAuth(path) {
+    return this.requestWithHeaders(path, "GET", {});
+  }
+  async getWithAuth(path) {
+    const headers = this.usingPFS ? { "Authorization": `Bearer ${this.bearerToken}` } : { "X-API-Key": this.apiKey };
+    return this.requestWithHeaders(path, "GET", headers);
+  }
+  async postWithAuth(path, body) {
+    const headers = this.usingPFS ? { "Authorization": `Bearer ${this.bearerToken}` } : { "X-API-Key": this.apiKey };
+    return this.requestWithHeaders(path, "POST", headers, body);
+  }
+  async post(path, body) {
+    return this.requestWithHeaders(path, "POST", { "X-API-Key": this.apiKey }, body);
+  }
+  async get(path) {
+    return this.requestWithHeaders(path, "GET", { "X-API-Key": this.apiKey });
+  }
+  async requestWithHeaders(path, method, extraHeaders, body) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const resp = await fetch(`${this.baseUrl}${path}`, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          "User-Agent": "LetsFG-js/0.1.0",
+          "X-Client-Type": "js-sdk",
+          ...extraHeaders
+        },
+        ...body != null ? { body: JSON.stringify(body) } : {},
+        signal: controller.signal
+      });
+      const data = await resp.json();
+      if (!resp.ok) {
+        const detail = data.detail || `API error (${resp.status})`;
+        const code = data.error_code || inferErrorCode(resp.status, detail);
+        if (resp.status === 401) throw new AuthenticationError(detail, data);
+        if (resp.status === 402) throw new PaymentRequiredError(detail, data);
+        if (resp.status === 410) throw new OfferExpiredError(detail, data);
+        if (resp.status === 422) throw new ValidationError(detail, resp.status, data, code);
+        throw new LetsFGError(detail, resp.status, data, code);
+      }
+      return data;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+var index_default = LetsFG;
+var BoostedTravel = LetsFG;
+var BoostedTravelError = LetsFGError;
+
+export {
+  extractOfferDetailSignals,
+  getOfferDetailBadges,
+  getOfferDetailPromptNotes,
+  TRIP_PURPOSES,
+  normalizeTripPurposes,
+  getPrimaryTripPurpose,
+  deduplicateOffers,
+  rankOffers,
+  selectDiverseTop,
+  getProfileLabel,
+  ErrorCode,
+  ErrorCategory,
+  LetsFGError,
+  AuthenticationError,
+  PaymentRequiredError,
+  OfferExpiredError,
+  ValidationError,
+  offerSummary,
+  cheapestOffer,
+  LetsFG,
+  index_default,
+  BoostedTravel,
+  BoostedTravelError
+};