@bash-app/bash-common 30.284.0 → 30.289.0

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

@@ -0,0 +1,152 @@
+import {
+  applyAvailabilityPreset,
+  computeEarliestOpenDate,
+  detectAvailabilityPreset,
+  formatAvailabilityPresetLabel,
+  parseAvailableHours,
+} from "../serviceAvailabilityDisplay.js";
+
+describe("applyAvailabilityPreset", () => {
+  it("opens Mon-Fri and closes weekend for the weekdays preset", () => {
+    const config = applyAvailabilityPreset("weekdays");
+    expect(config.openDays).toEqual({
+      Monday: true,
+      Tuesday: true,
+      Wednesday: true,
+      Thursday: true,
+      Friday: true,
+      Saturday: false,
+      Sunday: false,
+    });
+    expect(config.hours?.Monday?.[0]).toEqual({
+      open: "12:00 AM",
+      close: "11:59 PM",
+    });
+    expect(config.hours?.Saturday?.[0]).toEqual({ open: "", close: "" });
+  });
+
+  it("opens Sat-Sun and closes weekdays for the weekends preset", () => {
+    const config = applyAvailabilityPreset("weekends");
+    expect(config.openDays).toEqual({
+      Monday: false,
+      Tuesday: false,
+      Wednesday: false,
+      Thursday: false,
+      Friday: false,
+      Saturday: true,
+      Sunday: true,
+    });
+  });
+
+  it("preserves base fields such as enableInstantBooking", () => {
+    const config = applyAvailabilityPreset("weekdays", {
+      enableInstantBooking: true,
+    });
+    expect(config.enableInstantBooking).toBe(true);
+  });
+});
+
+describe("detectAvailabilityPreset", () => {
+  it("round-trips applyAvailabilityPreset output", () => {
+    expect(detectAvailabilityPreset(applyAvailabilityPreset("weekdays").openDays)).toBe(
+      "weekdays"
+    );
+    expect(detectAvailabilityPreset(applyAvailabilityPreset("weekends").openDays)).toBe(
+      "weekends"
+    );
+  });
+
+  it("returns custom for mixed schedules", () => {
+    expect(
+      detectAvailabilityPreset({
+        Monday: true,
+        Tuesday: true,
+        Saturday: true,
+      })
+    ).toBe("custom");
+  });
+
+  it("returns null when there is no day information", () => {
+    expect(detectAvailabilityPreset(undefined)).toBeNull();
+    expect(detectAvailabilityPreset({})).toBeNull();
+  });
+});
+
+describe("formatAvailabilityPresetLabel", () => {
+  it("maps presets to copy", () => {
+    expect(formatAvailabilityPresetLabel("weekdays")).toBe(
+      "Available on weekdays"
+    );
+    expect(formatAvailabilityPresetLabel("weekends")).toBe(
+      "Available on weekends"
+    );
+    expect(formatAvailabilityPresetLabel("custom")).toBe("Custom availability");
+  });
+});
+
+describe("parseAvailableHours", () => {
+  it("parses a JSON string", () => {
+    const parsed = parseAvailableHours(
+      JSON.stringify({ openDays: { Monday: true } })
+    );
+    expect(parsed?.openDays?.Monday).toBe(true);
+  });
+
+  it("passes through an object and returns null for junk", () => {
+    expect(parseAvailableHours({ openDays: {} })).toEqual({ openDays: {} });
+    expect(parseAvailableHours("not json")).toBeNull();
+    expect(parseAvailableHours(null)).toBeNull();
+  });
+});
+
+describe("computeEarliestOpenDate", () => {
+  // A Wednesday, so weekday/weekend logic is easy to reason about.
+  const wednesday = new Date(2026, 0, 7);
+
+  it("returns the start date when that day is open and unblocked", () => {
+    const result = computeEarliestOpenDate({
+      openDays: applyAvailabilityPreset("weekdays").openDays,
+      fromDate: wednesday,
+    });
+    expect(result).toEqual(new Date(2026, 0, 7));
+  });
+
+  it("skips closed weekend days for a weekdays schedule", () => {
+    // Start on Saturday Jan 10 -> first open weekday is Monday Jan 12.
+    const saturday = new Date(2026, 0, 10);
+    const result = computeEarliestOpenDate({
+      openDays: applyAvailabilityPreset("weekdays").openDays,
+      fromDate: saturday,
+    });
+    expect(result).toEqual(new Date(2026, 0, 12));
+  });
+
+  it("skips owner-blocked ranges", () => {
+    const result = computeEarliestOpenDate({
+      openDays: applyAvailabilityPreset("weekdays").openDays,
+      fromDate: wednesday,
+      blockedRanges: [
+        { start: new Date(2026, 0, 7), end: new Date(2026, 0, 8) },
+      ],
+    });
+    // Wed 7 and Thu 8 blocked -> Friday Jan 9.
+    expect(result).toEqual(new Date(2026, 0, 9));
+  });
+
+  it("returns null when no day is open within the lookahead", () => {
+    const result = computeEarliestOpenDate({
+      openDays: {
+        Monday: false,
+        Tuesday: false,
+        Wednesday: false,
+        Thursday: false,
+        Friday: false,
+        Saturday: false,
+        Sunday: false,
+      },
+      fromDate: wednesday,
+      maxLookaheadDays: 14,
+    });
+    expect(result).toBeNull();
+  });
+});

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

