@bash-app/bash-common 30.431.0 → 30.433.0

package/src/promoCartEngine.ts

@@ -0,0 +1,193 @@
+/**
+ * Multi-tier promo engine (pure). Decides, per cart line, whether a code applies
+ * and how much cash and BashPoints it takes off, with a deterministic fixed-cash
+ * allocation that the API persists so refunds and reports reproduce exactly.
+ */
+import {
+  promoCodeAppliesToTier,
+  promoCodeDiscountKind,
+  type PromoDiscountKind,
+  type PromoScopeFields,
+} from "./promoCodeScope.js";
+
+export type PromoCartLinePricing = "USD" | "BASHPOINTS" | "FREE";
+
+export type PromoCartLine = {
+  ticketTierId: string;
+  pricing: PromoCartLinePricing;
+  quantity: number;
+  /** Cash subtotal for the line after special offers, in cents. */
+  cashSubtotalCents: number;
+  /** BashPoints subtotal for the line. */
+  pointsSubtotal: number;
+};
+
+export type PromoForCart = PromoScopeFields & {
+  discountAppliesToBashPoints?: boolean | null;
+  redeemBy?: Date | null;
+  disabledAt?: Date | null;
+};
+
+export type PromoCartLineResult = {
+  ticketTierId: string;
+  eligible: boolean;
+  cashDiscountCents: number;
+  pointsDiscount: number;
+  finalCashCents: number;
+  finalPoints: number;
+  attributedTicketCount: number;
+};
+
+export type PromoCartResult = {
+  status: "applied" | "not_applicable" | "expired" | "disabled";
+  discountKind: PromoDiscountKind;
+  lines: PromoCartLineResult[];
+  eligibleTierIds: string[];
+  cashDiscountTotalCents: number;
+  pointsDiscountTotal: number;
+  attributedTicketCount: number;
+};
+
+function clampPercent(value: number | null | undefined): number {
+  const pct = Math.floor(Number(value) || 0);
+  return Math.max(0, Math.min(100, pct));
+}
+
+/**
+ * Split `amount` across `weights` in proportion, flooring each share, then give
+ * leftover units one at a time to the largest weight first, ties by key ascending.
+ */
+export function allocateProportionally(
+  amount: number,
+  items: ReadonlyArray<{ key: string; weight: number }>
+): Map<string, number> {
+  const result = new Map<string, number>();
+  const total = items.reduce((s, i) => s + Math.max(0, i.weight), 0);
+  const whole = Math.max(0, Math.floor(amount));
+  if (total <= 0 || whole <= 0) {
+    for (const i of items) result.set(i.key, 0);
+    return result;
+  }
+  const capped = Math.min(whole, total);
+  let assigned = 0;
+  for (const i of items) {
+    const share = Math.floor((capped * Math.max(0, i.weight)) / total);
+    result.set(i.key, share);
+    assigned += share;
+  }
+  // Fractional parts sum to fewer units than there are lines, so one pass suffices.
+  let leftover = capped - assigned;
+  const order = [...items]
+    .filter((i) => i.weight > 0)
+    .sort((a, b) => b.weight - a.weight || (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+  for (const i of order) {
+    if (leftover <= 0) break;
+    result.set(i.key, (result.get(i.key) ?? 0) + 1);
+    leftover--;
+  }
+  return result;
+}
+
+/** Per-ticket split of a line amount: equal shares, leftover cents to tickets in id order. */
+export function allocateAcrossTickets(
+  lineAmount: number,
+  ticketIds: readonly string[]
+): Map<string, number> {
+  const sorted = [...ticketIds].sort();
+  const result = new Map<string, number>();
+  const amount = Math.max(0, Math.floor(lineAmount));
+  if (sorted.length === 0) return result;
+  const base = Math.floor(amount / sorted.length);
+  let leftover = amount - base * sorted.length;
+  for (const id of sorted) {
+    result.set(id, base + (leftover > 0 ? 1 : 0));
+    if (leftover > 0) leftover--;
+  }
+  return result;
+}
+
+export function resolvePromoForCart(args: {
+  promo: PromoForCart;
+  cartLines: readonly PromoCartLine[];
+  now: Date;
+}): PromoCartResult {
+  const { promo, cartLines, now } = args;
+  const kind = promoCodeDiscountKind(promo);
+  const empty = (status: PromoCartResult["status"]): PromoCartResult => ({
+    status,
+    discountKind: kind,
+    lines: cartLines.map((l) => ({
+      ticketTierId: l.ticketTierId,
+      eligible: false,
+      cashDiscountCents: 0,
+      pointsDiscount: 0,
+      finalCashCents: Math.max(0, l.cashSubtotalCents),
+      finalPoints: Math.max(0, l.pointsSubtotal),
+      attributedTicketCount: 0,
+    })),
+    eligibleTierIds: [],
+    cashDiscountTotalCents: 0,
+    pointsDiscountTotal: 0,
+    attributedTicketCount: 0,
+  });
+  if (promo.disabledAt) return empty("disabled");
+  if (promo.redeemBy && promo.redeemBy.getTime() < now.getTime()) return empty("expired");
+
+  const eligibleSet = new Set(
+    cartLines.filter((l) => promoCodeAppliesToTier(promo, l.ticketTierId)).map((l) => l.ticketTierId)
+  );
+  if (eligibleSet.size === 0) return empty("not_applicable");
+
+  const pct = clampPercent(promo.discountAmountPercentage);
+  const fixed = Math.max(0, Math.floor(promo.discountAmountInCents ?? 0));
+  const pointsAllowed = promo.discountAppliesToBashPoints === true;
+
+  const fixedAllocation =
+    kind === "FIXED_CASH"
+      ? allocateProportionally(
+          fixed,
+          cartLines
+            .filter((l) => eligibleSet.has(l.ticketTierId) && l.pricing === "USD")
+            .map((l) => ({ key: l.ticketTierId, weight: Math.max(0, l.cashSubtotalCents) }))
+        )
+      : new Map<string, number>();
+
+  const lines = cartLines.map((l): PromoCartLineResult => {
+    const eligible = eligibleSet.has(l.ticketTierId);
+    const cash = Math.max(0, l.cashSubtotalCents);
+    const points = Math.max(0, l.pointsSubtotal);
+    let cashDiscount = 0;
+    let pointsDiscount = 0;
+    if (eligible) {
+      if (kind === "PERCENT") {
+        if (l.pricing === "USD") cashDiscount = Math.floor((cash * pct) / 100);
+        if (l.pricing === "BASHPOINTS" && pointsAllowed) {
+          pointsDiscount = Math.floor((points * pct) / 100);
+        }
+      } else if (kind === "FIXED_CASH" && l.pricing === "USD") {
+        cashDiscount = fixedAllocation.get(l.ticketTierId) ?? 0;
+      }
+    }
+    cashDiscount = Math.min(cashDiscount, cash);
+    pointsDiscount = Math.min(pointsDiscount, points);
+    return {
+      ticketTierId: l.ticketTierId,
+      eligible,
+      cashDiscountCents: cashDiscount,
+      pointsDiscount,
+      finalCashCents: cash - cashDiscount,
+      finalPoints: points - pointsDiscount,
+      attributedTicketCount: eligible ? Math.max(0, l.quantity) : 0,
+    };
+  });
+
+  return {
+    status: "applied",
+    discountKind: kind,
+    lines,
+    eligibleTierIds: [...eligibleSet],
+    cashDiscountTotalCents: lines.reduce((s, l) => s + l.cashDiscountCents, 0),
+    pointsDiscountTotal: lines.reduce((s, l) => s + l.pointsDiscount, 0),
+    attributedTicketCount: lines.reduce((s, l) => s + l.attributedTicketCount, 0),
+  };
+}

package/src/promoCodeRedemption.ts

@@ -0,0 +1,123 @@
+/**
+ * Promo code redemption rules shared by the API and the app.
+ * The API owns the ledger; these helpers are pure.
+ */
+
+export const PROMO_CODE_REJECT_REASONS = [
+  "expired",
+  "exhausted",
+  "already_used",
+  "disabled",
+  "invalid",
+  "host_review_required",
+] as const;
+
+export type PromoCodeRejectReason = (typeof PROMO_CODE_REJECT_REASONS)[number];
+
+/** Guest-facing copy. Plain and specific: this is about money. */
+export const PROMO_CODE_REJECT_MESSAGES: Record<PromoCodeRejectReason, string> = {
+  expired: "This code has expired.",
+  exhausted: "This code has reached its order limit.",
+  already_used: "You've already used this code as many times as it allows.",
+  disabled: "This code is no longer active.",
+  invalid: "We couldn't find that code for this bash.",
+  host_review_required: "This code needs the host to review it.",
+};
+
+export function isPromoCodeRejectReason(value: unknown): value is PromoCodeRejectReason {
+  return (
+    typeof value === "string" &&
+    (PROMO_CODE_REJECT_REASONS as readonly string[]).includes(value)
+  );
+}
+
+export type PromoRedeemabilityInput = {
+  redeemBy: Date | null | undefined;
+  disabledAt?: Date | null;
+  maxRedemptions: number | null | undefined;
+  maxUsesPerAccount?: number | null;
+  /** Consumed plus unexpired Reserved orders for the code. */
+  activeOrderCount: number;
+  /** Same count for the buyer's account (user id, else normalized email). */
+  accountOrderCount: number;
+  now: Date;
+};
+
+/** First failing rule, or null when the code can be used for one more order. */
+export function evaluatePromoRedeemability(
+  input: PromoRedeemabilityInput
+): PromoCodeRejectReason | null {
+  if (input.disabledAt) return "disabled";
+  if (input.redeemBy && input.redeemBy.getTime() < input.now.getTime()) {
+    return "expired";
+  }
+  if (
+    input.maxRedemptions != null &&
+    input.maxRedemptions > 0 &&
+    input.activeOrderCount >= input.maxRedemptions
+  ) {
+    return "exhausted";
+  }
+  if (
+    input.maxUsesPerAccount != null &&
+    input.maxUsesPerAccount > 0 &&
+    input.accountOrderCount >= input.maxUsesPerAccount
+  ) {
+    return "already_used";
+  }
+  return null;
+}
+
+export type PromoCodeDuplicateCandidate = {
+  id: string;
+  ticketTierId: string | null;
+  promoterId: string | null;
+  discountAmountInCents: number | null;
+  discountAmountPercentage: number | null;
+  redeemBy: Date | null;
+  maxRedemptions: number | null;
+  bashPointsRewardPerTicket: number | null;
+};
+
+function duplicateSignature(row: PromoCodeDuplicateCandidate): string {
+  return JSON.stringify([
+    row.promoterId ?? null,
+    row.discountAmountInCents ?? null,
+    row.discountAmountPercentage ?? null,
+    row.redeemBy ? new Date(row.redeemBy).getTime() : null,
+    row.maxRedemptions ?? null,
+    row.bashPointsRewardPerTicket ?? null,
+  ]);
+}
+
+/**
+ * Legacy codes are unique per tier, so one bash can hold several rows with the
+ * same code. Identical rows resolve to the oldest id, preferring a row whose tier
+ * is in the cart. Rows that differ need the host to review them.
+ */
+export function pickPromoCodeAmongDuplicates<T extends PromoCodeDuplicateCandidate>(
+  rows: readonly T[],
+  cartTierIds?: readonly string[]
+): { row: T } | { reason: "host_review_required" } {
+  if (rows.length === 0) {
+    throw new Error("pickPromoCodeAmongDuplicates needs at least one row");
+  }
+  if (rows.length === 1) return { row: rows[0] };
+  const signature = duplicateSignature(rows[0]);
+  if (rows.some((r) => duplicateSignature(r) !== signature)) {
+    return { reason: "host_review_required" };
+  }
+  const inCart = cartTierIds?.length
+    ? rows.filter((r) => r.ticketTierId && cartTierIds.includes(r.ticketTierId))
+    : [];
+  const pool = inCart.length ? inCart : rows;
+  const oldest = [...pool].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))[0];
+  return { row: oldest };
+}
+
+export function normalizePromoRedemptionEmail(
+  email: string | null | undefined
+): string | null {
+  const trimmed = email?.trim().toLowerCase() ?? "";
+  return trimmed ? trimmed : null;
+}

