@bash-app/bash-common 30.386.0 → 30.393.0

package/src/userTaste.ts

@@ -0,0 +1,152 @@
+import { BashEventType } from "@prisma/client";
+
+import { isCauseTagId } from "./causeTags.js";
+import {
+  DiscoveryScope,
+  DISCOVERY_SCOPE_VALUES,
+  isDiscoveryScope,
+} from "./discoveryScope.js";
+
+export const UserTasteKind = {
+  EventType: "EventType",
+  CauseTag: "CauseTag",
+  MusicGenre: "MusicGenre",
+  DiscoveryScope: "DiscoveryScope",
+} as const;
+
+export type UserTasteKind =
+  (typeof UserTasteKind)[keyof typeof UserTasteKind];
+
+export const UserTasteSource = {
+  Explicit: "Explicit",
+  Inferred: "Inferred",
+} as const;
+
+export type UserTasteSource =
+  (typeof UserTasteSource)[keyof typeof UserTasteSource];
+
+const BASH_EVENT_TYPE_VALUES = new Set(
+  Object.values(BashEventType) as string[]
+);
+
+/** Mirrors Prisma MusicGenreType — kept local so validation works without extra imports. */
+export const MUSIC_GENRE_TASTE_VALUES = [
+  "EDM",
+  "Electronic",
+  "House",
+  "Techno",
+  "Dubstep",
+  "Trance",
+  "Pop",
+  "Rock",
+  "HipHop",
+  "Country",
+  "RnB",
+  "Jazz",
+  "Blues",
+  "Indie",
+  "Alternative",
+  "Folk",
+  "Acoustic",
+  "Classical",
+  "Opera",
+  "World",
+  "Latin",
+  "Experimental",
+  "Fusion",
+  "Other",
+] as const;
+
+export type MusicGenreTasteValue = (typeof MUSIC_GENRE_TASTE_VALUES)[number];
+
+const MUSIC_GENRE_SET = new Set<string>(MUSIC_GENRE_TASTE_VALUES);
+
+const CIVIC_EVENT_TYPES = new Set(["ChurchEvent", "SchoolEvent"]);
+
+export function isUserTasteKind(value: unknown): value is UserTasteKind {
+  return (
+    value === UserTasteKind.EventType ||
+    value === UserTasteKind.CauseTag ||
+    value === UserTasteKind.MusicGenre ||
+    value === UserTasteKind.DiscoveryScope
+  );
+}
+
+export function isValidTasteValue(kind: UserTasteKind, value: string): boolean {
+  if (!value.trim()) return false;
+  switch (kind) {
+    case UserTasteKind.EventType:
+      return BASH_EVENT_TYPE_VALUES.has(value);
+    case UserTasteKind.CauseTag:
+      return isCauseTagId(value);
+    case UserTasteKind.MusicGenre:
+      return MUSIC_GENRE_SET.has(value);
+    case UserTasteKind.DiscoveryScope:
+      return (
+        isDiscoveryScope(value) &&
+        value !== DiscoveryScope.Unspecified &&
+        (DISCOVERY_SCOPE_VALUES as readonly string[]).includes(value)
+      );
+    default:
+      return false;
+  }
+}
+
+export function isCivicEventType(eventType: string): boolean {
+  return CIVIC_EVENT_TYPES.has(eventType);
+}
+
+export type SceneTasteChip = {
+  id: string;
+  label: string;
+  kind: UserTasteKind;
+  value: string;
+};
+
+/** First-screen chips — no Networking. */
+export const SCENE_TASTE_CHIPS: readonly SceneTasteChip[] = [
+  { id: "festival", label: "Festivals", kind: UserTasteKind.EventType, value: "Festival" },
+  { id: "concert", label: "Concerts", kind: UserTasteKind.EventType, value: "Concert" },
+  { id: "comedy", label: "Comedy", kind: UserTasteKind.EventType, value: "ComedyShow" },
+  { id: "rave", label: "Raves / nightlife", kind: UserTasteKind.EventType, value: "Rave" },
+  { id: "fair", label: "Fairs", kind: UserTasteKind.EventType, value: "Fair" },
+  { id: "sports", label: "Sports", kind: UserTasteKind.EventType, value: "SportsWatchParty" },
+  { id: "pride", label: "Drag / Pride", kind: UserTasteKind.CauseTag, value: "lgbtq" },
+  { id: "arts", label: "Arts & culture", kind: UserTasteKind.CauseTag, value: "arts_culture" },
+  { id: "food", label: "Food", kind: UserTasteKind.EventType, value: "FestivalFood" },
+  { id: "outdoor", label: "Outdoor", kind: UserTasteKind.EventType, value: "OutdoorActivity" },
+];
+
+export const TRAVEL_TASTE_CHIP: SceneTasteChip = {
+  id: "travel",
+  label: "I'll travel for the right night",
+  kind: UserTasteKind.DiscoveryScope,
+  value: DiscoveryScope.National,
+};
+
+export const TRAVEL_TASTE_VALUES: readonly string[] = [
+  DiscoveryScope.National,
+  DiscoveryScope.International,
+];
+
+export type TastePreferenceInput = {
+  kind: UserTasteKind;
+  value: string;
+  weight?: number;
+  source?: UserTasteSource;
+};
+
+export function normalizeTasteWeight(weight: number | undefined): number {
+  if (weight === 2 || weight === -1 || weight === 1) return weight;
+  return 1;
+}
+
+export function userHasTravelTaste(
+  rows: ReadonlyArray<{ kind: string; value: string }>
+): boolean {
+  return rows.some(
+    (r) =>
+      r.kind === UserTasteKind.DiscoveryScope &&
+      TRAVEL_TASTE_VALUES.includes(r.value)
+  );
+}