@@ -0,0 +1,37 @@
+import { SocialEventCadence } from "@prisma/client";
+import { describe, expect, test } from "@jest/globals";
+import {
+  SOCIAL_EVENT_CADENCE_LABELS,
+  SOCIAL_EVENT_CADENCE_PROFILE_LABELS,
+  getSocialEventCadenceDisplay,
+} from "../userUtils.js";
+
+describe("getSocialEventCadenceDisplay", () => {
+  test("returns the promoter-voice label for a set cadence", () => {
+    expect(getSocialEventCadenceDisplay(SocialEventCadence.Always)).toBe(
+      "Always down for a bash"
+    );
+    expect(getSocialEventCadenceDisplay(SocialEventCadence.Never)).toBe(
+      "Prefers to stay in"
+    );
+  });
+
+  test("returns null when cadence is unset", () => {
+    expect(getSocialEventCadenceDisplay(null)).toBeNull();
+    expect(getSocialEventCadenceDisplay(undefined)).toBeNull();
+  });
+});
+
+describe("social event cadence label maps", () => {
+  test("plain labels cover every enum value", () => {
+    for (const value of Object.values(SocialEventCadence)) {
+      expect(SOCIAL_EVENT_CADENCE_LABELS[value]).toBeTruthy();
+    }
+  });
+
+  test("profile labels cover every enum value", () => {
+    for (const value of Object.values(SocialEventCadence)) {
+      expect(SOCIAL_EVENT_CADENCE_PROFILE_LABELS[value]).toBeTruthy();
+    }
+  });
+});

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

@@ -0,0 +1,49 @@
+import {
+  getTicketCheckInDisplayLabel,
+  isGpsCheckInMethod,
+} from "../ticketCheckInDisplay";
+
+describe("isGpsCheckInMethod", () => {
+  it("recognizes GPS / geofence method strings", () => {
+    expect(isGpsCheckInMethod("geofence")).toBe(true);
+    expect(isGpsCheckInMethod("auto")).toBe(true);
+    expect(isGpsCheckInMethod("GPS_RADIUS")).toBe(true);
+    expect(isGpsCheckInMethod("manual")).toBe(false);
+  });
+});
+
+describe("getTicketCheckInDisplayLabel", () => {
+  const checkedInAt = new Date("2030-06-01T20:00:00.000Z");
+
+  it("returns null when not checked in", () => {
+    expect(getTicketCheckInDisplayLabel(null, "manual")).toBeNull();
+    expect(getTicketCheckInDisplayLabel(null, "manual", "Pending")).toBeNull();
+  });
+
+  it("labels CheckedIn status when checkedInAt is missing (legacy rows)", () => {
+    expect(getTicketCheckInDisplayLabel(null, "manual", "CheckedIn")).toBe(
+      "Scanned at door"
+    );
+    expect(getTicketCheckInDisplayLabel(null, "geofence", "CheckedIn")).toBe(
+      "GPS check-in"
+    );
+    expect(getTicketCheckInDisplayLabel(null, null, "CheckedIn")).toBe(
+      "Checked in"
+    );
+  });
+
+  it("labels GPS check-in", () => {
+    expect(getTicketCheckInDisplayLabel(checkedInAt, "geofence")).toBe(
+      "GPS check-in"
+    );
+    expect(getTicketCheckInDisplayLabel(checkedInAt, "auto")).toBe(
+      "GPS check-in"
+    );
+  });
+
+  it("labels door scan", () => {
+    expect(getTicketCheckInDisplayLabel(checkedInAt, "manual")).toBe(
+      "Scanned at door"
+    );
+  });
+});

