@bash-app/bash-common 30.235.0 → 30.237.0

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

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "@jest/globals";
+import {
+  DEFAULT_PRICING_MODEL_ALLOW_LIST_BY_SERVICE_TYPE,
+  validateOfferAgainstAllowList,
+} from "../offerAllowListUtils.js";
+
+describe("validateOfferAgainstAllowList", () => {
+  it("passes when allow-list is empty (no host restriction)", () => {
+    expect(
+      validateOfferAgainstAllowList({
+        offered: "PER_ATTENDEE",
+        allowList: [],
+      }).ok
+    ).toBe(true);
+    expect(
+      validateOfferAgainstAllowList({
+        offered: "FLAT_FEE",
+        allowList: null,
+      }).ok
+    ).toBe(true);
+  });
+
+  it("passes when offered model is on the allow-list", () => {
+    expect(
+      validateOfferAgainstAllowList({
+        offered: "PER_PAID_ATTENDEE",
+        allowList: ["FLAT_FEE", "PER_PAID_ATTENDEE"],
+      }).ok
+    ).toBe(true);
+  });
+
+  it("rejects when offered model is NOT on the allow-list", () => {
+    const r = validateOfferAgainstAllowList({
+      offered: "PER_BASHPOINTS_ATTENDEE",
+      allowList: ["FLAT_FEE", "PER_PAID_ATTENDEE"],
+    });
+    expect(r.ok).toBe(false);
+    if (!r.ok) {
+      expect(r.reason).toContain("FLAT_FEE");
+      expect(r.reason).toContain("PER_BASHPOINTS_ATTENDEE");
+    }
+  });
+
+  it("rejects when offered is missing", () => {
+    const r = validateOfferAgainstAllowList({
+      offered: null,
+      allowList: ["FLAT_FEE"],
+    });
+    expect(r.ok).toBe(false);
+    if (!r.ok) expect(r.reason).toMatch(/missing/);
+  });
+});
+
+describe("DEFAULT_PRICING_MODEL_ALLOW_LIST_BY_SERVICE_TYPE", () => {
+  it("has a default for every service vertical the wizard ships", () => {
+    expect(
+      DEFAULT_PRICING_MODEL_ALLOW_LIST_BY_SERVICE_TYPE.Vendors.length
+    ).toBeGreaterThan(0);
+    expect(
+      DEFAULT_PRICING_MODEL_ALLOW_LIST_BY_SERVICE_TYPE.Exhibitors.length
+    ).toBeGreaterThan(0);
+    expect(
+      DEFAULT_PRICING_MODEL_ALLOW_LIST_BY_SERVICE_TYPE.Sponsors.length
+    ).toBeGreaterThan(0);
+    expect(
+      DEFAULT_PRICING_MODEL_ALLOW_LIST_BY_SERVICE_TYPE.Venues.length
+    ).toBeGreaterThan(0);
+    expect(
+      DEFAULT_PRICING_MODEL_ALLOW_LIST_BY_SERVICE_TYPE.EntertainmentServices
+        .length
+    ).toBeGreaterThan(0);
+    expect(
+      DEFAULT_PRICING_MODEL_ALLOW_LIST_BY_SERVICE_TYPE.EventServices.length
+    ).toBeGreaterThan(0);
+  });
+});

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

