@bash-app/bash-common 30.314.0 → 30.318.0

package/src/__tests__/relationshipHealth.test.ts

@@ -0,0 +1,370 @@
+import { computeRelationshipHealth, RELATIONSHIP_HEALTH_LABELS } from "../relationshipHealth.js";
+
+const NOW = new Date("2026-07-13T00:00:00Z");
+
+describe("computeRelationshipHealth", () => {
+  it("returns New with no attendance history", () => {
+    const result = computeRelationshipHealth(
+      { eventCount: 0, lastAttendedAt: null, firstAttendedAt: null, tags: [], lastOutreachAt: null },
+      NOW
+    );
+    expect(result.status).toBe("New");
+    expect(result.reasons.join(" ")).toMatch(/no attended bashes/i);
+  });
+
+  it("returns New for a single recent attendance", () => {
+    const result = computeRelationshipHealth(
+      {
+        eventCount: 1,
+        lastAttendedAt: new Date("2026-07-01T00:00:00Z").toISOString(),
+        firstAttendedAt: new Date("2026-07-01T00:00:00Z").toISOString(),
+        tags: [],
+        lastOutreachAt: null,
+      },
+      NOW
+    );
+    expect(result.status).toBe("New");
+  });
+
+  it("returns Cooling for a single attendance that lapsed a few months", () => {
+    const result = computeRelationshipHealth(
+      {
+        eventCount: 1,
+        lastAttendedAt: new Date("2026-04-01T00:00:00Z").toISOString(),
+        firstAttendedAt: new Date("2026-04-01T00:00:00Z").toISOString(),
+        tags: [],
+        lastOutreachAt: null,
+      },
+      NOW
+    );
+    expect(result.status).toBe("Cooling");
+  });
+
+  it("returns AtRisk for a single attendance that lapsed a long time ago", () => {
+    const result = computeRelationshipHealth(
+      {
+        eventCount: 1,
+        lastAttendedAt: new Date("2025-01-01T00:00:00Z").toISOString(),
+        firstAttendedAt: new Date("2025-01-01T00:00:00Z").toISOString(),
+        tags: [],
+        lastOutreachAt: null,
+      },
+      NOW
+    );
+    expect(result.status).toBe("AtRisk");
+  });
+
+  it("returns Steady for a regular attendee within their own cadence", () => {
+    const result = computeRelationshipHealth(
+      {
+        eventCount: 5,
+        firstAttendedAt: new Date("2026-01-13T00:00:00Z").toISOString(),
+        lastAttendedAt: new Date("2026-06-23T00:00:00Z").toISOString(),
+        tags: [],
+        lastOutreachAt: null,
+      },
+      NOW
+    );
+    expect(result.status).toBe("Steady");
+    expect(result.expectedGapDays).not.toBeNull();
+  });
+
+  it("returns Cooling then AtRisk as the gap relative to cadence grows", () => {
+    const base = {
+      eventCount: 4,
+      firstAttendedAt: new Date("2026-01-01T00:00:00Z").toISOString(),
+      tags: [] as string[],
+      lastOutreachAt: null,
+    };
+    // span Jan1→May1 = 120 days over 3 gaps → expectedGapDays = 40;
+    // daysSince (NOW=Jul13) = 73 → ratio ~1.83 → Cooling
+    const cooling = computeRelationshipHealth(
+      { ...base, lastAttendedAt: new Date("2026-05-01T00:00:00Z").toISOString() },
+      NOW
+    );
+    expect(cooling.status).toBe("Cooling");
+
+    // span Jan1→Feb1 = 31 days over 3 gaps → expectedGapDays clamps to the 14-day
+    // floor; daysSince = 162 → ratio ~11.6 → AtRisk
+    const atRisk = computeRelationshipHealth(
+      { ...base, lastAttendedAt: new Date("2026-02-01T00:00:00Z").toISOString() },
+      NOW
+    );
+    expect(atRisk.status).toBe("AtRisk");
+  });
+
+  it("escalates a Cooling VIP to AtRisk and records why", () => {
+    const withoutVip = computeRelationshipHealth(
+      {
+        eventCount: 1,
+        lastAttendedAt: new Date("2026-04-01T00:00:00Z").toISOString(),
+        firstAttendedAt: new Date("2026-04-01T00:00:00Z").toISOString(),
+        tags: [],
+        lastOutreachAt: null,
+      },
+      NOW
+    );
+    expect(withoutVip.status).toBe("Cooling");
+
+    const withVip = computeRelationshipHealth(
+      {
+        eventCount: 1,
+        lastAttendedAt: new Date("2026-04-01T00:00:00Z").toISOString(),
+        firstAttendedAt: new Date("2026-04-01T00:00:00Z").toISOString(),
+        tags: ["VIP"],
+        lastOutreachAt: null,
+      },
+      NOW
+    );
+    expect(withVip.status).toBe("AtRisk");
+    expect(withVip.reasons.some((r) => /vip/i.test(r))).toBe(true);
+  });
+
+  it("includes outreach recency in the inspectable reasons without changing the bucket", () => {
+    const result = computeRelationshipHealth(
+      {
+        eventCount: 5,
+        firstAttendedAt: new Date("2026-01-13T00:00:00Z").toISOString(),
+        lastAttendedAt: new Date("2026-06-23T00:00:00Z").toISOString(),
+        tags: [],
+        lastOutreachAt: new Date("2026-07-10T00:00:00Z").toISOString(),
+      },
+      NOW
+    );
+    expect(result.status).toBe("Steady");
+    expect(result.reasons.some((r) => /contacted/i.test(r))).toBe(true);
+  });
+
+  it("treats a single attendance with no lastAttendedAt as New", () => {
+    const result = computeRelationshipHealth(
+      {
+        eventCount: 1,
+        lastAttendedAt: null,
+        firstAttendedAt: null,
+        tags: [],
+        lastOutreachAt: null,
+      },
+      NOW
+    );
+    expect(result.status).toBe("New");
+    expect(result.daysSinceLastAttended).toBeNull();
+  });
+
+  it("uses the default cadence when firstAttendedAt is missing for multi-event guests", () => {
+    const result = computeRelationshipHealth(
+      {
+        eventCount: 3,
+        firstAttendedAt: null,
+        lastAttendedAt: new Date("2026-07-01T00:00:00Z").toISOString(),
+        tags: [],
+        lastOutreachAt: null,
+      },
+      NOW
+    );
+    expect(result.status).toBe("Steady");
+    expect(result.expectedGapDays).toBe(60);
+    expect(result.reasons.some((r) => /default 60-day cadence/i.test(r))).toBe(true);
+  });
+
+  it("uses the default cadence when first and last attendance are the same day", () => {
+    const same = new Date("2026-06-01T00:00:00Z").toISOString();
+    const result = computeRelationshipHealth(
+      {
+        eventCount: 3,
+        firstAttendedAt: same,
+        lastAttendedAt: same,
+        tags: [],
+        lastOutreachAt: null,
+      },
+      NOW
+    );
+    expect(result.expectedGapDays).toBe(60);
+    expect(result.reasons.some((r) => /default 60-day cadence/i.test(r))).toBe(true);
+  });
+
+  it("clamps personalized cadence to a 14-day minimum", () => {
+    // 3 bashes over 10 days → raw gap 5, clamped to 14
+    const result = computeRelationshipHealth(
+      {
+        eventCount: 3,
+        firstAttendedAt: new Date("2026-07-01T00:00:00Z").toISOString(),
+        lastAttendedAt: new Date("2026-07-11T00:00:00Z").toISOString(),
+        tags: [],
+        lastOutreachAt: null,
+      },
+      NOW
+    );
+    expect(result.expectedGapDays).toBe(14);
+    expect(result.status).toBe("Steady");
+  });
+
+  it("does not escalate a Steady VIP", () => {
+    const result = computeRelationshipHealth(
+      {
+        eventCount: 5,
+        firstAttendedAt: new Date("2026-01-13T00:00:00Z").toISOString(),
+        lastAttendedAt: new Date("2026-06-23T00:00:00Z").toISOString(),
+        tags: [" VIP "],
+        lastOutreachAt: null,
+      },
+      NOW
+    );
+    expect(result.status).toBe("Steady");
+    expect(result.reasons.some((r) => /vip/i.test(r))).toBe(false);
+  });
+
+  it("notes missing outreach for Cooling and AtRisk without lastOutreachAt", () => {
+    const cooling = computeRelationshipHealth(
+      {
+        eventCount: 1,
+        lastAttendedAt: new Date("2026-04-01T00:00:00Z").toISOString(),
+        firstAttendedAt: new Date("2026-04-01T00:00:00Z").toISOString(),
+        tags: [],
+        lastOutreachAt: null,
+      },
+      NOW
+    );
+    expect(cooling.status).toBe("Cooling");
+    expect(cooling.reasons.some((r) => /no outreach/i.test(r))).toBe(true);
+
+    const atRisk = computeRelationshipHealth(
+      {
+        eventCount: 1,
+        lastAttendedAt: new Date("2025-01-01T00:00:00Z").toISOString(),
+        firstAttendedAt: new Date("2025-01-01T00:00:00Z").toISOString(),
+        tags: [],
+        lastOutreachAt: null,
+      },
+      NOW
+    );
+    expect(atRisk.status).toBe("AtRisk");
+    expect(atRisk.reasons.some((r) => /no outreach/i.test(r))).toBe(true);
+  });
+
+  it("uses singular day wording for a one-day gap", () => {
+    const result = computeRelationshipHealth(
+      {
+        eventCount: 1,
+        lastAttendedAt: new Date("2026-07-12T00:00:00Z").toISOString(),
+        firstAttendedAt: new Date("2026-07-12T00:00:00Z").toISOString(),
+        tags: [],
+        lastOutreachAt: new Date("2026-07-12T00:00:00Z").toISOString(),
+      },
+      NOW
+    );
+    expect(result.reasons.some((r) => r.includes("1 day ago"))).toBe(true);
+    expect(result.reasons.some((r) => r.includes("1 days ago"))).toBe(false);
+  });
+
+  it("exposes human labels for every status", () => {
+    expect(RELATIONSHIP_HEALTH_LABELS.New).toBe("New");
+    expect(RELATIONSHIP_HEALTH_LABELS.Steady).toBe("Steady");
+    expect(RELATIONSHIP_HEALTH_LABELS.Cooling).toBe("Cooling");
+    expect(RELATIONSHIP_HEALTH_LABELS.AtRisk).toBe("At risk");
+  });
+
+  it("treats multi-event guests with no lastAttendedAt as Steady (ratio 0)", () => {
+    const result = computeRelationshipHealth(
+      {
+        eventCount: 2,
+        firstAttendedAt: new Date("2026-01-01T00:00:00Z").toISOString(),
+        lastAttendedAt: null,
+        tags: [],
+        lastOutreachAt: null,
+      },
+      NOW
+    );
+    expect(result.status).toBe("Steady");
+    expect(result.daysSinceLastAttended).toBeNull();
+  });
+
+  it("uses exact day boundaries for the single-attendance windows", () => {
+    const stillNew = computeRelationshipHealth(
+      {
+        eventCount: 1,
+        lastAttendedAt: new Date("2026-05-29T00:00:00Z").toISOString(), // 45 days before NOW
+        firstAttendedAt: new Date("2026-05-29T00:00:00Z").toISOString(),
+        tags: [],
+        lastOutreachAt: null,
+      },
+      NOW
+    );
+    expect(stillNew.status).toBe("New");
+
+    const coolingEdge = computeRelationshipHealth(
+      {
+        eventCount: 1,
+        lastAttendedAt: new Date("2026-05-28T00:00:00Z").toISOString(), // 46 days
+        firstAttendedAt: new Date("2026-05-28T00:00:00Z").toISOString(),
+        tags: [],
+        lastOutreachAt: null,
+      },
+      NOW
+    );
+    expect(coolingEdge.status).toBe("Cooling");
+
+    const stillCooling = computeRelationshipHealth(
+      {
+        eventCount: 1,
+        lastAttendedAt: new Date("2026-03-15T00:00:00Z").toISOString(), // 120 days
+        firstAttendedAt: new Date("2026-03-15T00:00:00Z").toISOString(),
+        tags: [],
+        lastOutreachAt: null,
+      },
+      NOW
+    );
+    expect(stillCooling.status).toBe("Cooling");
+
+    const atRiskEdge = computeRelationshipHealth(
+      {
+        eventCount: 1,
+        lastAttendedAt: new Date("2026-03-14T00:00:00Z").toISOString(), // 121 days
+        firstAttendedAt: new Date("2026-03-14T00:00:00Z").toISOString(),
+        tags: [],
+        lastOutreachAt: null,
+      },
+      NOW
+    );
+    expect(atRiskEdge.status).toBe("AtRisk");
+  });
+
+  it("keeps Steady at the 1.5x cadence ratio and Cooling just above it", () => {
+    // span Jan14→May14 = 120 days over 3 gaps → expectedGapDays = 40
+    const base = {
+      eventCount: 4,
+      firstAttendedAt: new Date("2026-01-14T00:00:00Z").toISOString(),
+      tags: [] as string[],
+      lastOutreachAt: null,
+    };
+    // daysSince (NOW=Jul13) = 60 → ratio exactly 1.5 → Steady
+    const steady = computeRelationshipHealth(
+      { ...base, lastAttendedAt: new Date("2026-05-14T00:00:00Z").toISOString() },
+      NOW
+    );
+    expect(steady.expectedGapDays).toBe(40);
+    expect(steady.status).toBe("Steady");
+
+    // one day later lapse → daysSince = 61, span drops to 119 (still rounds to
+    // the same 40-day gap) → ratio just above 1.5 → Cooling
+    const cooling = computeRelationshipHealth(
+      { ...base, lastAttendedAt: new Date("2026-05-13T00:00:00Z").toISOString() },
+      NOW
+    );
+    expect(cooling.status).toBe("Cooling");
+  });
+
+  it("does not re-escalate an AtRisk VIP (already past Cooling)", () => {
+    const result = computeRelationshipHealth(
+      {
+        eventCount: 1,
+        lastAttendedAt: new Date("2025-01-01T00:00:00Z").toISOString(),
+        firstAttendedAt: new Date("2025-01-01T00:00:00Z").toISOString(),
+        tags: ["vip"],
+        lastOutreachAt: null,
+      },
+      NOW
+    );
+    expect(result.status).toBe("AtRisk");
+    expect(result.reasons.some((r) => /escalated from Cooling/i.test(r))).toBe(false);
+  });
+});