package/src/utils/agencyBookingCheckoutCopy.ts

@@ -0,0 +1,50 @@
+import type { AgencyPayoutModel } from "@prisma/client";
+
+export type AgencyBookingCheckoutNoticeInput = {
+  representedByOrganizationId?: string | null;
+  payoutModelSnapshot?: AgencyPayoutModel | null;
+  representedByOrganization?: { name: string | null } | null;
+};
+
+/** Host-facing payment note when a booking is on an agency roster. */
+export function getAgencyBookingCheckoutPaymentNotice(
+  booking: AgencyBookingCheckoutNoticeInput
+): string | null {
+  if (!booking.representedByOrganizationId) {
+    return null;
+  }
+
+  const agencyName =
+    booking.representedByOrganization?.name?.trim() || "the talent agency";
+
+  if (booking.payoutModelSnapshot === "AgencyMerchantOfRecord") {
+    return `Payment is processed through ${agencyName}. Your card charge goes to the agency's connected Stripe account; the artist is paid from that account after checkout. Bash's platform fee is collected separately at checkout.`;
+  }
+
+  if (booking.payoutModelSnapshot === "ManualOffPlatform") {
+    return `This booking is represented by ${agencyName}. Payment goes to the artist; agency commission is handled outside Stripe per your roster terms.`;
+  }
+
+  return `This booking is represented by ${agencyName}. Payment goes to the artist's Stripe account. Agency commission is tracked separately and settled per your roster terms.`;
+}
+
+export const AGENCY_PAYOUT_MODEL_LABELS: Record<
+  AgencyPayoutModel,
+  { title: string; summary: string }
+> = {
+  ArtistMerchantOfRecord: {
+    title: "Artist collects (default)",
+    summary:
+      "Checkout pays the artist's Stripe account. Bash keeps the platform fee. Your commission appears in Commissions and is settled per roster terms.",
+  },
+  AgencyMerchantOfRecord: {
+    title: "Agency collects (Stripe Connect)",
+    summary:
+      "Checkout pays your org Stripe account. Bash keeps the platform fee; you keep commission on your balance. The artist's share is transferred to their Connect account after payment.",
+  },
+  ManualOffPlatform: {
+    title: "Manual / off-platform",
+    summary:
+      "Commission is tracked in Bash only. You and the artist settle money outside Stripe.",
+  },
+};

package/src/utils/entertainmentDrawFit.ts

