@bash-app/bash-common 30.236.0 → 30.238.0

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);
+  });
+});

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

@@ -0,0 +1,172 @@
+import { describe, expect, it } from "@jest/globals";
+import {
+  DEFAULT_VOLUNTEER_STIPEND_BP_PER_HOUR,
+  DEFAULT_VOLUNTEER_STIPEND_BP_PER_SHIFT,
+  VOLUNTEER_COMPENSATION_DISCLAIMER,
+  VOLUNTEER_RATE_UNITS,
+  compensationTypeIncludesPerks,
+  compensationTypePaysBashPoints,
+  defaultStipendBpFor,
+  validateVolunteerCompensation,
+  volunteerCompensationSummary,
+} from "../volunteerCompensationUtils.js";
+
+describe("defaultStipendBpFor", () => {
+  it("defaults to per-shift starter BP when rateUnit is shift / null / unknown", () => {
+    expect(defaultStipendBpFor({ rateUnit: "shift" })).toBe(
+      DEFAULT_VOLUNTEER_STIPEND_BP_PER_SHIFT
+    );
+    expect(defaultStipendBpFor({ rateUnit: null })).toBe(
+      DEFAULT_VOLUNTEER_STIPEND_BP_PER_SHIFT
+    );
+    expect(defaultStipendBpFor({ rateUnit: "garbage" })).toBe(
+      DEFAULT_VOLUNTEER_STIPEND_BP_PER_SHIFT
+    );
+  });
+
+  it("returns the per-hour starter BP when rateUnit is hour", () => {
+    expect(defaultStipendBpFor({ rateUnit: "hour" })).toBe(
+      DEFAULT_VOLUNTEER_STIPEND_BP_PER_HOUR
+    );
+  });
+});
+
+describe("VOLUNTEER_RATE_UNITS", () => {
+  it("locks the allowed unit set to shift and hour", () => {
+    expect([...VOLUNTEER_RATE_UNITS]).toEqual(["shift", "hour"]);
+  });
+});
+
+describe("compensationTypePaysBashPoints / IncludesPerks", () => {
+  it("BashPointsStipend pays BP, no perks", () => {
+    expect(compensationTypePaysBashPoints("BashPointsStipend")).toBe(true);
+    expect(compensationTypeIncludesPerks("BashPointsStipend")).toBe(false);
+  });
+
+  it("PerksOnly has perks, no BP", () => {
+    expect(compensationTypePaysBashPoints("PerksOnly")).toBe(false);
+    expect(compensationTypeIncludesPerks("PerksOnly")).toBe(true);
+  });
+
+  it("BashPointsAndPerks has both", () => {
+    expect(compensationTypePaysBashPoints("BashPointsAndPerks")).toBe(true);
+    expect(compensationTypeIncludesPerks("BashPointsAndPerks")).toBe(true);
+  });
+
+  it("None has neither", () => {
+    expect(compensationTypePaysBashPoints("None")).toBe(false);
+    expect(compensationTypeIncludesPerks("None")).toBe(false);
+  });
+});
+
+describe("validateVolunteerCompensation", () => {
+  it("ok for pure-volunteer", () => {
+    expect(
+      validateVolunteerCompensation({ compensationType: "None" }).ok
+    ).toBe(true);
+  });
+
+  it("requires a stipend amount + rateUnit when paying BashPoints", () => {
+    expect(
+      validateVolunteerCompensation({
+        compensationType: "BashPointsStipend",
+        bashPointsStipend: null,
+        rateUnit: "shift",
+      }).ok
+    ).toBe(false);
+    expect(
+      validateVolunteerCompensation({
+        compensationType: "BashPointsStipend",
+        bashPointsStipend: 100,
+        rateUnit: null,
+      }).ok
+    ).toBe(false);
+    expect(
+      validateVolunteerCompensation({
+        compensationType: "BashPointsStipend",
+        bashPointsStipend: 100,
+        rateUnit: "shift",
+      }).ok
+    ).toBe(true);
+  });
+
+  it("rejects a leftover stipend on a non-BP comp type", () => {
+    const r = validateVolunteerCompensation({
+      compensationType: "PerksOnly",
+      bashPointsStipend: 50,
+      perksDescription: "Comp ticket",
+    });
+    expect(r.ok).toBe(false);
+  });
+
+  it("requires perksDescription when perks are included", () => {
+    expect(
+      validateVolunteerCompensation({
+        compensationType: "PerksOnly",
+        perksDescription: null,
+      }).ok
+    ).toBe(false);
+    expect(
+      validateVolunteerCompensation({
+        compensationType: "PerksOnly",
+        perksDescription: "Comp ticket + drink wristband",
+      }).ok
+    ).toBe(true);
+  });
+
+  it("ok for BashPointsAndPerks with everything filled in", () => {
+    expect(
+      validateVolunteerCompensation({
+        compensationType: "BashPointsAndPerks",
+        bashPointsStipend: 150,
+        rateUnit: "shift",
+        perksDescription: "Comp ticket",
+      }).ok
+    ).toBe(true);
+  });
+});
+
+describe("volunteerCompensationSummary", () => {
+  it("None → pure volunteer copy", () => {
+    expect(
+      volunteerCompensationSummary({ compensationType: "None" })
+    ).toMatch(/Pure volunteer/);
+  });
+
+  it("BashPointsStipend includes amount + unit", () => {
+    expect(
+      volunteerCompensationSummary({
+        compensationType: "BashPointsStipend",
+        bashPointsStipend: 100,
+        rateUnit: "shift",
+      })
+    ).toBe("100 BashPoints per shift.");
+  });
+
+  it("PerksOnly echoes the perks description", () => {
+    expect(
+      volunteerCompensationSummary({
+        compensationType: "PerksOnly",
+        perksDescription: "Comp ticket + drink wristband",
+      })
+    ).toContain("Comp ticket");
+  });
+
+  it("BashPointsAndPerks shows both", () => {
+    const out = volunteerCompensationSummary({
+      compensationType: "BashPointsAndPerks",
+      bashPointsStipend: 150,
+      rateUnit: "shift",
+      perksDescription: "Comp ticket",
+    });
+    expect(out).toContain("150 BashPoints");
+    expect(out).toContain("Comp ticket");
+  });
+});
+
+describe("disclaimer copy", () => {
+  it("makes clear volunteers are not employees or contractors and BP isn't wages", () => {
+    expect(VOLUNTEER_COMPENSATION_DISCLAIMER).toMatch(/not employees/i);
+    expect(VOLUNTEER_COMPENSATION_DISCLAIMER).toMatch(/not wages/i);
+  });
+});

package/src/utils/service/apiServiceBookingApiUtils.ts

@@ -276,5 +276,9 @@ export function servicePriceToBookToApiBookingBase({
     packages: [],
     allowPromiseToPay: allowPromiseToPay,
     isFreeGuest: isFreeGuest,
+    // Phase 3 — providers opt in per-booking when they want BP-paid tickets
+    // to count toward PER_PAID_ATTENDEE settlement. Defaults to false so
+    // legacy bookings keep their original counting semantics.
+    countsBashPointsTickets: false,
   };
 }