package/src/promoCodeScope.ts

@@ -0,0 +1,164 @@
+import { getPublicBashDetailPath } from "./utils/slugUtils.js";
+
+/**
+ * Which bash and tiers a promo code applies to, and what kind of discount it
+ * gives, for both legacy single-tier rows and bash-level rows. Every reader goes
+ * through these instead of `promo.ticketTier.bashEventId` or `promo.ticketTierId`.
+ */
+
+export type PromoDiscountKind = "NONE" | "PERCENT" | "FIXED_CASH";
+export type PromoEligibilityMode = "ALL_TIERS" | "SELECTED_TIERS";
+
+export type PromoScopeFields = {
+  ticketTierId?: string | null;
+  bashEventId?: string | null;
+  eligibilityMode?: PromoEligibilityMode | null;
+  discountType?: PromoDiscountKind | null;
+  discountAmountInCents?: number | null;
+  discountAmountPercentage?: number | null;
+  eligibleTiers?: ReadonlyArray<{ ticketTierId: string }> | null;
+  ticketTier?: { bashEventId: string } | null;
+};
+
+/** Explicit type wins; legacy rows derive it from whichever amount is set. */
+export function promoCodeDiscountKind(promo: PromoScopeFields): PromoDiscountKind {
+  if (promo.discountType) return promo.discountType;
+  if ((promo.discountAmountPercentage ?? 0) > 0) return "PERCENT";
+  if ((promo.discountAmountInCents ?? 0) > 0) return "FIXED_CASH";
+  return "NONE";
+}
+
+export function promoCodeBashEventId(promo: PromoScopeFields): string | null {
+  return promo.bashEventId ?? promo.ticketTier?.bashEventId ?? null;
+}
+
+/**
+ * "ALL" for an all-tiers code (including tiers added later); otherwise the
+ * selected tier ids, falling back to the legacy single tier.
+ */
+export function promoCodeEligibleTierIds(promo: PromoScopeFields): "ALL" | string[] {
+  if (promo.eligibilityMode === "ALL_TIERS") return "ALL";
+  const selected = (promo.eligibleTiers ?? []).map((t) => t.ticketTierId);
+  if (selected.length > 0) return [...new Set(selected)];
+  return promo.ticketTierId ? [promo.ticketTierId] : [];
+}
+
+export function promoCodeAppliesToTier(promo: PromoScopeFields, ticketTierId: string): boolean {
+  const ids = promoCodeEligibleTierIds(promo);
+  return ids === "ALL" || ids.includes(ticketTierId);
+}
+
+export type PromoCodeStatusReason =
+  | "expired"
+  | "exhausted"
+  | "already_used"
+  | "disabled"
+  | "invalid"
+  | "host_review_required";
+
+/** Public, logged-out view of a code. Never includes a promoter id or email. */
+export type PromoCodeStatus = {
+  status: "valid" | PromoCodeStatusReason;
+  reason: PromoCodeStatusReason | null;
+  code: string;
+  discountType: PromoDiscountKind | null;
+  /** Percent for PERCENT, cents for FIXED_CASH, 0 for NONE. */
+  value: number;
+  eligibilityMode: PromoEligibilityMode | null;
+  /** Empty for all-tiers codes. */
+  eligibleTierIds: string[];
+  appliesToBashPoints: boolean;
+};
+
+/**
+ * Promoter share link: `/bash/<active vanity>?promo=CODE`, else the public
+ * id-slug path. The code is uppercased and URL-encoded. Legacy `?promocode=`
+ * and `?ref=` links keep working on the bash page.
+ */
+export function getPromoterShareUrl(args: {
+  bashEventId: string;
+  slug?: string | null;
+  vanityPaths?: ReadonlyArray<{ segment: string; status: string }> | null;
+  code: string;
+  /** Absolute origin, e.g. "https://bash.community". Omit for a relative path. */
+  origin?: string;
+}): string {
+  const active = args.vanityPaths?.find((v) => v.status === "Active" && v.segment.trim());
+  const path = active
+    ? `/bash/${encodeURIComponent(active.segment.trim().toLowerCase())}`
+    : getPublicBashDetailPath(args.bashEventId, args.slug);
+  const query = `?promo=${encodeURIComponent(args.code.trim().toUpperCase())}`;
+  const origin = args.origin?.replace(/\/$/, "") ?? "";
+  return `${origin}${path}${query}`;
+}
+
+/** Host form payload for a bash-level promoter or promo code. */
+export type PromoterCodeInput = {
+  code: string;
+  promoterUserId?: string | null;
+  promoterEmail?: string | null;
+  discountType: PromoDiscountKind;
+  /** Percent (1-100) for PERCENT, cents for FIXED_CASH, ignored for NONE. */
+  discountValue?: number | null;
+  eligibilityMode: PromoEligibilityMode;
+  eligibleTierIds?: string[];
+  discountAppliesToBashPoints?: boolean;
+  redeemBy?: string | null;
+  /** Maximum orders. */
+  maxRedemptions?: number | null;
+  maxUsesPerAccount?: number | null;
+  bashPointsRewardPerTicket?: number | null;
+  /** The promoter's rate for this bash, 0-10000 bps of eligible net ticket proceeds. */
+  promoterCommissionBps?: number | null;
+  /** The host opened and confirmed the Promoter reward section. */
+  promoterRewardReviewed?: boolean;
+};
+
+export type PromoterCodeStatusLabel = "active" | "expired" | "exhausted" | "disabled";
+
+/** Validation shared by the host form and the API. Empty array means valid. */
+export function promoterCodeInputErrors(
+  input: PromoterCodeInput,
+  bashTierIds: readonly string[]
+): string[] {
+  const errors: string[] = [];
+  const code = input.code?.trim() ?? "";
+  if (!code) errors.push("Enter a code.");
+  else if (!/^[A-Za-z0-9_-]{2,32}$/.test(code)) {
+    errors.push("Codes use 2-32 letters, numbers, dashes, or underscores.");
+  }
+  if (input.discountType === "PERCENT") {
+    const pct = Number(input.discountValue);
+    if (!Number.isInteger(pct) || pct < 1 || pct > 100) {
+      errors.push("Guest discount must be between 1% and 100%.");
+    }
+  } else if (input.discountType === "FIXED_CASH") {
+    const cents = Number(input.discountValue);
+    if (!Number.isInteger(cents) || cents <= 0) errors.push("Enter a fixed discount above $0.");
+  }
+  if (input.eligibilityMode === "SELECTED_TIERS") {
+    const ids = input.eligibleTierIds ?? [];
+    if (ids.length === 0) errors.push("Pick at least one ticket tier.");
+    if (ids.some((id) => !bashTierIds.includes(id))) errors.push("A selected tier isn't on this bash.");
+  }
+  if (input.promoterCommissionBps != null) {
+    const bps = input.promoterCommissionBps;
+    if (!Number.isInteger(bps) || bps < 0 || bps > 10_000) {
+      errors.push("Promoter commission must be between 0% and 100%.");
+    }
+  }
+  for (const [label, value] of [
+    ["Maximum orders", input.maxRedemptions],
+    ["Per-guest limit", input.maxUsesPerAccount],
+    ["BashPoints per ticket", input.bashPointsRewardPerTicket],
+  ] as const) {
+    if (value != null && (!Number.isInteger(value) || value < 0)) {
+      errors.push(`${label} must be a whole number of 0 or more.`);
+    }
+  }
+  const hasPromoter = !!(input.promoterUserId || input.promoterEmail?.trim());
+  if (hasPromoter && !input.promoterRewardReviewed) {
+    errors.push("Review the promoter reward before saving.");
+  }
+  return errors;
+}