package/src/appleIapProducts.ts

@@ -0,0 +1,203 @@
+/**
+ * Apple App Store product catalog for iOS IAP.
+ * Product IDs must match App Store Connect exactly.
+ *
+ * Stripe remains the billing path on web/Android. On iOS native, these products
+ * unlock the same entitlements Stripe grants for digital goods (Guideline 3.1.1).
+ * Event tickets and real-world service bookings stay on Stripe (3.1.3(e)).
+ */
+import { BashPassTier, MembershipTier } from "@prisma/client";
+
+import { FEATURE_BOOST_DURATIONS, MEMBERSHIP_PRICING } from "./membershipDefinitions.js";
+import { SERVICE_SUBSCRIPTION_TIERS } from "./definitions.js";
+
+export type AppleIapProductFamily =
+  | "membership"
+  | "listing"
+  | "bashpass"
+  | "feature_boost";
+
+export type AppleMembershipInterval = "monthly" | "yearly" | "lifetime";
+
+export type AppleListingTier = "Ally" | "Partner" | "Patron";
+
+export interface AppleMembershipProduct {
+  productId: string;
+  family: "membership";
+  tier: Exclude<MembershipTier, "Basic" | "Guest">;
+  interval: AppleMembershipInterval;
+  /** Reference price in cents (ASC must match; Apple may regionalize). */
+  priceCents: number;
+}
+
+export interface AppleListingProduct {
+  productId: string;
+  family: "listing";
+  tier: AppleListingTier;
+  interval: "monthly";
+  priceCents: number;
+}
+
+export interface AppleBashPassProduct {
+  productId: string;
+  family: "bashpass";
+  tier: BashPassTier;
+  interval: "monthly";
+  priceCents: number;
+}
+
+export interface AppleFeatureBoostProduct {
+  productId: string;
+  family: "feature_boost";
+  durationId: (typeof FEATURE_BOOST_DURATIONS)[number]["id"];
+  hours: number;
+  priceCents: number;
+}
+
+export type AppleIapProduct =
+  | AppleMembershipProduct
+  | AppleListingProduct
+  | AppleBashPassProduct
+  | AppleFeatureBoostProduct;
+
+const MEMBERSHIP_TIERS = [
+  MembershipTier.Premium,
+  MembershipTier.Pro,
+  MembershipTier.Elite,
+  MembershipTier.Legend,
+] as const;
+
+function membershipProductId(
+  tier: (typeof MEMBERSHIP_TIERS)[number],
+  interval: AppleMembershipInterval
+): string {
+  return `community.bash.us.membership.${tier.toLowerCase()}.${interval}`;
+}
+
+/** Lifetime price heuristic: 10× yearly (matches existing Stripe lifetime helpers). */
+function lifetimePriceCents(tier: (typeof MEMBERSHIP_TIERS)[number]): number {
+  return MEMBERSHIP_PRICING[tier].yearly * 10;
+}
+
+export const APPLE_MEMBERSHIP_PRODUCTS: readonly AppleMembershipProduct[] =
+  MEMBERSHIP_TIERS.flatMap((tier) => {
+    const monthly: AppleMembershipProduct = {
+      productId: membershipProductId(tier, "monthly"),
+      family: "membership",
+      tier,
+      interval: "monthly",
+      priceCents: MEMBERSHIP_PRICING[tier].monthly,
+    };
+    const yearly: AppleMembershipProduct = {
+      productId: membershipProductId(tier, "yearly"),
+      family: "membership",
+      tier,
+      interval: "yearly",
+      priceCents: MEMBERSHIP_PRICING[tier].yearly,
+    };
+    const lifetime: AppleMembershipProduct = {
+      productId: membershipProductId(tier, "lifetime"),
+      family: "membership",
+      tier,
+      interval: "lifetime",
+      priceCents: lifetimePriceCents(tier),
+    };
+    return [monthly, yearly, lifetime];
+  });
+
+/** Listing seat subscriptions — dollars in SERVICE_SUBSCRIPTION_TIERS → cents. */
+export const APPLE_LISTING_PRODUCTS: readonly AppleListingProduct[] = (
+  ["Ally", "Partner", "Patron"] as const
+).map((tier) => ({
+  productId: `community.bash.us.listing.${tier.toLowerCase()}.monthly`,
+  family: "listing" as const,
+  tier,
+  interval: "monthly" as const,
+  priceCents: Math.round(SERVICE_SUBSCRIPTION_TIERS[tier].price * 100),
+}));
+
+/**
+ * Standalone BashPass monthly prices (cents). Mirror Stripe catalog when ASC is created.
+ * LITE $19.99 · STANDARD $49.99 · UNLIMITED $99.99
+ */
+export const APPLE_BASHPASS_PRICE_CENTS: Record<BashPassTier, number> = {
+  [BashPassTier.LITE]: 1999,
+  [BashPassTier.STANDARD]: 4999,
+  [BashPassTier.UNLIMITED]: 9999,
+};
+
+export const APPLE_BASHPASS_PRODUCTS: readonly AppleBashPassProduct[] = (
+  Object.values(BashPassTier) as BashPassTier[]
+).map((tier) => ({
+  productId: `community.bash.us.bashpass.${tier.toLowerCase()}.monthly`,
+  family: "bashpass" as const,
+  tier,
+  interval: "monthly" as const,
+  priceCents: APPLE_BASHPASS_PRICE_CENTS[tier],
+}));
+
+export const APPLE_FEATURE_BOOST_PRODUCTS: readonly AppleFeatureBoostProduct[] =
+  FEATURE_BOOST_DURATIONS.map((d) => ({
+    productId: `community.bash.us.boost.${d.id}`,
+    family: "feature_boost" as const,
+    durationId: d.id,
+    hours: d.hours,
+    priceCents: d.priceCents,
+  }));
+
+export const APPLE_IAP_PRODUCTS: readonly AppleIapProduct[] = [
+  ...APPLE_MEMBERSHIP_PRODUCTS,
+  ...APPLE_LISTING_PRODUCTS,
+  ...APPLE_BASHPASS_PRODUCTS,
+  ...APPLE_FEATURE_BOOST_PRODUCTS,
+];
+
+const BY_PRODUCT_ID: ReadonlyMap<string, AppleIapProduct> = new Map(
+  APPLE_IAP_PRODUCTS.map((p) => [p.productId, p])
+);
+
+export function getAppleIapProduct(productId: string): AppleIapProduct | undefined {
+  return BY_PRODUCT_ID.get(productId);
+}
+
+export function isAppleIapProductId(productId: string): boolean {
+  return BY_PRODUCT_ID.has(productId);
+}
+
+export function listAppleIapProductIds(family?: AppleIapProductFamily): string[] {
+  if (!family) {
+    return APPLE_IAP_PRODUCTS.map((p) => p.productId);
+  }
+  return APPLE_IAP_PRODUCTS.filter((p) => p.family === family).map((p) => p.productId);
+}
+
+export function findAppleMembershipProduct(
+  tier: Exclude<MembershipTier, "Basic" | "Guest">,
+  interval: AppleMembershipInterval
+): AppleMembershipProduct | undefined {
+  return APPLE_MEMBERSHIP_PRODUCTS.find(
+    (p) => p.tier === tier && p.interval === interval
+  );
+}
+
+export function findAppleListingProduct(
+  tier: AppleListingTier
+): AppleListingProduct | undefined {
+  return APPLE_LISTING_PRODUCTS.find((p) => p.tier === tier);
+}
+
+export function findAppleBashPassProduct(
+  tier: BashPassTier
+): AppleBashPassProduct | undefined {
+  return APPLE_BASHPASS_PRODUCTS.find((p) => p.tier === tier);
+}
+
+export function findAppleFeatureBoostProduct(
+  durationId: (typeof FEATURE_BOOST_DURATIONS)[number]["id"]
+): AppleFeatureBoostProduct | undefined {
+  return APPLE_FEATURE_BOOST_PRODUCTS.find((p) => p.durationId === durationId);
+}
+
+/** Apple subscription management deep link (Settings → Subscriptions). */
+export const APPLE_SUBSCRIPTIONS_MANAGEMENT_URL =
+  "https://apps.apple.com/account/subscriptions";