@@ -0,0 +1,124 @@
+import { describe, expect, it } from "@jest/globals";
+import { computeOfferComparisonBands } from "../offerComparisonUtils.js";
+
+describe("computeOfferComparisonBands FLAT family", () => {
+  it("returns identical bands for FLAT_FEE", () => {
+    const r = computeOfferComparisonBands({
+      pricingModel: "FLAT_FEE",
+      flatRateCents: 50_000,
+    });
+    expect(r.expectedTotalCents).toBe(50_000);
+    expect(r.worstCaseCents).toBe(50_000);
+    expect(r.bestCaseCents).toBe(50_000);
+    expect(r.reasoning).toContain("Fixed price");
+  });
+
+  it("HOURLY and PER_DAY treated as flat", () => {
+    expect(
+      computeOfferComparisonBands({
+        pricingModel: "HOURLY",
+        baseRateCents: 15_000,
+      }).expectedTotalCents
+    ).toBe(15_000);
+    expect(
+      computeOfferComparisonBands({
+        pricingModel: "PER_DAY",
+        baseRateCents: 40_000,
+      }).expectedTotalCents
+    ).toBe(40_000);
+  });
+});
+
+describe("computeOfferComparisonBands PER_ATTENDEE family", () => {
+  it("expects rate * expected, applies minimum floor", () => {
+    const r = computeOfferComparisonBands({
+      pricingModel: "PER_ATTENDEE",
+      baseRateCents: 500,
+      expectedAttendees: 200,
+      minimumQuantity: 100,
+      minimumChargeCents: 70_000,
+    });
+    expect(r.expectedTotalCents).toBe(100_000);
+    expect(r.bestCaseCents).toBeGreaterThanOrEqual(70_000);
+  });
+
+  it("worst case respects maxBillableCents when present", () => {
+    const r = computeOfferComparisonBands({
+      pricingModel: "PER_PAID_ATTENDEE",
+      baseRateCents: 500,
+      expectedAttendees: 200,
+      maxBillableCents: 200_000,
+    });
+    expect(r.worstCaseCents).toBe(200_000);
+  });
+
+  it("worst case defaults to 1.5x when no cap", () => {
+    const r = computeOfferComparisonBands({
+      pricingModel: "PER_ATTENDEE",
+      baseRateCents: 500,
+      expectedAttendees: 200,
+    });
+    expect(r.worstCaseCents).toBe(Math.round(200 * 500 * 1.5));
+  });
+});
+
+describe("computeOfferComparisonBands PER_BASHPOINTS_ATTENDEE", () => {
+  it("returns BP bands only, USD bands null", () => {
+    const r = computeOfferComparisonBands({
+      pricingModel: "PER_BASHPOINTS_ATTENDEE",
+      baseRateBashPoints: 10,
+      expectedAttendees: 200,
+      minimumQuantity: 100,
+    });
+    expect(r.expectedTotalCents).toBeNull();
+    expect(r.expectedTotalBp).toBe(2000);
+    expect(r.bestCaseBp).toBe(1000);
+  });
+});
+
+describe("computeOfferComparisonBands revenue-share", () => {
+  it("expected = basis * pct; worst case zero", () => {
+    const r = computeOfferComparisonBands({
+      pricingModel: "TICKET_REVENUE_PERCENTAGE",
+      expectedBasisCents: 1_000_000,
+      percentage: 30,
+    });
+    expect(r.expectedTotalCents).toBe(300_000);
+    expect(r.bestCaseCents).toBe(300_000);
+    expect(r.worstCaseCents).toBe(0);
+  });
+
+  it("clamps percentage", () => {
+    const r = computeOfferComparisonBands({
+      pricingModel: "PRODUCT_SALES_PERCENTAGE",
+      expectedBasisCents: 1_000_000,
+      percentage: 200,
+    });
+    expect(r.expectedTotalCents).toBe(1_000_000);
+  });
+});
+
+describe("computeOfferComparisonBands TIERED", () => {
+  it("uses chosen tier as expected, low/high for bands", () => {
+    const r = computeOfferComparisonBands({
+      pricingModel: "TIERED",
+      tieredExpectedTierCents: 200_000,
+      tieredLowestTierCents: 100_000,
+      tieredHighestTierCents: 500_000,
+    });
+    expect(r.expectedTotalCents).toBe(200_000);
+    expect(r.bestCaseCents).toBe(100_000);
+    expect(r.worstCaseCents).toBe(500_000);
+  });
+});
+
+describe("computeOfferComparisonBands fallback", () => {
+  it("treats unknown model as flat", () => {
+    const r = computeOfferComparisonBands({
+      pricingModel: "MYSTERY_MODEL",
+      baseRateCents: 30_000,
+    });
+    expect(r.expectedTotalCents).toBe(30_000);
+    expect(r.reasoning).toContain("Unrecognized");
+  });
+});

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

