@bash-app/bash-common 30.260.0 → 30.262.0

package/src/utils/guestSurface.ts

@@ -0,0 +1,315 @@
+/**
+ * Curated guest visibility — shared policy resolver for API + bash-app.
+ * Three layers compose: event teaser policy, per-guest visibility, viewer roster depth.
+ */
+
+import type { PublicTeaserUser } from "../extendedSchemas.js";
+
+export type AttendeeDisplayMode =
+  | "All"
+  | "CountOnly"
+  | "NetworkOnly"
+  | "Hidden";
+
+export type AttendeeVisibility =
+  | "Visible"
+  | "Hidden"
+  | "FeaturedPending"
+  | "FeaturedInvited";
+
+export type GuestListDepth = "None" | "Partial" | "Full";
+
+export type { PublicTeaserUser };
+
+export type NetworkOverlapPayload = {
+  connections: PublicTeaserUser[];
+  contacts: PublicTeaserUser[];
+  customLists: Array<{
+    listId: string;
+    listName: string;
+    users: PublicTeaserUser[];
+  }>;
+};
+
+export type GuestSurfacePayload = {
+  count: { totalTickets: number; visibleAttendees: number };
+  preview: PublicTeaserUser[];
+  featured: PublicTeaserUser[];
+  featuredHeadline: string | null;
+  network: NetworkOverlapPayload | null;
+  upsell: { hasDeeperTiers: boolean; cheapestTierName?: string } | null;
+  roster?: {
+    users: PublicTeaserUser[];
+    totalVisible: number;
+    hasMore: boolean;
+    cursor?: string;
+  };
+  viewer: { rosterDepth: GuestListDepth; isHost: boolean };
+  policy: { effectiveMode: AttendeeDisplayMode };
+  /** Host-only: user IDs awaiting spotlight approval (guest-initiated) */
+  pendingFeaturedUserIds?: string[];
+  /** Host-only: user IDs with host-initiated featured invite pending accept */
+  pendingFeaturedInviteUserIds?: string[];
+  /** Viewer-only: pending featured invite for the authenticated viewer */
+  viewerFeaturedInvite?: {
+    bashEventId: string;
+    bashTitle: string;
+    hostName?: string;
+  } | null;
+  /** Host-only: per-guest visibility for roster management */
+  attendeeVisibilityByUserId?: Record<string, AttendeeVisibility>;
+  /** Event has public guest list enabled on bash detail */
+  attendeeListPublic?: boolean;
+};
+
+export type AttendeeRosterMeta = {
+  depth: GuestListDepth;
+  totalVisible?: number;
+  hasMore?: boolean;
+  cursor?: string;
+};
+
+export type EventModeInput = {
+  attendeeDisplayMode?: string | null;
+  showAttendees?: boolean | null;
+};
+
+export type GuestSurfacePolicyInput = {
+  eventMode: AttendeeDisplayMode;
+  isHost: boolean;
+  isAuthenticated: boolean;
+  viewerRosterDepth: GuestListDepth;
+};
+
+export type GuestSurfacePolicy = {
+  showCount: boolean;
+  showPreviewAvatars: boolean;
+  showFeatured: boolean;
+  showNetworkSlice: boolean;
+  rosterDepth: GuestListDepth;
+  previewLimit: number;
+  apiPreviewLimit: number;
+  effectiveMode: AttendeeDisplayMode;
+};
+
+const DEPTH_RANK: Record<GuestListDepth, number> = {
+  None: 0,
+  Partial: 1,
+  Full: 2,
+};
+
+/** Legacy showAttendees=false → Hidden; otherwise honour attendeeDisplayMode string. */
+export function resolveEffectiveEventMode(
+  event: EventModeInput
+): AttendeeDisplayMode {
+  const raw = event.attendeeDisplayMode;
+  if (raw === "CountOnly") return "CountOnly";
+  if (raw === "NetworkOnly") return "NetworkOnly";
+  if (raw === "Hidden") return "Hidden";
+  if (event.showAttendees === false) return "Hidden";
+  return "All";
+}
+
+export function compareGuestListDepth(
+  a: GuestListDepth,
+  b: GuestListDepth
+): number {
+  return DEPTH_RANK[a] - DEPTH_RANK[b];
+}
+
+export function maxGuestListDepth(
+  ...depths: GuestListDepth[]
+): GuestListDepth {
+  if (depths.length === 0) return "None";
+  return depths.reduce((max, d) =>
+    compareGuestListDepth(d, max) > 0 ? d : max
+  );
+}
+
+/** Cap viewer tier depth by event mode for non-hosts. */
+export function capRosterDepthForEventMode(
+  viewerDepth: GuestListDepth,
+  eventMode: AttendeeDisplayMode,
+  isHost: boolean
+): GuestListDepth {
+  if (isHost) return "Full";
+  if (eventMode === "Hidden") return "None";
+  if (eventMode === "NetworkOnly") return "None";
+  return viewerDepth;
+}
+
+/** Whether the viewer may fetch the full host-style roster endpoint. */
+export function viewerMayFetchFullRoster(input: {
+  isHost: boolean;
+  viewerRosterDepth: GuestListDepth;
+}): boolean {
+  if (input.isHost) return true;
+  return compareGuestListDepth(input.viewerRosterDepth, "Partial") >= 0;
+}
+
+/** Public bash-detail teaser policy (Layer 1 + viewer depth cap). */
+export function resolveGuestSurfacePolicy(
+  input: GuestSurfacePolicyInput
+): GuestSurfacePolicy {
+  const { eventMode, isHost, isAuthenticated, viewerRosterDepth } = input;
+  const effectiveDepth = capRosterDepthForEventMode(
+    viewerRosterDepth,
+    eventMode,
+    isHost
+  );
+
+  if (eventMode === "Hidden" && !isHost) {
+    return {
+      showCount: false,
+      showPreviewAvatars: false,
+      showFeatured: false,
+      showNetworkSlice: false,
+      rosterDepth: "None",
+      previewLimit: 4,
+      apiPreviewLimit: 10,
+      effectiveMode: eventMode,
+    };
+  }
+
+  if (eventMode === "CountOnly" && !isHost) {
+    return {
+      showCount: true,
+      showPreviewAvatars: false,
+      showFeatured: false,
+      showNetworkSlice: isAuthenticated,
+      rosterDepth: effectiveDepth,
+      previewLimit: 4,
+      apiPreviewLimit: 10,
+      effectiveMode: eventMode,
+    };
+  }
+
+  const showCount = true;
+  const showPreviewAvatars =
+    eventMode === "All" && !isHost
+      ? true
+      : eventMode === "All" && isHost
+        ? true
+        : false;
+  const showFeatured =
+    (eventMode === "All" || isHost) && eventMode !== "CountOnly";
+  const showNetworkSlice =
+    isAuthenticated &&
+    (eventMode === "All" ||
+      eventMode === "CountOnly" ||
+      eventMode === "NetworkOnly" ||
+      isHost);
+
+  return {
+    showCount,
+    showPreviewAvatars:
+      showPreviewAvatars &&
+      eventMode !== "CountOnly" &&
+      eventMode !== "NetworkOnly",
+    showFeatured: showFeatured && eventMode !== "NetworkOnly",
+    showNetworkSlice,
+    rosterDepth: effectiveDepth,
+    previewLimit: 4,
+    apiPreviewLimit: 10,
+    effectiveMode: eventMode,
+  };
+}
+
+export type PreviewAttendeeRow = {
+  userId: string;
+  paidOn?: Date | string | null;
+  checkedInAt?: Date | string | null;
+};
+
+/** Featured first, then most recent activity, then stable userId. */
+export function orderPreviewAttendeeIds(
+  rows: PreviewAttendeeRow[],
+  featuredUserIds: string[],
+  limit: number
+): string[] {
+  const featuredSet = new Set(featuredUserIds);
+  const byUser = new Map<string, PreviewAttendeeRow>();
+  for (const row of rows) {
+    if (!row.userId) continue;
+    const existing = byUser.get(row.userId);
+    if (!existing) {
+      byUser.set(row.userId, row);
+      continue;
+    }
+    const existingTs = activityTimestamp(existing);
+    const rowTs = activityTimestamp(row);
+    if (rowTs > existingTs) byUser.set(row.userId, row);
+  }
+
+  const featuredOrdered = featuredUserIds.filter((id) => byUser.has(id));
+  const rest = [...byUser.entries()]
+    .filter(([id]) => !featuredSet.has(id))
+    .sort(([, a], [, b]) => {
+      const diff = activityTimestamp(b) - activityTimestamp(a);
+      if (diff !== 0) return diff;
+      return a.userId.localeCompare(b.userId);
+    })
+    .map(([id]) => id);
+
+  return [...featuredOrdered, ...rest].slice(0, limit);
+}
+
+function activityTimestamp(row: PreviewAttendeeRow): number {
+  const paid =
+    row.paidOn != null ? new Date(row.paidOn as string | Date).getTime() : 0;
+  const checked =
+    row.checkedInAt != null
+      ? new Date(row.checkedInAt as string | Date).getTime()
+      : 0;
+  return Math.max(paid, checked);
+}
+
+export function filterHiddenVisibilityUserIds(
+  userIds: string[],
+  visibilityByUserId: Map<string, AttendeeVisibility>,
+  isHost: boolean
+): string[] {
+  if (isHost) return userIds;
+  return userIds.filter((id) => {
+    const v = visibilityByUserId.get(id) ?? "Visible";
+    return v === "Visible" || v === "FeaturedPending";
+    // FeaturedInvited is hidden until the guest accepts
+  });
+}
+
+export function filterBlockedUserIds(
+  userIds: string[],
+  blockedIds: Set<string>
+): string[] {
+  return userIds.filter((id) => !blockedIds.has(id));
+}
+
+export function guestListDepthFromTierField(
+  value: string | null | undefined
+): GuestListDepth {
+  if (value === "Partial" || value === "Full") return value;
+  return "None";
+}
+
+export function computeUpsellFromTiers(
+  tiers: Array<{ guestListDepth?: string | null; title?: string | null; price?: number | null }>,
+  viewerDepth: GuestListDepth
+): GuestSurfacePayload["upsell"] {
+  const deeper = tiers.filter(
+    (t) =>
+      compareGuestListDepth(
+        guestListDepthFromTierField(t.guestListDepth),
+        "None"
+      ) > 0
+  );
+  if (deeper.length === 0 || compareGuestListDepth(viewerDepth, "Partial") >= 0) {
+    return null;
+  }
+  const sorted = [...deeper].sort(
+    (a, b) => (a.price ?? 0) - (b.price ?? 0)
+  );
+  return {
+    hasDeeperTiers: true,
+    cheapestTierName: sorted[0]?.title ?? undefined,
+  };
+}