package/src/utils/__tests__/featuredDiscoveryGeo.test.ts

@@ -1,4 +1,7 @@
+import { SUGGESTION_WEIGHTS } from "../../suggestionScore.js";
 import {
+  applyFeaturedTasteMultiplier,
+  FEATURED_TASTE_MATCH_SCORE,
   haversineMiles,
   effectiveFeaturedForGeoScope,
   sortPublicEventsForFeaturedDiscovery,
@@ -118,3 +121,13 @@ describe("sortPublicEventsForFeaturedDiscovery", () => {
     ]);
   });
 });
+
+describe("applyFeaturedTasteMultiplier", () => {
+  it("stays smaller than crew-going weights", () => {
+    expect(applyFeaturedTasteMultiplier(10, false)).toBe(10);
+    expect(applyFeaturedTasteMultiplier(10, true)).toBe(10.5);
+    expect(FEATURED_TASTE_MATCH_SCORE).toBeLessThan(
+      SUGGESTION_WEIGHTS.connectionsGoing
+    );
+  });
+});

package/src/utils/featuredDiscoveryGeo.ts

@@ -73,3 +73,18 @@ export function sortPublicEventsForFeaturedDiscovery<
   });
   return withKeys.map((x) => x.e);
 }
+
+/**
+ * Paid featuring × taste overlap. Must stay smaller than any crew-going
+ * boost (`SUGGESTION_WEIGHTS.connectionsGoing` / followed / attended host).
+ */
+export const FEATURED_TASTE_MATCH_MULTIPLIER = 1.05;
+export const FEATURED_TASTE_MATCH_SCORE = 1;
+
+export function applyFeaturedTasteMultiplier(
+  featuredScore: number,
+  tasteOverlaps: boolean
+): number {
+  if (!tasteOverlaps) return featuredScore;
+  return featuredScore * FEATURED_TASTE_MATCH_MULTIPLIER;
+}

package/src/utils/service/__tests__/foodAndBeverageQuote.test.ts