@@ -0,0 +1,171 @@
+import {
+  computeServiceBookingExposure,
+  isVariablePricingModel,
+  summarizeServiceBookingExposures,
+} from "../serviceBookingExposureUtils";
+
+describe("isVariablePricingModel", () => {
+  it("returns true for attendee- and revenue-driven models", () => {
+    expect(isVariablePricingModel("PER_ATTENDEE")).toBe(true);
+    expect(isVariablePricingModel("PER_PAID_ATTENDEE")).toBe(true);
+    expect(isVariablePricingModel("PER_BASHPOINTS_ATTENDEE")).toBe(true);
+    expect(isVariablePricingModel("TICKET_REVENUE_PERCENTAGE")).toBe(true);
+    expect(isVariablePricingModel("PRODUCT_SALES_PERCENTAGE")).toBe(true);
+    expect(isVariablePricingModel("TIERED")).toBe(true);
+    expect(isVariablePricingModel("CUSTOM")).toBe(true);
+  });
+
+  it("returns false for flat models", () => {
+    expect(isVariablePricingModel("FLAT_FEE")).toBe(false);
+    expect(isVariablePricingModel("HOURLY")).toBe(false);
+    expect(isVariablePricingModel("PER_DAY")).toBe(false);
+  });
+
+  it("returns false for unknown / null inputs", () => {
+    expect(isVariablePricingModel(null)).toBe(false);
+    expect(isVariablePricingModel(undefined)).toBe(false);
+    expect(isVariablePricingModel("NOT_A_MODEL")).toBe(false);
+  });
+});
+
+describe("computeServiceBookingExposure", () => {
+  it("treats null pricingModel as flat — expected equals worst from totalATBCents", () => {
+    const out = computeServiceBookingExposure({
+      bookingId: "b1",
+      label: "Legacy booking",
+      pricingModel: null,
+      totalATBCents: 150_000,
+    });
+    expect(out.isVariable).toBe(false);
+    expect(out.expectedCents).toBe(150_000);
+    expect(out.worstCaseCents).toBe(150_000);
+  });
+
+  it("uses flatRateCents when totalATBCents missing", () => {
+    const out = computeServiceBookingExposure({
+      bookingId: "b1",
+      label: "Photo Booth",
+      pricingModel: "FLAT_FEE",
+      flatRateCents: 50_000,
+    });
+    expect(out.expectedCents).toBe(50_000);
+    expect(out.worstCaseCents).toBe(50_000);
+  });
+
+  it("computes PER_ATTENDEE expected and worst case from attendee fields", () => {
+    const out = computeServiceBookingExposure({
+      bookingId: "b1",
+      label: "DJ",
+      pricingModel: "PER_ATTENDEE",
+      baseRateCents: 500,
+      expectedAttendeesAtBooking: 200,
+      maxAttendeesAttributable: 250,
+    });
+    expect(out.isVariable).toBe(true);
+    expect(out.expectedCents).toBe(100_000); // 200 * 500
+    expect(out.worstCaseCents).toBe(125_000); // 250 * 500
+  });
+
+  it("prefers maxBillableCents over the attendee ceiling for worst case", () => {
+    const out = computeServiceBookingExposure({
+      bookingId: "b1",
+      label: "DJ",
+      pricingModel: "PER_ATTENDEE",
+      baseRateCents: 500,
+      expectedAttendeesAtBooking: 200,
+      maxAttendeesAttributable: 250,
+      maxBillableCents: 200_000,
+    });
+    expect(out.worstCaseCents).toBe(200_000);
+  });
+
+  it("falls back to 1.5x expected when no caps set on variable bookings", () => {
+    const out = computeServiceBookingExposure({
+      bookingId: "b1",
+      label: "DJ",
+      pricingModel: "PER_ATTENDEE",
+      baseRateCents: 500,
+      expectedAttendeesAtBooking: 200,
+    });
+    expect(out.expectedCents).toBe(100_000);
+    expect(out.worstCaseCents).toBe(150_000); // 100_000 * 1.5
+  });
+
+  it("clamps worst case never below expected", () => {
+    // Pathological: maxBillableCents below expected.
+    const out = computeServiceBookingExposure({
+      bookingId: "b1",
+      label: "DJ",
+      pricingModel: "PER_ATTENDEE",
+      baseRateCents: 500,
+      expectedAttendeesAtBooking: 200,
+      maxBillableCents: 50_000, // lower than expected 100_000
+    });
+    expect(out.expectedCents).toBe(100_000);
+    expect(out.worstCaseCents).toBe(100_000);
+  });
+
+  it("handles revenue-share by using totalATB as expected, 1.5x as worst", () => {
+    const out = computeServiceBookingExposure({
+      bookingId: "b1",
+      label: "Venue (rev-share)",
+      pricingModel: "TICKET_REVENUE_PERCENTAGE",
+      totalATBCents: 80_000,
+    });
+    expect(out.isVariable).toBe(true);
+    expect(out.expectedCents).toBe(80_000);
+    expect(out.worstCaseCents).toBe(120_000); // 80_000 * 1.5
+  });
+
+  it("returns zeros when nothing usable is provided", () => {
+    const out = computeServiceBookingExposure({
+      bookingId: "b1",
+      label: "Mystery",
+      pricingModel: "CUSTOM",
+    });
+    expect(out.expectedCents).toBe(0);
+    expect(out.worstCaseCents).toBe(0);
+  });
+});
+
+describe("summarizeServiceBookingExposures", () => {
+  it("sums expected + worst-case across mixed bookings", () => {
+    const out = summarizeServiceBookingExposures([
+      {
+        bookingId: "a",
+        label: "DJ",
+        pricingModel: "PER_ATTENDEE",
+        baseRateCents: 500,
+        expectedAttendeesAtBooking: 200,
+        maxAttendeesAttributable: 250,
+      },
+      {
+        bookingId: "b",
+        label: "Photo Booth",
+        pricingModel: "FLAT_FEE",
+        totalATBCents: 50_000,
+      },
+      {
+        bookingId: "c",
+        label: "Caterer (legacy)",
+        pricingModel: null,
+        totalATBCents: 200_000,
+      },
+    ]);
+    // Expected: 100_000 + 50_000 + 200_000 = 350_000
+    expect(out.projectedTotalCents).toBe(350_000);
+    // Worst: 125_000 + 50_000 + 200_000 = 375_000
+    expect(out.worstCaseTotalCents).toBe(375_000);
+    expect(out.byBooking).toHaveLength(3);
+    expect(out.byBooking[0].isVariable).toBe(true);
+    expect(out.byBooking[1].isVariable).toBe(false);
+    expect(out.byBooking[2].isVariable).toBe(false);
+  });
+
+  it("returns zeros for an empty list", () => {
+    const out = summarizeServiceBookingExposures([]);
+    expect(out.projectedTotalCents).toBe(0);
+    expect(out.worstCaseTotalCents).toBe(0);
+    expect(out.byBooking).toEqual([]);
+  });
+});

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