@@ -0,0 +1,180 @@
+import type { AmountOfGuests } from "@prisma/client";
+
+export type CrowdSizeLike = Pick<
+  AmountOfGuests,
+  | "minimum"
+  | "ideal"
+  | "expected"
+  | "showMinimumGuests"
+  | "showIdealGuests"
+  | "showExpectedGuests"
+> | null | undefined;
+
+export type VenueCapacityLike = {
+  capacity?: number | null;
+  anticipatedAttendees?: number | null;
+} | null | undefined;
+
+/** Effective draw the entertainer shares publicly, or best estimate from preferences. */
+export function getEntertainerEffectiveDraw(
+  crowdSize: CrowdSizeLike
+): number | null {
+  if (!crowdSize) return null;
+
+  if (
+    crowdSize.showExpectedGuests &&
+    crowdSize.expected != null &&
+    crowdSize.expected > 0
+  ) {
+    return crowdSize.expected;
+  }
+
+  if (crowdSize.showIdealGuests && crowdSize.ideal != null && crowdSize.ideal > 0) {
+    return crowdSize.ideal;
+  }
+
+  if (
+    crowdSize.showMinimumGuests &&
+    crowdSize.minimum != null &&
+    crowdSize.minimum > 0
+  ) {
+    return crowdSize.minimum;
+  }
+
+  return null;
+}
+
+export function getVenueEffectiveCapacity(
+  venue: VenueCapacityLike
+): number | null {
+  if (!venue) return null;
+  const capacity = venue.capacity ?? venue.anticipatedAttendees;
+  return capacity != null && capacity > 0 ? capacity : null;
+}
+
+export interface DrawCapacityFitResult {
+  points: number;
+  maxPoints: number;
+  reason?: string;
+}
+
+/**
+ * Score how well an entertainer's draw fits a venue's capacity (0–15 points).
+ * Partial credit when only one side has data.
+ */
+export function scoreDrawCapacityFit(
+  venue: VenueCapacityLike,
+  crowdSize: CrowdSizeLike
+): DrawCapacityFitResult {
+  const maxPoints = 15;
+  const venueCapacity = getVenueEffectiveCapacity(venue);
+  const draw = getEntertainerEffectiveDraw(crowdSize);
+
+  if (!venueCapacity && !draw) {
+    return { points: 3, maxPoints, reason: "Draw and capacity not specified" };
+  }
+
+  if (!venueCapacity || !draw) {
+    return {
+      points: 5,
+      maxPoints,
+      reason: venueCapacity
+        ? "Entertainer draw not specified"
+        : "Venue capacity not specified",
+    };
+  }
+
+  const ratio = draw / venueCapacity;
+
+  if (ratio >= 0.2 && ratio <= 1.25) {
+    return {
+      points: maxPoints,
+      maxPoints,
+      reason: `Draw (~${draw}) fits venue capacity (~${venueCapacity})`,
+    };
+  }
+
+  if (ratio > 1.25 && ratio <= 1.75) {
+    return {
+      points: 8,
+      maxPoints,
+      reason: `Draw (~${draw}) slightly above capacity (~${venueCapacity})`,
+    };
+  }
+
+  if (ratio < 0.2 && ratio >= 0.05) {
+    return {
+      points: 7,
+      maxPoints,
+      reason: `Draw (~${draw}) modest for venue size (~${venueCapacity})`,
+    };
+  }
+
+  return {
+    points: 2,
+    maxPoints,
+    reason: `Draw (~${draw}) and capacity (~${venueCapacity}) may not align`,
+  };
+}
+
+/**
+ * Host browse filter: expected guest count vs entertainer's shared draw.
+ * When entertainer has no draw data, do not exclude them.
+ */
+export function entertainerFitsHostExpectedCrowd(
+  hostExpectedGuests: number,
+  crowdSize: CrowdSizeLike
+): boolean {
+  if (!Number.isFinite(hostExpectedGuests) || hostExpectedGuests <= 0) {
+    return true;
+  }
+
+  const draw = getEntertainerEffectiveDraw(crowdSize);
+  if (draw == null) {
+    return true;
+  }
+
+  const low = hostExpectedGuests * 0.2;
+  const high = hostExpectedGuests * 2.5;
+  return draw >= low && draw <= high;
+}
+
+function normalizeVenueName(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+/** Fuzzy match venue listing name against entertainer's notable venue names. */
+export function findNotableVenueNameMatch(
+  venueServiceName: string | null | undefined,
+  notableVenuesPerformed: string[] | null | undefined,
+  showNotableVenuesPerformed?: boolean
+): string | null {
+  if (!showNotableVenuesPerformed) {
+    return null;
+  }
+
+  if (!venueServiceName?.trim() || !notableVenuesPerformed?.length) {
+    return null;
+  }
+
+  const normalizedVenue = normalizeVenueName(venueServiceName);
+  if (!normalizedVenue) return null;
+
+  for (const notable of notableVenuesPerformed) {
+    const normalizedNotable = normalizeVenueName(notable);
+    if (!normalizedNotable) continue;
+
+    if (
+      normalizedVenue.includes(normalizedNotable) ||
+      normalizedNotable.includes(normalizedVenue)
+    ) {
+      return notable.trim();
+    }
+  }
+
+  return null;
+}

package/src/utils/guestSurface.ts

@@ -20,7 +20,11 @@ export type AttendeeVisibility =
 export type GuestListDepth = "None" | "Partial" | "Full";
 
 /** Who may see the full attendee roster on the bash detail page (Layer 1). */
-export type AttendeeListAccess = "Preview" | "Public" | "TicketHolders";
+export type AttendeeListAccess =
+  | "Preview"
+  | "Public"
+  | "TicketHolders"
+  | "RsvpGoing";
 
 export type { PublicTeaserUser };
 
@@ -35,7 +39,12 @@ export type NetworkOverlapPayload = {
 };
 
 export type GuestSurfacePayload = {
-  count: { totalTickets: number; visibleAttendees: number };
+  count: {
+    totalTickets: number;
+    visibleAttendees: number;
+    /** Going RSVPs on Rsvp-mode events (ticket count may be 0). */
+    rsvpGoingCount?: number;
+  };
   preview: PublicTeaserUser[];
   featured: PublicTeaserUser[];
   featuredHeadline: string | null;
@@ -65,6 +74,14 @@ export type GuestSurfacePayload = {
   attendeeListPublic?: boolean;
   /** Preview | Public | TicketHolders — supersedes attendeeListPublic when set */
   attendeeListAccess?: string | null;
+  /**
+   * When set, the viewer sees a blurred preview and must RSVP (or buy a ticket)
+   * to unlock the full attendee list.
+   */
+  listLock?: {
+    reason: "rsvp_required" | "ticket_required";
+    goingCount: number;
+  } | null;
 };
 
 export type AttendeeRosterMeta = {
@@ -109,7 +126,7 @@ export function resolveAttendeeListAccess(event: {
   attendeeListPublic?: boolean | null;
 }): AttendeeListAccess {
   const raw = event.attendeeListAccess;
-  if (raw === "Public" || raw === "TicketHolders" || raw === "Preview") {
+  if (raw === "Public" || raw === "TicketHolders" || raw === "Preview" || raw === "RsvpGoing") {
     return raw;
   }
   return event.attendeeListPublic ? "Public" : "Preview";

package/src/utils/locationVisibility.ts

@@ -17,6 +17,11 @@ export type ViewerLocationContext = {
   viewerOwnsValidTicket: boolean;
   viewerPublicRsvpGoing: boolean;
   viewerHasAcceptedInvitation: boolean;
+  /**
+   * Active guest-session grant with status Going for this event (no password account).
+   * Mirrors viewerPublicRsvpGoing for location unlock when hideLocation is on.
+   */
+  viewerGuestRsvpGoing?: boolean;
 };
 
 const VALID_TICKET_STATUSES_EXCLUDED = new Set(["Cancelled", "WaitlistPending"]);
@@ -47,7 +52,9 @@ export function viewerCanSeeFullBashLocation(
   if (!bash.hideLocation) return true;
   if (bash.locationRevealedAt) return true;
   if (ctx.isHostOrOrganizer) return true;
-  if (!ctx.viewerUserId) return false;
+
+  const guestGoing = ctx.viewerGuestRsvpGoing === true;
+  if (!ctx.viewerUserId && !guestGoing) return false;
 
   const audience = bash.locationRevealAudience ?? "TicketHolders";
 
@@ -55,8 +62,10 @@ export function viewerCanSeeFullBashLocation(
 
   if (audience === "TicketHolders") return false;
 
+  const rsvpGoing = ctx.viewerPublicRsvpGoing || guestGoing;
+
   if (audience === "TicketHoldersAndRsvps" || audience === "TicketHoldersAndInvited") {
-    if (ctx.viewerPublicRsvpGoing) return true;
+    if (rsvpGoing) return true;
   }
 
   if (audience === "TicketHoldersAndInvited" && ctx.viewerHasAcceptedInvitation) {

package/src/utils/organizationEntitlements.ts

@@ -0,0 +1,37 @@
+/**
+ * Organization plan entitlements (pure predicates shared by api + bash-app).
+ *
+ * Keep these free of Prisma/DB access so both the frontend (gating UI + subdomain
+ * routing) and backend (SSR + API responses) evaluate the same rules. Pass only the
+ * subscription fields, not a full Prisma model, so partial selects work everywhere.
+ */
+
+/** Subscription statuses where a paid plan's perks are considered live. */
+export const ACTIVE_ORG_SUBSCRIPTION_STATUSES = [
+  "Active",
+  "Trialing",
+] as const;
+
+export interface OrganizationEntitlementInput {
+  subscriptionTier?: string | null;
+  subscriptionStatus?: string | null;
+}
+
+/**
+ * Vanity subdomains ({slug}.bash.community) are an Enterprise-only perk. All other
+ * orgs use the canonical path URL (bash.community/org/{slug}). Requires an active
+ * (or trialing) subscription so a lapsed Enterprise org falls back to the path.
+ */
+export function organizationHasVanitySubdomain(
+  org: OrganizationEntitlementInput | null | undefined
+): boolean {
+  if (!org) return false;
+  if (org.subscriptionTier !== "Enterprise") return false;
+  // Treat a missing status as active: legacy/ops-provisioned Enterprise orgs may
+  // predate subscriptionStatus being populated, and we don't want to silently
+  // drop their vanity domain.
+  if (org.subscriptionStatus == null) return true;
+  return (ACTIVE_ORG_SUBSCRIPTION_STATUSES as readonly string[]).includes(
+    org.subscriptionStatus
+  );
+}

package/src/utils/reputationUtils.ts

@@ -0,0 +1,94 @@
+/**
+ * Unified reputation summary across actor types (hosts, services/venues/artists).
+ *
+ * Stars on profiles show the raw average; leaderboards and cross-actor comparisons
+ * use a Bayesian-adjusted score so a 5.0 from two people doesn't outrank a 4.8
+ * from two hundred (see the Ratings explainer copy). Keeping the math here means
+ * host and service reputation stay consistent without duplicating the formula.
+ */
+
+export type ReputationActorType = "host" | "service" | "venue" | "artist";
+
+export interface ReputationSummary {
+  actorType: ReputationActorType;
+  /** Raw average rating (0–5), or null when there isn't enough signal. */
+  averageRating: number | null;
+  /** Number of ratings behind the average. */
+  totalRatings: number;
+  /** Bayesian-adjusted score (0–5) for ranking; null below the minimum. */
+  bayesianScore: number | null;
+  /** Whether there are enough ratings to show stars publicly. */
+  hasEnoughSignal: boolean;
+}
+
+/** Below this many ratings we don't show a star number (avoids misleading 5.0s). */
+export const MIN_RATINGS_FOR_DISPLAY = 3;
+
+/** Prior strength (how many "virtual" average-rated reviews to blend in). */
+const BAYESIAN_PRIOR_COUNT = 10;
+/** Prior mean — the platform's assumed baseline rating. */
+const BAYESIAN_PRIOR_MEAN = 4.0;
+
+/**
+ * Bayesian average: pulls low-volume ratings toward the prior mean, so a couple
+ * of glowing reviews can't outrank a large, consistently-strong record.
+ */
+export function bayesianAverage(
+  averageRating: number | null | undefined,
+  totalRatings: number | null | undefined,
+  opts: { priorCount?: number; priorMean?: number } = {}
+): number | null {
+  const avg = averageRating ?? 0;
+  const count = totalRatings ?? 0;
+  if (count <= 0) return null;
+  const priorCount = opts.priorCount ?? BAYESIAN_PRIOR_COUNT;
+  const priorMean = opts.priorMean ?? BAYESIAN_PRIOR_MEAN;
+  const score = (priorCount * priorMean + count * avg) / (priorCount + count);
+  return Math.round(score * 100) / 100;
+}
+
+/** Build a normalized reputation summary from a rating + count pair. */
+export function getReputationSummary(
+  actorType: ReputationActorType,
+  averageRating: number | null | undefined,
+  totalRatings: number | null | undefined
+): ReputationSummary {
+  const count = totalRatings ?? 0;
+  const hasEnoughSignal = count >= MIN_RATINGS_FOR_DISPLAY;
+  return {
+    actorType,
+    averageRating: hasEnoughSignal ? (averageRating ?? null) : null,
+    totalRatings: count,
+    bayesianScore: bayesianAverage(averageRating, totalRatings),
+    hasEnoughSignal,
+  };
+}
+
+export interface ServiceListingReputation {
+  averageRating: number;
+  totalRatings: number;
+  sourceLabel?: string;
+}
+
+/** Compact browse/detail reputation from aggregate service rating fields. */
+export function getServiceListingReputation(service: {
+  serviceRating?: number | null;
+  totalRatings?: number | null;
+  externalReviewSource?: string | null;
+}): ServiceListingReputation | null {
+  const summary = getReputationSummary(
+    "service",
+    service.serviceRating,
+    service.totalRatings
+  );
+  if (!summary.hasEnoughSignal || summary.averageRating == null) {
+    return null;
+  }
+  const sourceLabel =
+    service.externalReviewSource === "google" ? "Google" : undefined;
+  return {
+    averageRating: summary.averageRating,
+    totalRatings: summary.totalRatings,
+    sourceLabel,
+  };
+}