@@ -0,0 +1,502 @@
+import {
+  CELEBRATION_CAKE_FLAVORS,
+  EVENT_SERVICE_FULFILLMENT_MODES,
+  celebrationCakeStartingPriceLabel,
+  encodeCakeOption,
+  filterCelebrationCakeFulfillmentModes,
+  filterFulfillmentModes,
+  foodAndBeverageLeadTimeLabel,
+  foodAndBeverageQuoteCents,
+  foodAndBeverageRateSummary,
+  getFoodAndBeverageMenuCategories,
+  isBelowGuestMinimum,
+  GRAZING_TABLE_STYLES,
+  encodeGrazingOption,
+  grazingTableStartingPriceLabel,
+  isCelebrationCakeEventService,
+  isCelebrationCakeFulfillmentMode,
+  isFoodAndBeverageEventService,
+  isFulfillmentMode,
+  isGrazingTableEventService,
+  isOfficiantEventService,
+  isPackagePricedFoodEventService,
+  isPerGuestFoodAndBeverageEventService,
+  packagePricedFoodStartingPriceLabel,
+  parseCakeOptions,
+  parseGrazingOptions,
+  quotedGuestCount,
+  serializeCakeOptions,
+  serializeGrazingOptions,
+} from "../foodAndBeverageQuote.js";
+
+describe("isFoodAndBeverageEventService", () => {
+  it("returns true for FoodAndBeverage eventServiceType", () => {
+    expect(
+      isFoodAndBeverageEventService({ eventServiceType: "FoodAndBeverage" })
+    ).toBe(true);
+  });
+
+  it("returns true for canonical subtype even without eventServiceType", () => {
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "Caterer" })
+    ).toBe(true);
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "DessertBar" })
+    ).toBe(true);
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "CelebrationCake" })
+    ).toBe(true);
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "GrazingTable" })
+    ).toBe(true);
+  });
+
+  it("returns true for legacy/alias subtypes", () => {
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "PrivateChef" })
+    ).toBe(true);
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "Bartender" })
+    ).toBe(true);
+  });
+
+  it("returns false for unrelated types", () => {
+    expect(
+      isFoodAndBeverageEventService({ eventServiceType: "EventPlanningAndManagement" })
+    ).toBe(false);
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "EventPlanner" })
+    ).toBe(false);
+  });
+
+  it("returns false when both are null/undefined", () => {
+    expect(isFoodAndBeverageEventService({})).toBe(false);
+    expect(isFoodAndBeverageEventService({ eventServiceType: null, eventServiceSubType: null })).toBe(false);
+  });
+});
+
+describe("EVENT_SERVICE_FULFILLMENT_MODES", () => {
+  it("contains Pickup, Delivery, and FullService", () => {
+    expect(EVENT_SERVICE_FULFILLMENT_MODES).toContain("Pickup");
+    expect(EVENT_SERVICE_FULFILLMENT_MODES).toContain("Delivery");
+    expect(EVENT_SERVICE_FULFILLMENT_MODES).toContain("FullService");
+    expect(EVENT_SERVICE_FULFILLMENT_MODES).toHaveLength(3);
+  });
+});
+
+describe("getFoodAndBeverageMenuCategories", () => {
+  it("returns Caterer chips for Caterer subtype", () => {
+    const chips = getFoodAndBeverageMenuCategories("Caterer");
+    expect(chips).toContain("Salads");
+    expect(chips).toContain("Mains");
+    expect(chips).toContain("Sides");
+  });
+
+  it("returns DessertBar chips for DessertBar subtype", () => {
+    const chips = getFoodAndBeverageMenuCategories("DessertBar");
+    expect(chips).toContain("Cakes");
+    expect(chips).toContain("Cupcakes");
+  });
+
+  it("falls back to generic chips for unknown subtypes", () => {
+    const chips = getFoodAndBeverageMenuCategories("SomeUnknownType");
+    expect(chips.length).toBeGreaterThan(0);
+    expect(chips).toContain("Mains");
+  });
+
+  it("returns generic chips for null subtype", () => {
+    const chips = getFoodAndBeverageMenuCategories(null);
+    expect(chips.length).toBeGreaterThan(0);
+  });
+});
+
+describe("quotedGuestCount", () => {
+  it("returns headcount when no minimum is set", () => {
+    expect(quotedGuestCount(80)).toBe(80);
+    expect(quotedGuestCount(80, null)).toBe(80);
+    expect(quotedGuestCount(80, 0)).toBe(80);
+  });
+
+  it("returns headcount when above minimum", () => {
+    expect(quotedGuestCount(80, 25)).toBe(80);
+  });
+
+  it("floors to minimum when headcount is below", () => {
+    expect(quotedGuestCount(10, 25)).toBe(25);
+    expect(quotedGuestCount(0, 25)).toBe(25);
+  });
+
+  it("returns minimum exactly when headcount equals minimum", () => {
+    expect(quotedGuestCount(25, 25)).toBe(25);
+  });
+
+  it("never returns a negative count", () => {
+    expect(quotedGuestCount(-5)).toBe(0);
+  });
+});
+
+describe("foodAndBeverageQuoteCents", () => {
+  it("calculates basic per-guest price", () => {
+    // $18/guest × 100 guests = $1,800
+    expect(
+      foodAndBeverageQuoteCents({ baseRateCents: 1800, headcount: 100 })
+    ).toBe(180000);
+  });
+
+  it("floors headcount at minimumQuantity", () => {
+    // $18/guest × min 25 guests; host enters 10 → billed for 25
+    expect(
+      foodAndBeverageQuoteCents({
+        baseRateCents: 1800,
+        headcount: 10,
+        minimumQuantity: 25,
+      })
+    ).toBe(1800 * 25);
+  });
+
+  it("does not floor when headcount is above minimum", () => {
+    expect(
+      foodAndBeverageQuoteCents({
+        baseRateCents: 1800,
+        headcount: 80,
+        minimumQuantity: 25,
+      })
+    ).toBe(1800 * 80);
+  });
+
+  it("applies minimumChargeCents dollar floor after guest floor", () => {
+    // $8/guest × 25 guests (floored from 5) = $200. Min charge $500 → $500.
+    expect(
+      foodAndBeverageQuoteCents({
+        baseRateCents: 800,
+        headcount: 5,
+        minimumQuantity: 25,
+        minimumChargeCents: 50000,
+      })
+    ).toBe(50000);
+  });
+
+  it("dollar floor does not fire when rate total already exceeds it", () => {
+    // $18/guest × 50 guests = $900 > $500 min charge
+    expect(
+      foodAndBeverageQuoteCents({
+        baseRateCents: 1800,
+        headcount: 50,
+        minimumQuantity: 25,
+        minimumChargeCents: 50000,
+      })
+    ).toBe(1800 * 50);
+  });
+
+  it("returns 0 for zero baseRate", () => {
+    expect(
+      foodAndBeverageQuoteCents({ baseRateCents: 0, headcount: 100 })
+    ).toBe(0);
+  });
+
+  it("returns 0 for negative headcount", () => {
+    expect(
+      foodAndBeverageQuoteCents({ baseRateCents: 1800, headcount: -1 })
+    ).toBe(0);
+  });
+});
+
+describe("foodAndBeverageRateSummary", () => {
+  it("formats without a minimum", () => {
+    const result = foodAndBeverageRateSummary(1800);
+    expect(result).toBe("$18 / guest");
+  });
+
+  it("formats with a minimum", () => {
+    const result = foodAndBeverageRateSummary(1800, 25);
+    expect(result).toBe("$18 / guest · min 25 guests");
+  });
+
+  it("formats cents correctly", () => {
+    const result = foodAndBeverageRateSummary(1850);
+    expect(result).toBe("$18.50 / guest");
+  });
+});
+
+describe("foodAndBeverageLeadTimeLabel", () => {
+  it("returns null for falsy inputs", () => {
+    expect(foodAndBeverageLeadTimeLabel(null)).toBeNull();
+    expect(foodAndBeverageLeadTimeLabel(0)).toBeNull();
+    expect(foodAndBeverageLeadTimeLabel(undefined)).toBeNull();
+  });
+
+  it("formats days when not divisible by 7", () => {
+    expect(foodAndBeverageLeadTimeLabel(1)).toBe("Needs 1 day notice");
+    expect(foodAndBeverageLeadTimeLabel(5)).toBe("Needs 5 days notice");
+    expect(foodAndBeverageLeadTimeLabel(10)).toBe("Needs 10 days notice");
+  });
+
+  it("formats weeks when divisible by 7", () => {
+    expect(foodAndBeverageLeadTimeLabel(7)).toBe("Needs 1 week notice");
+    expect(foodAndBeverageLeadTimeLabel(14)).toBe("Needs 2 weeks notice");
+  });
+});
+
+describe("package-priced food detection", () => {
+  it("treats cake and grazing as package-priced, not per-guest", () => {
+    expect(
+      isPackagePricedFoodEventService({ eventServiceSubType: "CelebrationCake" })
+    ).toBe(true);
+    expect(
+      isPackagePricedFoodEventService({ eventServiceSubType: "GrazingTable" })
+    ).toBe(true);
+    expect(
+      isPackagePricedFoodEventService({ eventServiceSubType: "Caterer" })
+    ).toBe(false);
+    expect(isPackagePricedFoodEventService({})).toBe(false);
+  });
+
+  it("isPerGuestFoodAndBeverage is false for cake and grazing", () => {
+    expect(
+      isPerGuestFoodAndBeverageEventService({
+        eventServiceType: "FoodAndBeverage",
+        eventServiceSubType: "CelebrationCake",
+      })
+    ).toBe(false);
+    expect(
+      isPerGuestFoodAndBeverageEventService({
+        eventServiceType: "FoodAndBeverage",
+        eventServiceSubType: "GrazingTable",
+      })
+    ).toBe(false);
+    expect(
+      isPerGuestFoodAndBeverageEventService({
+        eventServiceType: "FoodAndBeverage",
+        eventServiceSubType: "Caterer",
+      })
+    ).toBe(true);
+  });
+
+  it("isGrazingTableEventService is true only for GrazingTable", () => {
+    expect(
+      isGrazingTableEventService({ eventServiceSubType: "GrazingTable" })
+    ).toBe(true);
+    expect(
+      isGrazingTableEventService({ eventServiceSubType: "CelebrationCake" })
+    ).toBe(false);
+    expect(isGrazingTableEventService({})).toBe(false);
+  });
+
+  it("isOfficiantEventService is true only for Officiant", () => {
+    expect(isOfficiantEventService({ eventServiceSubType: "Officiant" })).toBe(
+      true
+    );
+    expect(
+      isOfficiantEventService({ eventServiceSubType: "HostingSupportOther" })
+    ).toBe(false);
+    expect(isFoodAndBeverageEventService({ eventServiceSubType: "Officiant" })).toBe(
+      false
+    );
+  });
+});
+
+describe("isCelebrationCakeEventService", () => {
+  it("returns true only for CelebrationCake", () => {
+    expect(
+      isCelebrationCakeEventService({ eventServiceSubType: "CelebrationCake" })
+    ).toBe(true);
+    expect(
+      isCelebrationCakeEventService({ eventServiceSubType: "Caterer" })
+    ).toBe(false);
+    expect(
+      isCelebrationCakeEventService({ eventServiceSubType: "DessertBar" })
+    ).toBe(false);
+    expect(isCelebrationCakeEventService({})).toBe(false);
+    expect(isCelebrationCakeEventService({ eventServiceSubType: null })).toBe(
+      false
+    );
+  });
+});
+
+describe("parseCakeOptions", () => {
+  it("returns empty groups for null or empty input", () => {
+    expect(parseCakeOptions(null)).toEqual({
+      flavors: [],
+      frostings: [],
+      fillings: [],
+      dietary: [],
+      other: [],
+    });
+    expect(parseCakeOptions([])).toEqual({
+      flavors: [],
+      frostings: [],
+      fillings: [],
+      dietary: [],
+      other: [],
+    });
+  });
+
+  it("splits prefixed chips and keeps unprefixed leftovers", () => {
+    const parsed = parseCakeOptions([
+      "flavor:Red Velvet",
+      "frosting:Chocolate Buttercream",
+      "filling:Lemon Custard",
+      "dietary:Gluten-Free",
+      "Desserts",
+    ]);
+    expect(parsed.flavors).toEqual(["Red Velvet"]);
+    expect(parsed.frostings).toEqual(["Chocolate Buttercream"]);
+    expect(parsed.fillings).toEqual(["Lemon Custard"]);
+    expect(parsed.dietary).toEqual(["Gluten-Free"]);
+    expect(parsed.other).toEqual(["Desserts"]);
+  });
+
+  it("round-trips through serializeCakeOptions", () => {
+    const serialized = serializeCakeOptions({
+      flavors: ["Vanilla", "Chocolate"],
+      frostings: ["Fondant"],
+      fillings: [],
+      dietary: ["Vegan"],
+    });
+    expect(serialized).toEqual([
+      "flavor:Vanilla",
+      "flavor:Chocolate",
+      "frosting:Fondant",
+      "dietary:Vegan",
+    ]);
+    expect(parseCakeOptions(serialized)).toEqual({
+      flavors: ["Vanilla", "Chocolate"],
+      frostings: ["Fondant"],
+      fillings: [],
+      dietary: ["Vegan"],
+      other: [],
+    });
+  });
+
+  it("encodeCakeOption uses lowercase prefixes", () => {
+    expect(encodeCakeOption("flavor", "Red Velvet")).toBe("flavor:Red Velvet");
+    expect(CELEBRATION_CAKE_FLAVORS).toContain("Red Velvet");
+  });
+});
+
+describe("celebrationCakeStartingPriceLabel", () => {
+  it("returns null when there is no starting price", () => {
+    expect(celebrationCakeStartingPriceLabel(null)).toBeNull();
+    expect(celebrationCakeStartingPriceLabel(0)).toBeNull();
+  });
+
+  it("formats whole-dollar starting prices", () => {
+    expect(celebrationCakeStartingPriceLabel(35000)).toBe("Cakes start at $350");
+  });
+});
+
+describe("grazing options", () => {
+  it("returns empty groups for null or empty input", () => {
+    expect(parseGrazingOptions(null)).toEqual({
+      styles: [],
+      proteins: [],
+      dietary: [],
+      other: [],
+    });
+    expect(parseGrazingOptions([])).toEqual({
+      styles: [],
+      proteins: [],
+      dietary: [],
+      other: [],
+    });
+  });
+
+  it("splits prefixed chips and keeps unprefixed leftovers", () => {
+    const parsed = parseGrazingOptions([
+      "style:Classic Charcuterie",
+      "protein:Cured Meats",
+      "dietary:Gluten-Free",
+      "Mains",
+    ]);
+    expect(parsed.styles).toEqual(["Classic Charcuterie"]);
+    expect(parsed.proteins).toEqual(["Cured Meats"]);
+    expect(parsed.dietary).toEqual(["Gluten-Free"]);
+    expect(parsed.other).toEqual(["Mains"]);
+  });
+
+  it("round-trips through serializeGrazingOptions", () => {
+    const serialized = serializeGrazingOptions({
+      styles: ["Modern Grazing"],
+      proteins: ["Artisan Cheeses"],
+      dietary: ["Vegan"],
+    });
+    expect(serialized).toEqual([
+      "style:Modern Grazing",
+      "protein:Artisan Cheeses",
+      "dietary:Vegan",
+    ]);
+    expect(parseGrazingOptions(serialized)).toEqual({
+      styles: ["Modern Grazing"],
+      proteins: ["Artisan Cheeses"],
+      dietary: ["Vegan"],
+      other: [],
+    });
+  });
+
+  it("encodeGrazingOption uses lowercase prefixes", () => {
+    expect(encodeGrazingOption("style", "Seasonal")).toBe("style:Seasonal");
+    expect(GRAZING_TABLE_STYLES).toContain("Classic Charcuterie");
+  });
+});
+
+describe("grazing and package starting-price labels", () => {
+  it("formats grazing starting prices", () => {
+    expect(grazingTableStartingPriceLabel(null)).toBeNull();
+    expect(grazingTableStartingPriceLabel(17500)).toBe("Boards start at $175");
+  });
+
+  it("delegates packagePricedFoodStartingPriceLabel by subtype", () => {
+    expect(packagePricedFoodStartingPriceLabel("GrazingTable", 17500)).toBe(
+      "Boards start at $175"
+    );
+    expect(packagePricedFoodStartingPriceLabel("CelebrationCake", 35000)).toBe(
+      "Cakes start at $350"
+    );
+    expect(packagePricedFoodStartingPriceLabel("Caterer", 35000)).toBeNull();
+  });
+});
+
+describe("isBelowGuestMinimum", () => {
+  it("returns false when no minimum is set", () => {
+    expect(isBelowGuestMinimum(5)).toBe(false);
+    expect(isBelowGuestMinimum(5, null)).toBe(false);
+    expect(isBelowGuestMinimum(5, 0)).toBe(false);
+  });
+
+  it("returns true when below minimum", () => {
+    expect(isBelowGuestMinimum(10, 25)).toBe(true);
+  });
+
+  it("returns false when exactly at minimum", () => {
+    expect(isBelowGuestMinimum(25, 25)).toBe(false);
+  });
+
+  it("returns false when above minimum", () => {
+    expect(isBelowGuestMinimum(100, 25)).toBe(false);
+  });
+});
+
+describe("fulfillment mode filters", () => {
+  it("keeps known F&B modes and drops unknowns", () => {
+    expect(isFulfillmentMode("Pickup")).toBe(true);
+    expect(isFulfillmentMode("FullService")).toBe(true);
+    expect(isFulfillmentMode("Curbside")).toBe(false);
+    expect(
+      filterFulfillmentModes(["Pickup", "Curbside", "Delivery", "FullService"])
+    ).toEqual(["Pickup", "Delivery", "FullService"]);
+    expect(filterFulfillmentModes(null)).toEqual([]);
+  });
+
+  it("keeps cake pickup/delivery only", () => {
+    expect(isCelebrationCakeFulfillmentMode("Pickup")).toBe(true);
+    expect(isCelebrationCakeFulfillmentMode("FullService")).toBe(false);
+    expect(
+      filterCelebrationCakeFulfillmentModes([
+        "Pickup",
+        "FullService",
+        "Delivery",
+      ])
+    ).toEqual(["Pickup", "Delivery"]);
+    expect(filterCelebrationCakeFulfillmentModes(undefined)).toEqual([]);
+  });
+});