@@ -0,0 +1,83 @@
+import { describe, expect, it } from "@jest/globals";
+import { resolveUnifiedPricingBlock } from "../unifiedPricingResolver.js";
+
+describe("resolveUnifiedPricingBlock", () => {
+  it("returns the empty block when nothing is configured", () => {
+    const r = resolveUnifiedPricingBlock({});
+    expect(r.fromUnifiedBlock).toBe(false);
+    expect(r.noRateConfigured).toBe(true);
+    expect(r.baseRateCents).toBeNull();
+  });
+
+  it("prefers the unified block from the first subtype that has one", () => {
+    const r = resolveUnifiedPricingBlock({
+      vendor: {
+        pricingModel: "FLAT_FEE",
+        baseRateCents: 50_000,
+        rateUnit: "event",
+      },
+      legacyRate: { ratePerUnitCents: 99_999 },
+    });
+    expect(r.fromUnifiedBlock).toBe(true);
+    expect(r.baseRateCents).toBe(50_000);
+    expect(r.rateUnit).toBe("event");
+  });
+
+  it("walks all candidate subtypes when earlier ones are empty", () => {
+    const r = resolveUnifiedPricingBlock({
+      eventService: null,
+      vendor: null,
+      exhibitor: null,
+      sponsor: {
+        pricingModel: "TIERED",
+        baseRateCents: 100_000,
+      },
+    });
+    expect(r.fromUnifiedBlock).toBe(true);
+    expect(r.pricingModel).toBe("TIERED");
+    expect(r.baseRateCents).toBe(100_000);
+  });
+
+  it("recognizes a unified signal even when only baseRateBashPoints is set", () => {
+    const r = resolveUnifiedPricingBlock({
+      eventService: {
+        pricingModel: null,
+        baseRateCents: null,
+        baseRateBashPoints: 25,
+      },
+    });
+    expect(r.fromUnifiedBlock).toBe(true);
+    expect(r.baseRateBashPoints).toBe(25);
+    expect(r.noRateConfigured).toBe(false);
+  });
+
+  it("falls back to legacy ServiceRate when no unified block exists", () => {
+    const r = resolveUnifiedPricingBlock({
+      legacyRate: {
+        ratePerUnitCents: 12_345,
+        rateUnit: "hour",
+        minimumQuantity: 4,
+      },
+    });
+    expect(r.fromUnifiedBlock).toBe(false);
+    expect(r.pricingModel).toBe("FLAT_FEE");
+    expect(r.baseRateCents).toBe(12_345);
+    expect(r.minimumQuantity).toBe(4);
+  });
+
+  it("falls through to empty when both unified and legacy are unset", () => {
+    const r = resolveUnifiedPricingBlock({
+      vendor: { pricingModel: null, baseRateCents: null },
+      legacyRate: null,
+    });
+    expect(r.noRateConfigured).toBe(true);
+  });
+
+  it("noRateConfigured stays true when unified has minimumQuantity but no rate", () => {
+    const r = resolveUnifiedPricingBlock({
+      vendor: { minimumQuantity: 10 },
+    });
+    expect(r.fromUnifiedBlock).toBe(true);
+    expect(r.noRateConfigured).toBe(true);
+  });
+});

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