package/src/utils/promotionBlastUtils.ts

@@ -0,0 +1,127 @@
+/**
+ * Promotion Blast — on-site partner promos (time-boxed + geofence).
+ */
+
+export type PromotionBlastPackageTierId = "starter" | "standard" | "premium";
+
+export type PromotionBlastTriggerTypeId = "TIME_BOXED" | "GEOFENCE";
+
+export interface PromotionBlastPackageTerms {
+  tierId: PromotionBlastPackageTierId;
+  maxBlasts: number;
+  maxPushRecipients?: number | null;
+  maxRadiusFeet: number;
+  allowedTriggerTypes: PromotionBlastTriggerTypeId[];
+  hostAccessFeeCents: number;
+  bashPlatformFeeCents: number;
+  templateId?: string | null;
+}
+
+/** Minutes before event start when partners may activate blasts. */
+export const PROMOTION_BLAST_EVENT_WINDOW_BEFORE_MINUTES = 30;
+
+/** Minutes after event end when partners may still activate. */
+export const PROMOTION_BLAST_EVENT_WINDOW_AFTER_MINUTES = 30;
+
+/** Max concurrently live partner promos per event. */
+export const PROMOTION_BLAST_MAX_LIVE_PER_EVENT = 5;
+
+/** Max promotional pushes per attendee per event (all partners). */
+export const PROMOTION_BLAST_MAX_PUSHES_PER_USER_PER_EVENT = 3;
+
+/** Min minutes between promo pushes to same user at same event. */
+export const PROMOTION_BLAST_MIN_PUSH_INTERVAL_MINUTES = 15;
+
+export const PROMOTION_BLAST_HEADLINE_MAX_LENGTH = 80;
+export const PROMOTION_BLAST_BODY_MAX_LENGTH = 280;
+export const PROMOTION_BLAST_CTA_MAX_LENGTH = 40;
+
+export const PROMOTION_BLAST_DURATION_PRESETS_MINUTES = [15, 30, 60] as const;
+export const PROMOTION_BLAST_RADIUS_PRESETS_FEET = [100, 200, 500] as const;
+
+export const PROMOTION_BLAST_PACKAGES: Record<
+  PromotionBlastPackageTierId,
+  Omit<PromotionBlastPackageTerms, "hostAccessFeeCents" | "templateId">
+> = {
+  starter: {
+    tierId: "starter",
+    maxBlasts: 1,
+    maxPushRecipients: null,
+    maxRadiusFeet: 200,
+    allowedTriggerTypes: ["TIME_BOXED"],
+    bashPlatformFeeCents: 500,
+  },
+  standard: {
+    tierId: "standard",
+    maxBlasts: 3,
+    maxPushRecipients: null,
+    maxRadiusFeet: 500,
+    allowedTriggerTypes: ["TIME_BOXED", "GEOFENCE"],
+    bashPlatformFeeCents: 1200,
+  },
+  premium: {
+    tierId: "premium",
+    maxBlasts: 999,
+    maxPushRecipients: null,
+    maxRadiusFeet: 500,
+    allowedTriggerTypes: ["TIME_BOXED", "GEOFENCE"],
+    bashPlatformFeeCents: 2500,
+  },
+};
+
+export function promotionBlastPackageForTier(
+  tierId: PromotionBlastPackageTierId,
+  hostAccessFeeCents: number,
+  templateId?: string | null
+): PromotionBlastPackageTerms {
+  const base = PROMOTION_BLAST_PACKAGES[tierId];
+  return {
+    ...base,
+    hostAccessFeeCents,
+    templateId: templateId ?? null,
+  };
+}
+
+export function promotionBlastPackageTotalCents(pkg: PromotionBlastPackageTerms): number {
+  return pkg.hostAccessFeeCents + pkg.bashPlatformFeeCents;
+}
+
+export function promotionBlastPackageLabel(tierId: PromotionBlastPackageTierId): string {
+  switch (tierId) {
+    case "starter":
+      return "Starter — 1 time-boxed blast";
+    case "standard":
+      return "Standard — 3 blasts + geofence";
+    case "premium":
+      return "Premium — unlimited blasts + geofence";
+    default:
+      return tierId;
+  }
+}
+
+export function isWithinPromotionBlastEventWindow(
+  eventStart: Date,
+  eventEnd: Date | null | undefined,
+  now: Date = new Date()
+): boolean {
+  const windowStart = new Date(eventStart);
+  windowStart.setMinutes(windowStart.getMinutes() - PROMOTION_BLAST_EVENT_WINDOW_BEFORE_MINUTES);
+  const windowEnd = eventEnd
+    ? new Date(eventEnd)
+    : new Date(eventStart.getTime() + 4 * 60 * 60 * 1000);
+  windowEnd.setMinutes(windowEnd.getMinutes() + PROMOTION_BLAST_EVENT_WINDOW_AFTER_MINUTES);
+  return now >= windowStart && now <= windowEnd;
+}
+
+export function generatePromotionBlastConfirmationCode(): string {
+  const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+  let code = "";
+  for (let i = 0; i < 6; i++) {
+    code += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return code;
+}
+
+export function promotionBlastDeepLinkPath(bashEventId: string, blastId: string): string {
+  return `/bash/${encodeURIComponent(bashEventId)}?tab=promotions&blast=${encodeURIComponent(blastId)}`;
+}

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

@@ -0,0 +1,102 @@
+import {
+  calcLegacyRateEstimateCents,
+  computeBashEventDurationHours,
+  getDefaultOfferAmountCents,
+  isBulkHostOfferEligible,
+} from "../defaultOfferAmountUtils.js";
+
+describe("calcLegacyRateEstimateCents", () => {
+  it("uses flat rate when set", () => {
+    expect(
+      calcLegacyRateEstimateCents({ flatRateCents: 50_000 }, 4)
+    ).toBe(50_000);
+  });
+
+  it("uses daily rate for 8+ hour events", () => {
+    expect(
+      calcLegacyRateEstimateCents(
+        { hourlyRateCents: 15_000, dailyRateCents: 50_000 },
+        8
+      )
+    ).toBe(50_000);
+  });
+
+  it("uses hourly × duration for shorter events", () => {
+    expect(
+      calcLegacyRateEstimateCents(
+        { hourlyRateCents: 15_000, dailyRateCents: 50_000 },
+        4
+      )
+    ).toBe(60_000);
+  });
+});
+
+describe("computeBashEventDurationHours", () => {
+  it("returns hours between start and end", () => {
+    expect(
+      computeBashEventDurationHours(
+        "2026-06-01T18:00:00.000Z",
+        "2026-06-01T22:00:00.000Z"
+      )
+    ).toBe(4);
+  });
+
+  it("defaults to 1 when dates missing", () => {
+    expect(computeBashEventDurationHours(null, null)).toBe(1);
+  });
+});
+
+describe("getDefaultOfferAmountCents", () => {
+  it("prefers unified HOURLY model with duration", () => {
+    expect(
+      getDefaultOfferAmountCents({
+        service: {
+          entertainmentService: {
+            pricingModel: "HOURLY",
+            baseRateCents: 20_000,
+          },
+        },
+        durationHours: 3,
+      })
+    ).toBe(60_000);
+  });
+
+  it("falls back to legacy general rates", () => {
+    expect(
+      getDefaultOfferAmountCents({
+        service: {
+          serviceRatesAssociation: {
+            serviceGeneralRates: { dailyRateCents: 75_000 },
+          },
+        },
+        durationHours: 10,
+      })
+    ).toBe(75_000);
+  });
+
+  it("computes PER_ATTENDEE from expected guests", () => {
+    expect(
+      getDefaultOfferAmountCents({
+        service: {
+          eventService: {
+            pricingModel: "PER_ATTENDEE",
+            baseRateCents: 500,
+          },
+        },
+        durationHours: 4,
+        expectedAttendees: 100,
+      })
+    ).toBe(50_000);
+  });
+});
+
+describe("isBulkHostOfferEligible", () => {
+  it("rejects participation-fee services", () => {
+    expect(isBulkHostOfferEligible(50_000, true)).toBe(false);
+  });
+
+  it("requires a positive amount", () => {
+    expect(isBulkHostOfferEligible(0, false)).toBe(false);
+    expect(isBulkHostOfferEligible(25_000, false)).toBe(true);
+  });
+});

package/src/utils/service/defaultOfferAmountUtils.ts

@@ -0,0 +1,170 @@
+/**
+ * Deterministic default offer amount for a service + bash context.
+ * Keeps service cards, budget bar, SendOfferSheet prefill, and bulk offers aligned.
+ */
+import {
+  computeOfferComparisonBands,
+  type OfferComparisonInput,
+} from "./offerComparisonUtils.js";
+import {
+  resolveUnifiedPricingBlock,
+  type UnifiedPricingSourceCandidates,
+} from "./unifiedPricingResolver.js";
+import { SERVICE_DAILY_RATE_HOURS_MIN } from "./serviceRateUtils.js";
+
+export { SERVICE_DAILY_RATE_HOURS_MIN };
+
+export interface LegacyGeneralRatesShape {
+  flatRateCents?: number | null;
+  hourlyRateCents?: number | null;
+  dailyRateCents?: number | null;
+}
+
+export type DefaultOfferAmountServiceShape = UnifiedPricingSourceCandidates & {
+  serviceRatesAssociation?: {
+    serviceGeneralRates?: LegacyGeneralRatesShape | null;
+  } | null;
+};
+
+export interface DefaultOfferAmountParams {
+  service: DefaultOfferAmountServiceShape;
+  durationHours: number;
+  expectedAttendees?: number | null;
+}
+
+/** Event length in hours; defaults to 1 when dates are missing or invalid. */
+export function computeBashEventDurationHours(
+  startDateTime: Date | string | null | undefined,
+  endDateTime: Date | string | null | undefined
+): number {
+  if (!startDateTime || !endDateTime) return 1;
+  const start = new Date(startDateTime).getTime();
+  const end = new Date(endDateTime).getTime();
+  if (!Number.isFinite(start) || !Number.isFinite(end)) return 1;
+  const hours = (end - start) / (1000 * 60 * 60);
+  return hours >= 0.25 ? hours : 1;
+}
+
+/** Legacy published-rate estimate (flat → daily if 8+ hrs → hourly × duration). */
+export function calcLegacyRateEstimateCents(
+  rates: LegacyGeneralRatesShape | null | undefined,
+  durationHours: number
+): number {
+  if (!rates) return 0;
+  if ((rates.flatRateCents ?? 0) > 0) return rates.flatRateCents!;
+  const hours = durationHours >= 0.25 ? durationHours : 1;
+  if (
+    hours >= SERVICE_DAILY_RATE_HOURS_MIN &&
+    (rates.dailyRateCents ?? 0) > 0
+  ) {
+    return rates.dailyRateCents!;
+  }
+  if ((rates.hourlyRateCents ?? 0) > 0) {
+    return Math.round(rates.hourlyRateCents! * hours);
+  }
+  if ((rates.dailyRateCents ?? 0) > 0) return rates.dailyRateCents!;
+  return 0;
+}
+
+function unifiedModelEstimateCents(
+  pricingModel: string,
+  block: {
+    baseRateCents: number | null;
+    baseRateBashPoints: number | null;
+    minimumChargeCents: number | null;
+    minimumQuantity: number | null;
+  },
+  durationHours: number,
+  expectedAttendees: number | null | undefined
+): number {
+  const base = block.baseRateCents ?? 0;
+  const hours = durationHours >= 0.25 ? durationHours : 1;
+
+  switch (pricingModel) {
+    case "HOURLY":
+      return base > 0 ? Math.round(base * hours) : 0;
+    case "PER_DAY":
+      if (base <= 0) return 0;
+      if (hours >= SERVICE_DAILY_RATE_HOURS_MIN) return base;
+      return Math.round(base * (hours / SERVICE_DAILY_RATE_HOURS_MIN));
+    case "FLAT_FEE":
+    case "CUSTOM":
+      return base > 0 ? base : 0;
+    case "PER_ATTENDEE":
+    case "PER_PAID_ATTENDEE": {
+      const bands = computeOfferComparisonBands({
+        pricingModel,
+        baseRateCents: base,
+        minimumChargeCents: block.minimumChargeCents,
+        minimumQuantity: block.minimumQuantity,
+        expectedAttendees,
+      } satisfies OfferComparisonInput);
+      return bands.expectedTotalCents ?? 0;
+    }
+    case "PER_BASHPOINTS_ATTENDEE":
+      return 0;
+    case "TIERED": {
+      const bands = computeOfferComparisonBands({
+        pricingModel: "TIERED",
+        tieredExpectedTierCents: base > 0 ? base : null,
+      });
+      return bands.expectedTotalCents ?? 0;
+    }
+    default: {
+      const bands = computeOfferComparisonBands({
+        pricingModel,
+        baseRateCents: base,
+        flatRateCents: base > 0 ? base : null,
+      });
+      return bands.expectedTotalCents ?? 0;
+    }
+  }
+}
+
+/**
+ * Returns the suggested opening offer in USD cents for this bash, or 0 when
+ * no computable rate exists (bulk send should skip those services).
+ */
+export function getDefaultOfferAmountCents(
+  params: DefaultOfferAmountParams
+): number {
+  const { service, durationHours, expectedAttendees } = params;
+  const legacyRates = service.serviceRatesAssociation?.serviceGeneralRates;
+
+  const block = resolveUnifiedPricingBlock({
+    eventService: service.eventService,
+    vendor: service.vendor,
+    exhibitor: service.exhibitor,
+    sponsor: service.sponsor,
+    venue: service.venue,
+    entertainmentService: service.entertainmentService,
+    volunteerService: service.volunteerService,
+    legacyRate: null,
+  });
+
+  if (block.fromUnifiedBlock && block.pricingModel) {
+    const unified = unifiedModelEstimateCents(
+      block.pricingModel,
+      block,
+      durationHours,
+      expectedAttendees
+    );
+    if (unified > 0) return unified;
+  }
+
+  return calcLegacyRateEstimateCents(legacyRates, durationHours);
+}
+
+export function formatOfferAmountDollars(cents: number): string {
+  return `$${Math.round(cents / 100).toLocaleString("en-US")}`;
+}
+
+/** Host → provider bulk offers only when a positive USD default exists. */
+export function isBulkHostOfferEligible(
+  amountCents: number,
+  isParticipationFeeService: boolean
+): boolean {
+  return !isParticipationFeeService && amountCents > 0;
+}
+
+export const BULK_OFFER_MAX_COUNT = 10;