package/src/utils/__tests__/discountEngine/discountCalculator.test.ts

@@ -1,5 +1,6 @@
 import {
   OfferDiscountType,
+  PromoCodeEligibilityMode,
   SpecialOffer,
   SpecialOfferType,
 } from "@prisma/client";
@@ -23,10 +24,17 @@ function basePromoCode(
     Pick<BashEventPromoCodeWithPromoter, "id" | "code">
 ): BashEventPromoCodeWithPromoter {
   return {
+    bashEventId: null,
     ticketTierId: "tier-1",
+    eligibilityMode: PromoCodeEligibilityMode.SELECTED_TIERS,
+    discountType: null,
+    discountAppliesToBashPoints: false,
+    disabledAt: null,
+    legacyReviewFlag: null,
     discountAmountInCents: null,
     discountAmountPercentage: null,
     maxRedemptions: null,
+    maxUsesPerAccount: null,
     redeemBy: null,
     promoterId: null,
     stripeCouponId: null,

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

@@ -23,7 +23,9 @@ import {
   computeTicketApplicationFeeAmountCents,
   computeGuestTicketCheckoutBreakdown,
   ticketCommissionCents,
-  clampTicketCommissionBps,
+  eligibleNetTicketProceedsCents,
+  ticketCommissionBpsError,
+  TEMPORARY_SETTLEMENT_SAFETY_REMAINDER_CENTS,
   MAX_TICKET_COMMISSION_BPS,
   guestAllInUnitPriceCents,
   guestCheckoutHasNoAddedFees,
@@ -282,13 +284,105 @@ describe("PaymentUtils - Core Functions", () => {
       expect(r.applicationFeeAmountCents).toBe(r.stripeProcessingCents);
     });
 
-    test("ticketCommissionCents floors bps of the subtotal and caps at 50%", () => {
+    test("ticketCommissionCents floors bps of the basis and pays up to 100%", () => {
+      expect(MAX_TICKET_COMMISSION_BPS).toBe(10000);
       expect(ticketCommissionCents(10000, 1500)).toBe(1500);
       expect(ticketCommissionCents(10000, 0)).toBe(0);
-      expect(ticketCommissionCents(10000, MAX_TICKET_COMMISSION_BPS + 100)).toBe(
-        5000
-      );
-      expect(clampTicketCommissionBps(99999)).toBe(MAX_TICKET_COMMISSION_BPS);
+      expect(ticketCommissionCents(1912, 10000)).toBe(1912);
+      expect(ticketCommissionCents(1912, 5000)).toBe(956);
+      expect(ticketCommissionCents(1912, 99999)).toBe(1912);
+      expect(ticketCommissionCents(0, 10000)).toBe(0);
+    });
+
+    test("ticketCommissionBpsError accepts 0-100% and rejects the rest", () => {
+      expect(ticketCommissionBpsError(0)).toBeNull();
+      expect(ticketCommissionBpsError(5000)).toBeNull();
+      expect(ticketCommissionBpsError(10000)).toBeNull();
+      expect(ticketCommissionBpsError(null)).toBeNull();
+      expect(ticketCommissionBpsError(10001)).toMatch(/between 0% and 100%/);
+      expect(ticketCommissionBpsError(-1)).toMatch(/between 0% and 100%/);
+      expect(ticketCommissionBpsError(12.5)).toMatch(/whole number/);
+    });
+
+    describe("eligibleNetTicketProceedsCents: $20 sale", () => {
+      const fees = (feeHandling: string, platformFeeEnabled: boolean) =>
+        computeTicketApplicationFeeAmountCents({
+          discountedSubtotalCents: 2000,
+          platformFeeEnabled,
+          platformFeeRate: 0.03,
+          feeHandling,
+          bashPassWaivesGuestFee: false,
+        });
+      const net = (f: ReturnType<typeof fees>, eligible = 2000) =>
+        eligibleNetTicketProceedsCents({
+          eligibleSubtotalCents: eligible,
+          discountedSubtotalCents: 2000,
+          bashPlatformTotalCents: f.bashPlatformTotalCents,
+          guestPlatformLineCents: f.guestPlatformLineCents,
+          stripeProcessingCents: f.stripeProcessingCents,
+          guestProcessingLineCents: f.guestProcessingLineCents,
+        });
+
+      test("host absorbs, platform fee off: 2000 - 88 = 1912; 100% owes 1912, 50% owes 956", () => {
+        const f = fees("HostAbsorbs", false);
+        expect(f.applicationFeeAmountCents).toBe(88);
+        expect(net(f)).toBe(1912);
+        expect(ticketCommissionCents(net(f), 10000)).toBe(1912);
+        expect(ticketCommissionCents(net(f), 5000)).toBe(956);
+      });
+
+      test("host absorbs a 3% platform fee: app fee 148, net 1852", () => {
+        const f = fees("HostAbsorbs", true);
+        expect(f.applicationFeeAmountCents).toBe(148);
+        expect(net(f)).toBe(1852);
+        expect(ticketCommissionCents(net(f), 5000)).toBe(926);
+      });
+
+      test("guest pays the fees: the guest lines cover them, so the host share is close to the subtotal", () => {
+        const f = fees("GuestPays", true);
+        const hostShare =
+          Math.max(0, f.bashPlatformTotalCents - f.guestPlatformLineCents) +
+          Math.max(0, f.stripeProcessingCents - f.guestProcessingLineCents);
+        expect(net(f)).toBe(2000 - hostShare);
+        expect(net(f)).toBeGreaterThan(1900);
+      });
+
+      test("only the code's tier counts: a $20 eligible line in a $40 cart carries half the fees", () => {
+        const both = computeTicketApplicationFeeAmountCents({
+          discountedSubtotalCents: 4000,
+          platformFeeEnabled: false,
+          platformFeeRate: 0.03,
+          feeHandling: "HostAbsorbs",
+          bashPassWaivesGuestFee: false,
+        });
+        const eligible = eligibleNetTicketProceedsCents({
+          eligibleSubtotalCents: 2000,
+          discountedSubtotalCents: 4000,
+          bashPlatformTotalCents: both.bashPlatformTotalCents,
+          guestPlatformLineCents: both.guestPlatformLineCents,
+          stripeProcessingCents: both.stripeProcessingCents,
+          guestProcessingLineCents: both.guestProcessingLineCents,
+        });
+        expect(eligible).toBe(2000 - Math.ceil(both.stripeProcessingCents / 2));
+      });
+
+      test("zero eligible proceeds owe nothing", () => {
+        expect(net(fees("HostAbsorbs", false), 0)).toBe(0);
+      });
+    });
+
+    test("withholding can take the full eligible net when the safety remainder is 0", () => {
+      expect(TEMPORARY_SETTLEMENT_SAFETY_REMAINDER_CENTS).toBe(0);
+      const r = computeTicketApplicationFeeAmountCents({
+        discountedSubtotalCents: 2000,
+        platformFeeEnabled: false,
+        platformFeeRate: 0.03,
+        feeHandling: "HostAbsorbs",
+        bashPassWaivesGuestFee: false,
+        performerCommissionCents: 1912,
+      });
+      expect(r.performerCommissionCents).toBe(1912);
+      expect(r.totalChargedCents - r.applicationFeeAmountCents).toBe(0);
     });
 
     test("PROMO-002: performer cut is withheld on the application fee, not the guest total", () => {