package/src/definitions.ts

@@ -909,6 +909,8 @@ export enum ApiErrorType {
   payment_intent_creation_failed,
   /** Host requires waiver / custom terms; buyer did not attest acceptance */
   EventWaiverNotAccepted,
+  /** Bash is not Published/PreSale — ticket purchase and checkout creation are blocked */
+  EventNotAcceptingPurchases,
 }
 
 export type ErrorDataType = Record<RecordKey, unknown>;

package/src/extendedSchemas.ts

@@ -417,7 +417,18 @@ export interface BashEventExt extends Override<
     | "isAutoApprovable"
     | "merchandiseItems"
   >,
-  { icebreakerPrompt: string | null }
+  {
+    icebreakerPrompt: string | null;
+    /** Free-text cancellation / refund policy shown at checkout and on tickets. */
+    cancellationPolicy?: string | null;
+    /** When true (default), cancelling auto-refunds paid ticket holders. */
+    refundsGuaranteedOnCancellation?: boolean;
+    /** Host may postpone after tickets exist if enabled before first sale. */
+    postponementAllowed?: boolean;
+    isPostponed?: boolean;
+    postponedAt?: Date | string | null;
+    postponeResponseDeadline?: Date | string | null;
+  }
 > {
   /** Host-curated merch catalog (wizard); stored as JSON on BashEvent. Null = no merch configured. */
   merchandiseItems: BashEventMerchCatalog | null;
@@ -467,6 +478,20 @@ export interface BashEventExt extends Override<
   myPublicRsvpStatus?: string | null;
   /** Host approval queue status for the viewer's PublicBashRsvp (Pending | Approved | Denied) */
   myPublicRsvpApprovalStatus?: string | null;
+  /** When the viewer last kept/declined after a postponement (PublicBashRsvp) */
+  myPublicRsvpPostponeRespondedAt?: Date | string | null;
+  /**
+   * Creator-view only when `isPostponed`: keep / decline / pending counts for
+   * active tickets and approved Going RSVPs.
+   */
+  postponeResponseSummary?: {
+    ticketsKept: number;
+    ticketsDeclined: number;
+    ticketsPending: number;
+    rsvpsKept: number;
+    rsvpsDeclined: number;
+    rsvpsPending: number;
+  };
   /** GET /event/:id and GET /public-event/:id (authenticated) when accessScreeningEnabled — viewer's latest access request status */
   myAccessRequestStatus?: "None" | "Pending" | "Approved" | "Denied" | null;
   /** GET /event/:id when status=Idea — viewer's IdeaInterest row (matched by email) */
@@ -482,6 +507,8 @@ export interface BashEventExt extends Override<
   // Event page visual customisation (stored as scalar columns on BashEvent)
   backgroundImage: string | null;
   themeColor: string | null;
+  /** Soft blur on theme photo backgrounds; hosts may turn off for a sharp image. */
+  backgroundBlurEnabled: boolean;
   /**
    * Computed at request time from the host Organization's nonprofit verification.
    * Drives the buyer-facing fee breakdown ("Nonprofit — no Bash platform fee").
@@ -1585,6 +1612,8 @@ export type TicketFlexible = Ticket & {
     TicketTransferInvite,
     "status" | "expiresAt" | "token" | "toEmail" | "toUserId"
   > | null;
+  /** Present after schema publish; set when guest keeps/declines a postponement. */
+  postponeRespondedAt?: Date | string | null;
 };
 
 export interface CheckoutExt extends Checkout {