@bash-app/bash-common 30.275.0 → 30.277.0

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

@@ -20,6 +20,11 @@ import {
   calculateBashPlatformFeeCents,
   splitBashPlatformFeeForTicketCheckout,
   computeTicketApplicationFeeAmountCents,
+  computeGuestTicketCheckoutBreakdown,
+  guestAllInUnitPriceCents,
+  guestCheckoutHasNoAddedFees,
+  lowestGuestAllInPriceCents,
+  hostAbsorbsTicketProcessing,
   userHasActiveBashPass,
   getEffectiveBashPassTier,
   getBashPassMonthlyCapRemaining,
@@ -166,7 +171,7 @@ describe("PaymentUtils - Core Functions", () => {
       expect(explicitFalse).toEqual(defaulted);
     });
 
-    test("computeTicketApplicationFeeAmountCents — verified nonprofit host: zero Bash platform, Stripe untouched", () => {
+    test("computeTicketApplicationFeeAmountCents — verified nonprofit host: zero Bash platform, guest may pay processing when GuestPays", () => {
       const r = computeTicketApplicationFeeAmountCents({
         discountedSubtotalCents: 10000,
         platformFeeEnabled: true,
@@ -177,12 +182,19 @@ describe("PaymentUtils - Core Functions", () => {
       });
       expect(r.bashPlatformTotalCents).toBe(0);
       expect(r.guestPlatformLineCents).toBe(0);
-      expect(r.totalChargedCents).toBe(10000);
-      expect(r.stripeProcessingCents).toBe(calculateStripeProcessingFeeCents(10000));
+      expect(r.guestProcessingLineCents).toBe(
+        calculateStripeProcessingFeeCents(10000),
+      );
+      expect(r.totalChargedCents).toBe(
+        10000 + calculateStripeProcessingFeeCents(10000),
+      );
+      expect(r.stripeProcessingCents).toBe(
+        calculateStripeProcessingFeeCents(r.totalChargedCents),
+      );
       expect(r.applicationFeeAmountCents).toBe(r.stripeProcessingCents);
     });
 
-    test("computeTicketApplicationFeeAmountCents — verified nonprofit waiver overrides feeHandling=GuestPays", () => {
+    test("computeTicketApplicationFeeAmountCents — verified nonprofit waiver overrides platform on GuestPays", () => {
       const nonNonprofit = computeTicketApplicationFeeAmountCents({
         discountedSubtotalCents: 5000,
         platformFeeEnabled: true,
@@ -192,7 +204,12 @@ describe("PaymentUtils - Core Functions", () => {
       });
       expect(nonNonprofit.bashPlatformTotalCents).toBe(250);
       expect(nonNonprofit.guestPlatformLineCents).toBe(250);
-      expect(nonNonprofit.totalChargedCents).toBe(5250);
+      expect(nonNonprofit.guestProcessingLineCents).toBe(
+        calculateStripeProcessingFeeCents(5000),
+      );
+      expect(nonNonprofit.totalChargedCents).toBe(
+        5000 + 250 + calculateStripeProcessingFeeCents(5000),
+      );
 
       const nonprofit = computeTicketApplicationFeeAmountCents({
         discountedSubtotalCents: 5000,
@@ -204,8 +221,15 @@ describe("PaymentUtils - Core Functions", () => {
       });
       expect(nonprofit.bashPlatformTotalCents).toBe(0);
       expect(nonprofit.guestPlatformLineCents).toBe(0);
-      expect(nonprofit.totalChargedCents).toBe(5000);
-      expect(nonprofit.applicationFeeAmountCents).toBe(nonprofit.stripeProcessingCents);
+      expect(nonprofit.guestProcessingLineCents).toBe(
+        calculateStripeProcessingFeeCents(5000),
+      );
+      expect(nonprofit.totalChargedCents).toBe(
+        5000 + calculateStripeProcessingFeeCents(5000),
+      );
+      expect(nonprofit.applicationFeeAmountCents).toBe(
+        nonprofit.stripeProcessingCents,
+      );
     });
 
     test("computeTicketApplicationFeeAmountCents — verified nonprofit waiver beats any membership-tier math", () => {
@@ -225,7 +249,17 @@ describe("PaymentUtils - Core Functions", () => {
         });
         expect(r.bashPlatformTotalCents).toBe(0);
         expect(r.guestPlatformLineCents).toBe(0);
-        expect(r.totalChargedCents).toBe(12345);
+        if (tier.feeHandling === "HostAbsorbs") {
+          expect(r.guestProcessingLineCents).toBe(0);
+          expect(r.totalChargedCents).toBe(12345);
+        } else {
+          expect(r.guestProcessingLineCents).toBe(
+            calculateStripeProcessingFeeCents(12345),
+          );
+          expect(r.totalChargedCents).toBe(
+            12345 + calculateStripeProcessingFeeCents(12345),
+          );
+        }
         expect(r.applicationFeeAmountCents).toBe(r.stripeProcessingCents);
       }
     });
@@ -289,6 +323,25 @@ describe("PaymentUtils - Core Functions", () => {
     test("calculateTotalPriceWithoutTax returns 0 for empty list", () => {
       expect(calculateTotalPriceWithoutTax([], new Map())).toBe(0);
     });
+
+    test("calculateTotalPriceWithoutTax uses unitPriceCents for pay-what-you-can tiers", () => {
+      const tiers = [
+        { id: "t1", price: 2000, pricingType: "USD", isDonationTier: true },
+      ] as any;
+      const ticketList = new Map([
+        [
+          "t1",
+          [
+            {
+              numberOfTickets: 2,
+              ticketDateTime: new Date(),
+              unitPriceCents: 5000,
+            },
+          ],
+        ],
+      ]);
+      expect(calculateTotalPriceWithoutTax(tiers, ticketList)).toBe(10000);
+    });
   });
 
   describe("Ticket total BashPoints", () => {
@@ -370,6 +423,68 @@ describe("PaymentUtils - Core Functions", () => {
     });
   });
 
+  describe("guest ticket checkout breakdown (No Fees for Attendees)", () => {
+    test("HostAbsorbs — $20 ticket → $20 due, no processing line", () => {
+      const r = computeGuestTicketCheckoutBreakdown({
+        discountedSubtotalCents: 2000,
+        platformFeeEnabled: false,
+        platformFeeRate: 0.03,
+        feeHandling: "HostAbsorbs",
+        bashPassWaivesGuestFee: false,
+      });
+      expect(r.ticketSubtotalCents).toBe(2000);
+      expect(r.guestProcessingLineCents).toBe(0);
+      expect(r.totalDueCents).toBe(2000);
+    });
+
+    test("GuestPays — $20 ticket → $20.88 all-in with processing line on subtotal", () => {
+      const processing = calculateStripeProcessingFeeCents(2000);
+      expect(processing).toBe(88);
+      const r = computeGuestTicketCheckoutBreakdown({
+        discountedSubtotalCents: 2000,
+        platformFeeEnabled: false,
+        platformFeeRate: 0.03,
+        feeHandling: "GuestPays",
+        bashPassWaivesGuestFee: false,
+      });
+      expect(r.guestProcessingLineCents).toBe(88);
+      expect(r.totalDueCents).toBe(2088);
+    });
+
+    test("guestCheckoutHasNoAddedFees and display helpers", () => {
+      expect(
+        guestCheckoutHasNoAddedFees({ feeHandling: "HostAbsorbs" }),
+      ).toBe(true);
+      expect(
+        guestCheckoutHasNoAddedFees({ feeHandling: "GuestPays" }),
+      ).toBe(false);
+      expect(
+        guestCheckoutHasNoAddedFees({
+          feeHandling: "HostAbsorbs",
+          externalTicketUrl: "https://eventbrite.com/x",
+        }),
+      ).toBe(false);
+      expect(hostAbsorbsTicketProcessing("HostAbsorbs")).toBe(true);
+      expect(hostAbsorbsTicketProcessing("GuestPays")).toBe(false);
+      expect(guestAllInUnitPriceCents(2000, { feeHandling: "HostAbsorbs" })).toBe(
+        2000,
+      );
+      expect(guestAllInUnitPriceCents(2000, { feeHandling: "GuestPays" })).toBe(
+        2088,
+      );
+      expect(
+        lowestGuestAllInPriceCents(
+          [
+            { price: 5000, pricingType: "USD" },
+            { price: 2000, pricingType: "USD" },
+            { price: 100, pricingType: "BASHPOINTS" },
+          ],
+          { feeHandling: "HostAbsorbs" },
+        ),
+      ).toBe(2000);
+    });
+  });
+
   describe("splitBashPlatformFeeForTicketCheckout edge cases", () => {
     test("returns zeros when platform fee disabled", () => {
       expect(

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

@@ -7,6 +7,8 @@ import { DateTime } from "luxon";
 import {
   getCompactRunFirstAndLastOccurrence,
   getRecurringBashEventPossibleLuxonTimes,
+  occurrenceOverrideKey,
+  parseOccurrenceOverrides,
 } from "../recurrenceUtils.js";
 
 function buildRecurrence(partial: Partial<Recurrence>): Recurrence {
@@ -94,3 +96,100 @@ describe("getCompactRunFirstAndLastOccurrence", () => {
     ).toBeNull();
   });
 });
+
+describe("occurrenceOverrideKey", () => {
+  it("returns the same key for Date and ISO string of the same instant", () => {
+    const iso = "2026-06-15T20:00:00.000Z";
+    expect(occurrenceOverrideKey(new Date(iso))).toBe(
+      occurrenceOverrideKey(iso)
+    );
+  });
+});
+
+describe("parseOccurrenceOverrides", () => {
+  it("returns empty object for nullish or non-object input", () => {
+    expect(parseOccurrenceOverrides(null)).toEqual({});
+    expect(parseOccurrenceOverrides(undefined)).toEqual({});
+    expect(parseOccurrenceOverrides([])).toEqual({});
+    expect(parseOccurrenceOverrides("bad")).toEqual({});
+  });
+
+  it("parses valid override entries and ignores malformed ones", () => {
+    expect(
+      parseOccurrenceOverrides({
+        "Jun 15, 2026 8:00 PM": {
+          startDateTime: "2026-06-16T20:00:00.000Z",
+          endDateTime: "2026-06-16T22:00:00.000Z",
+        },
+        bad: { noStart: true },
+        empty: null,
+      })
+    ).toEqual({
+      "Jun 15, 2026 8:00 PM": {
+        startDateTime: "2026-06-16T20:00:00.000Z",
+        endDateTime: "2026-06-16T22:00:00.000Z",
+      },
+    });
+  });
+});
+
+describe("occurrence exceptions in getRecurringBashEventPossibleLuxonTimes", () => {
+  it("drops skipped occurrences from excludedDates", () => {
+    const base = DateTime.utc().plus({ weeks: 2 }).startOf("day");
+    const start = base
+      .set({ hour: 20, minute: 0, second: 0, millisecond: 0 })
+      .toJSDate();
+    const recurrence = buildRecurrence({
+      frequency: RecurringFrequency.Daily,
+      interval: 1,
+      repeatCount: 3,
+      endsType: RecurrenceEndsType.AFTER_COUNT,
+    });
+
+    const baseline = getRecurringBashEventPossibleLuxonTimes(start, recurrence);
+    expect(baseline).toHaveLength(3);
+
+    const skipped = baseline[1];
+    const withSkip = buildRecurrence({
+      ...recurrence,
+      excludedDates: [skipped.toJSDate()],
+    } as Partial<Recurrence>);
+
+    const result = getRecurringBashEventPossibleLuxonTimes(start, withSkip);
+    expect(result).toHaveLength(2);
+    expect(result.map((d) => d.toMillis())).not.toContain(skipped.toMillis());
+  });
+
+  it("applies moved occurrences from occurrenceOverrides", () => {
+    const base = DateTime.utc().plus({ weeks: 2 }).startOf("day");
+    const start = base
+      .set({ hour: 20, minute: 0, second: 0, millisecond: 0 })
+      .toJSDate();
+    const recurrence = buildRecurrence({
+      frequency: RecurringFrequency.Daily,
+      interval: 1,
+      repeatCount: 3,
+      endsType: RecurrenceEndsType.AFTER_COUNT,
+    });
+
+    const baseline = getRecurringBashEventPossibleLuxonTimes(start, recurrence);
+    const original = baseline[1];
+    const movedStart = original.plus({ days: 2 }).toISO();
+    const withMove = buildRecurrence({
+      ...recurrence,
+      occurrenceOverrides: {
+        [occurrenceOverrideKey(original)]: {
+          startDateTime: movedStart!,
+          endDateTime: null,
+        },
+      },
+    } as Partial<Recurrence>);
+
+    const result = getRecurringBashEventPossibleLuxonTimes(start, withMove);
+    expect(result).toHaveLength(3);
+    expect(result.map((d) => d.toMillis())).toContain(
+      DateTime.fromISO(movedStart!).toMillis()
+    );
+    expect(result.map((d) => d.toMillis())).not.toContain(original.toMillis());
+  });
+});

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

@@ -29,6 +29,18 @@ describe("ticketListUtils", () => {
     expect(decoded.get("tier-xyz")![0].numberOfTickets).toBe(3);
   });
 
+  test("round-trips unitPriceCents for pay-what-you-can tiers", () => {
+    const ticketList = new Map<string, NumberOfTicketsForDate[]>([
+      [
+        "tier-pwyc",
+        [{ numberOfTickets: 1, ticketDateTime: isoDate, unitPriceCents: 7500 }],
+      ],
+    ]);
+
+    const decoded = ticketListStrToTicketList(ticketListToString(ticketList));
+    expect(decoded.get("tier-pwyc")![0].unitPriceCents).toBe(7500);
+  });
+
   test("omits tiers with zero tickets", () => {
     const ticketList = new Map<string, NumberOfTicketsForDate[]>([
       ["tier-empty", [{ numberOfTickets: 0, ticketDateTime: isoDate }]],

package/src/utils/groupTicketCartUtils.ts

@@ -0,0 +1,36 @@
+import type { TicketTier } from "@prisma/client";
+
+import type { NumberOfTicketsForDate } from "../definitions.js";
+import { isGroupTicketTier } from "../groupTicketUtils.js";
+
+/**
+ * Validates cart quantities for group package tiers: qty = packages, not seats.
+ */
+export function validateGroupTicketCartForTiers(
+  ticketTiers: TicketTier[],
+  ticketList: Map<string, NumberOfTicketsForDate[]>
+): { ok: true } | { ok: false; message: string } {
+  for (const tier of ticketTiers) {
+    if (!isGroupTicketTier(tier)) {
+      continue;
+    }
+    const rows = ticketList.get(tier.id);
+    if (!rows?.length) {
+      continue;
+    }
+    const packageQty = rows.reduce((s, r) => s + (r.numberOfTickets ?? 0), 0);
+    if (packageQty < 1) {
+      return {
+        ok: false,
+        message: `${tier.title} is a group package — select one package to buy.`,
+      };
+    }
+    if (packageQty > 1) {
+      return {
+        ok: false,
+        message: `${tier.title} is one package per checkout. Buy one table/package at a time.`,
+      };
+    }
+  }
+  return { ok: true };
+}

package/src/utils/paymentUtils.ts

@@ -44,6 +44,46 @@ export function calculateDiscountFromPromoCode(
   return 0;
 }
 
+/**
+ * Unit price in cents for checkout (supports pay-what-you-can tiers).
+ */
+export function effectiveTicketUnitPriceCents(
+  tier: TicketTier,
+  row: NumberOfTicketsForDate
+): number {
+  if (tier.isDonationTier === true && row.unitPriceCents != null) {
+    return Math.max(tier.price, row.unitPriceCents);
+  }
+  return tier.price;
+}
+
+export function validatePayWhatYouCanTicketList(
+  ticketTiers: TicketTier[],
+  ticketList: Map<string, NumberOfTicketsForDate[]>
+): { ok: true } | { ok: false; message: string } {
+  for (const tier of ticketTiers) {
+    if (tier.isDonationTier !== true) continue;
+    const rows = ticketList.get(tier.id);
+    if (!rows?.length) continue;
+    for (const row of rows) {
+      if ((row.numberOfTickets ?? 0) <= 0) continue;
+      if (row.unitPriceCents == null) {
+        return {
+          ok: false,
+          message: `Enter an amount for ${tier.title} (minimum $${convertCentsToDollars(tier.price).toFixed(2)}).`,
+        };
+      }
+      if (row.unitPriceCents < tier.price) {
+        return {
+          ok: false,
+          message: `${tier.title} requires at least $${convertCentsToDollars(tier.price).toFixed(2)} per ticket.`,
+        };
+      }
+    }
+  }
+  return { ok: true };
+}
+
 /**
  * Returns the total price in USD cents based on a map where the keys are the ticketTierIds
  * Only counts USD-priced tickets. BashPoints tickets are excluded (they have price=0).
@@ -60,7 +100,8 @@ export function calculateTotalPriceWithoutTax(
     if (tier.pricingType !== "BASHPOINTS") {
       const ticketListNumAndDate = ticketList.get(tier.id);
       ticketListNumAndDate?.forEach((numAndDate: NumberOfTicketsForDate) => {
-        total += tier.price * (numAndDate.numberOfTickets ?? 0);
+        const unitCents = effectiveTicketUnitPriceCents(tier, numAndDate);
+        total += unitCents * (numAndDate.numberOfTickets ?? 0);
       });
     }
   });
@@ -275,6 +316,120 @@ export function splitBashPlatformFeeForTicketCheckout(args: {
   return { totalPlatformCents: total, guestPlatformLineCents: guestLine };
 }
 
+/** Event fields needed for guest-facing ticket fee display and checkout breakdown. */
+export type TicketFeeEventContext = {
+  feeHandling?: string | null;
+  platformFeeEnabled?: boolean;
+  platformFeeRate?: number;
+  externalTicketUrl?: string | null;
+};
+
+export type GuestTicketCheckoutBreakdown = {
+  ticketSubtotalCents: number;
+  /** Guest-visible Stripe processing line (0 when host absorbs). */
+  guestProcessingLineCents: number;
+  guestPlatformLineCents: number;
+  /** Amount the guest pays (before tax). */
+  totalDueCents: number;
+  /** Stripe's 2.9% + $0.30 pass-through on the charge amount. */
+  stripeProcessingCents: number;
+  bashPlatformTotalCents: number;
+  applicationFeeAmountCents: number;
+};
+
+/** True when the host absorbs Stripe processing (`feeHandling` default). */
+export function hostAbsorbsTicketProcessing(
+  feeHandling: string | null | undefined,
+): boolean {
+  return (feeHandling ?? "HostAbsorbs") === "HostAbsorbs";
+}
+
+/**
+ * Whether the event qualifies for the public "No fees for attendees" badge.
+ * External-ticket events are excluded (Bash does not control checkout).
+ */
+export function guestCheckoutHasNoAddedFees(
+  event: TicketFeeEventContext,
+): boolean {
+  if (event.externalTicketUrl) return false;
+  return hostAbsorbsTicketProcessing(event.feeHandling);
+}
+
+/**
+ * Full guest ticket checkout breakdown — single source for API charges and UI copy.
+ *
+ * HostAbsorbs (default): guest pays subtotal (+ optional platform guest line only).
+ * GuestPays/Split (enterprise): guest also pays a visible processing line (fee on subtotal, donation-style).
+ */
+export function computeGuestTicketCheckoutBreakdown(args: {
+  discountedSubtotalCents: number;
+  platformFeeEnabled: boolean;
+  platformFeeRate: number;
+  feeHandling: string | null | undefined;
+  bashPassWaivesGuestFee: boolean;
+  isVerifiedNonprofitHost?: boolean;
+}): GuestTicketCheckoutBreakdown {
+  const ticketSubtotalCents = args.discountedSubtotalCents;
+  const isVerifiedNonprofitHost = args.isVerifiedNonprofitHost === true;
+  const split = isVerifiedNonprofitHost
+    ? { totalPlatformCents: 0, guestPlatformLineCents: 0 }
+    : splitBashPlatformFeeForTicketCheckout({
+        grossCents: ticketSubtotalCents,
+        platformFeeEnabled: args.platformFeeEnabled,
+        platformFeeRate: args.platformFeeRate,
+        feeHandling: args.feeHandling,
+        bashPassWaivesGuestFee: args.bashPassWaivesGuestFee,
+      });
+  const guestPlatformLineCents = split.guestPlatformLineCents;
+  const bashPlatformTotalCents = split.totalPlatformCents;
+  const guestProcessingLineCents = hostAbsorbsTicketProcessing(args.feeHandling)
+    ? 0
+    : calculateStripeProcessingFeeCents(ticketSubtotalCents);
+  const totalDueCents =
+    ticketSubtotalCents + guestProcessingLineCents + guestPlatformLineCents;
+  const stripeProcessingCents = calculateStripeProcessingFeeCents(totalDueCents);
+  const applicationFeeAmountCents =
+    stripeProcessingCents + bashPlatformTotalCents;
+  return {
+    ticketSubtotalCents,
+    guestProcessingLineCents,
+    guestPlatformLineCents,
+    totalDueCents,
+    stripeProcessingCents,
+    bashPlatformTotalCents,
+    applicationFeeAmountCents,
+  };
+}
+
+/** All-in mandatory guest price for one USD tier (cards, detail page). */
+export function guestAllInUnitPriceCents(
+  unitPriceCents: number,
+  event: TicketFeeEventContext,
+): number {
+  if (unitPriceCents <= 0) return 0;
+  return computeGuestTicketCheckoutBreakdown({
+    discountedSubtotalCents: unitPriceCents,
+    platformFeeEnabled: event.platformFeeEnabled ?? false,
+    platformFeeRate: event.platformFeeRate ?? 0.03,
+    feeHandling: event.feeHandling,
+    bashPassWaivesGuestFee: false,
+  }).totalDueCents;
+}
+
+/** Lowest all-in USD tier price for "From $X" previews. */
+export function lowestGuestAllInPriceCents(
+  tiers: ReadonlyArray<Pick<TicketTier, "price" | "pricingType">>,
+  event: TicketFeeEventContext,
+): number | null {
+  let min: number | null = null;
+  for (const tier of tiers) {
+    if (tier.pricingType === "BASHPOINTS" || tier.price <= 0) continue;
+    const allIn = guestAllInUnitPriceCents(tier.price, event);
+    if (min === null || allIn < min) min = allIn;
+  }
+  return min;
+}
+
 /**
  * Compute the Stripe Connect `application_fee_amount` for a ticket-style charge,
  * along with its constituent parts.
@@ -310,28 +465,17 @@ export function computeTicketApplicationFeeAmountCents(args: {
   applicationFeeAmountCents: number;
   /** Guest-visible portion of the platform line. Zero when `isVerifiedNonprofitHost` is true. */
   guestPlatformLineCents: number;
+  /** Guest-visible Stripe processing line (0 when host absorbs). */
+  guestProcessingLineCents: number;
 } {
-  const isVerifiedNonprofitHost = args.isVerifiedNonprofitHost === true;
-  const split = isVerifiedNonprofitHost
-    ? { totalPlatformCents: 0, guestPlatformLineCents: 0 }
-    : splitBashPlatformFeeForTicketCheckout({
-        grossCents: args.discountedSubtotalCents,
-        platformFeeEnabled: args.platformFeeEnabled,
-        platformFeeRate: args.platformFeeRate,
-        feeHandling: args.feeHandling,
-        bashPassWaivesGuestFee: args.bashPassWaivesGuestFee,
-      });
-  const guestPlatformLineCents = split.guestPlatformLineCents;
-  const bashPlatformTotalCents = split.totalPlatformCents;
-  const totalChargedCents = args.discountedSubtotalCents + guestPlatformLineCents;
-  const stripeProcessingCents = calculateStripeProcessingFeeCents(totalChargedCents);
-  const applicationFeeAmountCents = stripeProcessingCents + bashPlatformTotalCents;
+  const breakdown = computeGuestTicketCheckoutBreakdown(args);
   return {
-    totalChargedCents,
-    stripeProcessingCents,
-    bashPlatformTotalCents,
-    applicationFeeAmountCents,
-    guestPlatformLineCents,
+    totalChargedCents: breakdown.totalDueCents,
+    stripeProcessingCents: breakdown.stripeProcessingCents,
+    bashPlatformTotalCents: breakdown.bashPlatformTotalCents,
+    applicationFeeAmountCents: breakdown.applicationFeeAmountCents,
+    guestPlatformLineCents: breakdown.guestPlatformLineCents,
+    guestProcessingLineCents: breakdown.guestProcessingLineCents,
   };
 }
 

package/src/utils/recurrenceUtils.ts

@@ -10,6 +10,66 @@ import {
 import { compareDateTime } from "./dateTimeUtils.js";
 import { dayOfWeekToIdx } from "./generalDateTimeUtils.js";
 
+/**
+ * Per-occurrence date/time move. Keyed (in `Recurrence.occurrenceOverrides`) by the
+ * original generated occurrence's `LUXON_DATETIME_FORMAT_ISO_LIKE` string.
+ */
+export interface OccurrenceOverride {
+  startDateTime: string; // ISO
+  endDateTime?: string | null; // ISO
+}
+
+export type OccurrenceOverrideMap = Record<string, OccurrenceOverride>;
+
+/**
+ * Stable key for an occurrence within a series. Both the generator and the
+ * skip/move persistence must derive the key the same way, so callers should use this.
+ */
+export function occurrenceOverrideKey(
+  occurrenceStart: Date | string | DateTime
+): string {
+  const dt = DateTime.isDateTime(occurrenceStart)
+    ? occurrenceStart
+    : dateTimeFromDate(occurrenceStart);
+  return dt.toFormat(LUXON_DATETIME_FORMAT_ISO_LIKE);
+}
+
+/** Safely coerce the `Recurrence.occurrenceOverrides` Json column into a typed map. */
+export function parseOccurrenceOverrides(
+  raw: unknown
+): OccurrenceOverrideMap {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+  const out: OccurrenceOverrideMap = {};
+  for (const [key, value] of Object.entries(raw as Record<string, unknown>)) {
+    if (
+      value &&
+      typeof value === "object" &&
+      typeof (value as { startDateTime?: unknown }).startDateTime === "string"
+    ) {
+      const v = value as { startDateTime: string; endDateTime?: unknown };
+      out[key] = {
+        startDateTime: v.startDateTime,
+        endDateTime:
+          typeof v.endDateTime === "string" ? v.endDateTime : null,
+      };
+    }
+  }
+  return out;
+}
+
+/** True when the host has skipped or moved at least one occurrence in the series. */
+export function recurrenceHasOccurrenceExceptions(
+  recurrence: Recurrence | null | undefined
+): boolean {
+  if (!recurrence) return false;
+  const excluded = (recurrence as { excludedDates?: Date[] }).excludedDates ?? [];
+  if (excluded.length > 0) return true;
+  const overrides = parseOccurrenceOverrides(
+    (recurrence as { occurrenceOverrides?: unknown }).occurrenceOverrides
+  );
+  return Object.keys(overrides).length > 0;
+}
+
 export function getRecurringBashEventPossibleDateTimes(
   startDateTime: DateTimeArgType,
   recurrence: Recurrence | undefined | null
@@ -79,6 +139,11 @@ function getRecurringBashEventPossibleDatesTimesInternal(
     recurrenceDates = recurrenceDates.slice(0, recurrence.repeatCount);
   }
 
+  // Apply per-occurrence exceptions against the original generated instants:
+  // 1) drop occurrences the host removed (excludedDates)
+  // 2) move occurrences the host rescheduled (occurrenceOverrides)
+  recurrenceDates = applyOccurrenceExceptions(recurrenceDates, recurrence);
+
   return recurrenceDates
     .map((date: DateTime): string =>
       date.toFormat(LUXON_DATETIME_FORMAT_ISO_LIKE)
@@ -97,6 +162,45 @@ function getRecurringBashEventPossibleDatesTimesInternal(
     });
 }
 
+/**
+ * Remove skipped occurrences and apply rescheduled (moved) occurrences. Matching is by
+ * the original occurrence's `LUXON_DATETIME_FORMAT_ISO_LIKE` key so it survives the
+ * format→reparse round-trip the generator already does.
+ */
+function applyOccurrenceExceptions(
+  occurrences: DateTime[],
+  recurrence: Recurrence
+): DateTime[] {
+  const excludedKeys = new Set(
+    (
+      ((recurrence as { excludedDates?: Date[] }).excludedDates) ?? []
+    ).map((d) => occurrenceOverrideKey(d))
+  );
+  const overrides = parseOccurrenceOverrides(
+    (recurrence as { occurrenceOverrides?: unknown }).occurrenceOverrides
+  );
+
+  if (excludedKeys.size === 0 && Object.keys(overrides).length === 0) {
+    return occurrences;
+  }
+
+  const result: DateTime[] = [];
+  for (const occ of occurrences) {
+    const key = occurrenceOverrideKey(occ);
+    if (excludedKeys.has(key)) continue;
+    const override = overrides[key];
+    if (override?.startDateTime) {
+      const moved = dateTimeFromDate(new Date(override.startDateTime));
+      if (moved.isValid) {
+        result.push(moved);
+        continue;
+      }
+    }
+    result.push(occ);
+  }
+  return result;
+}
+
 /**
  * Get the daily recurring dates
  * @param beginningDateTime The beginning DateTime of the event, adjusted to be no earlier than now.