@@ -0,0 +1,219 @@
+import {
+  DEFAULT_FB_CARRYOVER_EXPIRY_DAYS,
+  REVENUE_SHARE_CANCELLATION_COPY,
+  FB_MINIMUM_CANCELLATION_COPY,
+  computeFBMinimumShortfallCents,
+  computeRevenueShareCents,
+  defaultFBCarryoverExpiresAt,
+  resolveFBMinimumForDate,
+} from "../venueSettlementUtils.js";
+
+describe("computeFBMinimumShortfallCents", () => {
+  it("computes a clean shortfall when subtotal < minimum", () => {
+    const out = computeFBMinimumShortfallCents({
+      fbMinimumCents: 1_000_000, // $10k
+      fbActualSpendCents: 750_000, // $7,500 subtotal
+      serviceChargeCents: 0,
+      taxCents: 0,
+      serviceChargeCountsTowardMinimum: true,
+      includesTax: false,
+    });
+    expect(out.coveredSpendCents).toBe(750_000);
+    expect(out.shortfallCents).toBe(250_000);
+    expect(out.excessCents).toBe(0);
+    expect(out.metExactly).toBe(false);
+  });
+
+  it("counts service charge toward minimum when the flag is on", () => {
+    const out = computeFBMinimumShortfallCents({
+      fbMinimumCents: 1_000_000,
+      fbActualSpendCents: 800_000,
+      serviceChargeCents: 160_000, // 20% svc
+      taxCents: 80_000,
+      serviceChargeCountsTowardMinimum: true,
+      includesTax: false,
+    });
+    expect(out.coveredSpendCents).toBe(960_000);
+    expect(out.shortfallCents).toBe(40_000);
+  });
+
+  it("excludes service charge when the flag is off", () => {
+    const out = computeFBMinimumShortfallCents({
+      fbMinimumCents: 1_000_000,
+      fbActualSpendCents: 800_000,
+      serviceChargeCents: 160_000,
+      taxCents: 80_000,
+      serviceChargeCountsTowardMinimum: false,
+      includesTax: false,
+    });
+    expect(out.coveredSpendCents).toBe(800_000);
+    expect(out.shortfallCents).toBe(200_000);
+  });
+
+  it("includes tax when the includesTax flag is set", () => {
+    const out = computeFBMinimumShortfallCents({
+      fbMinimumCents: 1_000_000,
+      fbActualSpendCents: 800_000,
+      serviceChargeCents: 0,
+      taxCents: 120_000,
+      serviceChargeCountsTowardMinimum: true,
+      includesTax: true,
+    });
+    expect(out.coveredSpendCents).toBe(920_000);
+    expect(out.shortfallCents).toBe(80_000);
+  });
+
+  it("returns excess (carryover-eligible) when covered exceeds minimum", () => {
+    const out = computeFBMinimumShortfallCents({
+      fbMinimumCents: 1_000_000,
+      fbActualSpendCents: 1_250_000,
+      serviceChargeCents: 0,
+      taxCents: 0,
+      serviceChargeCountsTowardMinimum: true,
+      includesTax: false,
+    });
+    expect(out.shortfallCents).toBe(0);
+    expect(out.excessCents).toBe(250_000);
+  });
+
+  it("marks metExactly when covered === minimum", () => {
+    const out = computeFBMinimumShortfallCents({
+      fbMinimumCents: 1_000_000,
+      fbActualSpendCents: 1_000_000,
+      serviceChargeCents: 0,
+      taxCents: 0,
+      serviceChargeCountsTowardMinimum: true,
+      includesTax: false,
+    });
+    expect(out.metExactly).toBe(true);
+    expect(out.shortfallCents).toBe(0);
+    expect(out.excessCents).toBe(0);
+  });
+
+  it("treats negative inputs as zero", () => {
+    const out = computeFBMinimumShortfallCents({
+      fbMinimumCents: 1_000_000,
+      fbActualSpendCents: -50_000,
+      serviceChargeCents: -10_000,
+      taxCents: -10_000,
+      serviceChargeCountsTowardMinimum: true,
+      includesTax: true,
+    });
+    expect(out.coveredSpendCents).toBe(0);
+    expect(out.shortfallCents).toBe(1_000_000);
+  });
+});
+
+describe("computeRevenueShareCents", () => {
+  it("splits 70/30 cleanly", () => {
+    expect(
+      computeRevenueShareCents({ basisCents: 1_000_000, hostPct: 70 })
+    ).toEqual({ hostCents: 700_000, venueCents: 300_000 });
+  });
+
+  it("clamps host pct to [0, 100]", () => {
+    expect(
+      computeRevenueShareCents({ basisCents: 1_000_000, hostPct: 250 })
+    ).toEqual({ hostCents: 1_000_000, venueCents: 0 });
+    expect(
+      computeRevenueShareCents({ basisCents: 1_000_000, hostPct: -50 })
+    ).toEqual({ hostCents: 0, venueCents: 1_000_000 });
+  });
+
+  it("returns zero for a zero basis", () => {
+    expect(
+      computeRevenueShareCents({ basisCents: 0, hostPct: 70 })
+    ).toEqual({ hostCents: 0, venueCents: 0 });
+  });
+});
+
+describe("resolveFBMinimumForDate", () => {
+  const TUE = new Date("2026-05-12T20:00:00Z"); // Tuesday
+  const SAT = new Date("2026-05-16T22:00:00Z"); // Saturday
+
+  it("picks the day-of-week minimum from the schedule", () => {
+    expect(
+      resolveFBMinimumForDate({
+        schedule: { Mon: 800_000, Tue: 900_000, Sat: 4_000_000 },
+        eventStartDateTime: TUE,
+      })
+    ).toBe(900_000);
+    expect(
+      resolveFBMinimumForDate({
+        schedule: { Mon: 800_000, Tue: 900_000, Sat: 4_000_000 },
+        eventStartDateTime: SAT,
+      })
+    ).toBe(4_000_000);
+  });
+
+  it("returns null when the schedule has no entry for the day", () => {
+    expect(
+      resolveFBMinimumForDate({
+        schedule: { Mon: 800_000 },
+        eventStartDateTime: TUE,
+      })
+    ).toBeNull();
+  });
+
+  it("returns null when the schedule is missing entirely", () => {
+    expect(
+      resolveFBMinimumForDate({
+        schedule: null,
+        eventStartDateTime: TUE,
+      })
+    ).toBeNull();
+  });
+
+  it("prefers an override window over the schedule when the date matches", () => {
+    const out = resolveFBMinimumForDate({
+      schedule: { Tue: 900_000 },
+      eventStartDateTime: new Date("2026-12-31T20:00:00Z"),
+      overrides: [
+        {
+          startDate: new Date("2026-12-30T00:00:00Z"),
+          endDate: new Date("2027-01-01T23:59:59Z"),
+          minimumCents: 10_000_000,
+        },
+      ],
+    });
+    expect(out).toBe(10_000_000);
+  });
+
+  it("ignores overrides whose window does not contain the bash date", () => {
+    const out = resolveFBMinimumForDate({
+      schedule: { Tue: 900_000 },
+      eventStartDateTime: TUE,
+      overrides: [
+        {
+          startDate: new Date("2026-12-30T00:00:00Z"),
+          endDate: new Date("2027-01-01T23:59:59Z"),
+          minimumCents: 10_000_000,
+        },
+      ],
+    });
+    expect(out).toBe(900_000);
+  });
+});
+
+describe("defaultFBCarryoverExpiresAt", () => {
+  it("defaults to 365 days from issuance", () => {
+    const issued = new Date("2026-01-01T00:00:00Z");
+    const expires = defaultFBCarryoverExpiresAt(issued);
+    expect(expires.getTime() - issued.getTime()).toBe(
+      DEFAULT_FB_CARRYOVER_EXPIRY_DAYS * 86_400_000
+    );
+  });
+
+  it("respects an explicit days override", () => {
+    const issued = new Date("2026-01-01T00:00:00Z");
+    const expires = defaultFBCarryoverExpiresAt(issued, 30);
+    expect(expires.getTime() - issued.getTime()).toBe(30 * 86_400_000);
+  });
+});
+
+describe("cancellation copy", () => {
+  it("exposes F&B + revenue-share cancellation snippets for the UI", () => {
+    expect(FB_MINIMUM_CANCELLATION_COPY).toMatch(/F&B minimum/);
+    expect(REVENUE_SHARE_CANCELLATION_COPY).toMatch(/revenue-share/i);
+  });
+});