《独立开发者的商业指南·资本与退出》7.2 现金、票据与 earn-out

// file: src/capital/earn-out.ts
// tier: L1
// verify: node --test test/capital/earn-out.test.ts

import { type Cents } from "../core/money.ts";
import { type Bps, applyRate } from "../core/rate.ts";
import { type Result, fail, ok } from "../core/result.ts";

export type EarnOutTerms = {
  floorBps: Bps;
  thresholdBps: Bps;
  capBps: Bps;
};

export type EarnOutPayout = {
  payoutBps: Bps;
  payoutCents: Cents;
  atCap: boolean;
  belowFloor: boolean;
};

export type ConsiderationInput = {
  priceCents: Cents;
  cashBps: Bps;
  noteBps: Bps;
  earnOutBps: Bps;
  noteAnnualRateBps: Bps;
  noteTermMonths: number;
  earnOutTermMonths: number;
  annualDiscountRateBps: Bps;
  earnOut: EarnOutTerms;
  earnOutActualBps: Bps;
};

export type Consideration = {
  priceCents: Cents;
  cashCents: Cents;
  notePrincipalCents: Cents;
  earnOutTargetCents: Cents;
  noteInterestCents: Cents;
  earnOutPayoutCents: Cents;
  nominalCents: Cents;
  presentValueCents: Cents;
  cashPresentValueCents: Cents;
  notePresentValueCents: Cents;
  earnOutPresentValueCents: Cents;
  timeValueDiscountCents: Cents;
  monthsToFullPayment: number;
  noteFirstPaymentCents: Cents;
  noteLastPaymentCents: Cents;
};

function validBps(value: Bps): boolean {
  return Number.isInteger(value) && value >= 0 && value <= 10000;
}

/**
 * Earn-out payout follows a linear ramp: nothing below the floor, the full cap
 * at the threshold, and a proportional share in between. Real contracts often
 * use a cliff instead of a ramp; the model makes the measurement dispute
 * visible either way. Floor, threshold and cap are teaching assumptions.
 */
export function earnOutPayout(
  targetCents: Cents,
  terms: EarnOutTerms,
  actualBps: Bps,
): Result<EarnOutPayout> {
  if (!Number.isInteger(targetCents) || targetCents < 0) {
    return fail("earn-out target must be a non-negative integer amount");
  }
  if (
    !validBps(terms.floorBps) ||
    !validBps(terms.thresholdBps) ||
    !validBps(terms.capBps)
  ) {
    return fail("earn-out terms must be between 0 and 10000 basis points");
  }
  if (terms.floorBps >= terms.thresholdBps) {
    return fail("earn-out floor must be below the threshold");
  }
  if (!Number.isInteger(actualBps) || actualBps < 0) {
    return fail("actual metric must be a non-negative integer in basis points");
  }

  if (actualBps <= terms.floorBps) {
    return ok({
      payoutBps: 0,
      payoutCents: 0,
      atCap: false,
      belowFloor: true,
    });
  }
  if (actualBps >= terms.thresholdBps) {
    return ok({
      payoutBps: terms.capBps,
      payoutCents: applyRate(targetCents, terms.capBps),
      atCap: true,
      belowFloor: false,
    });
  }

  const payoutBps = Math.round(
    (terms.capBps * (actualBps - terms.floorBps)) /
      (terms.thresholdBps - terms.floorBps),
  );
  return ok({
    payoutBps,
    payoutCents: applyRate(targetCents, payoutBps),
    atCap: false,
    belowFloor: false,
  });
}

/**
 * Splits the headline price into cash at close, a seller note and an earn-out.
 * The note amortizes principal in equal monthly installments and pays interest
 * on the outstanding balance. Present value discounts every monthly payment at
 * the teaching annual rate. This is arithmetic, not a valuation opinion.
 */
export function priceConsideration(
  input: ConsiderationInput,
): Result<Consideration> {
  if (!Number.isInteger(input.priceCents) || input.priceCents <= 0) {
    return fail("price must be a positive integer amount in cents");
  }
  if (
    !validBps(input.cashBps) ||
    !validBps(input.noteBps) ||
    !validBps(input.earnOutBps)
  ) {
    return fail("consideration shares must be between 0 and 10000 bps");
  }
  if (input.cashBps + input.noteBps + input.earnOutBps !== 10000) {
    return fail("cash, note and earn-out shares must add up to 100%");
  }
  if (!validBps(input.noteAnnualRateBps)) {
    return fail("note rate must be between 0 and 10000 bps");
  }
  if (!validBps(input.annualDiscountRateBps)) {
    return fail("discount rate must be between 0 and 10000 bps");
  }
  if (
    !Number.isInteger(input.noteTermMonths) ||
    input.noteTermMonths <= 0
  ) {
    return fail("note term must be a positive integer month count");
  }
  if (
    !Number.isInteger(input.earnOutTermMonths) ||
    input.earnOutTermMonths <= 0
  ) {
    return fail("earn-out term must be a positive integer month count");
  }

  const cashCents = applyRate(input.priceCents, input.cashBps);
  const notePrincipalCents = applyRate(input.priceCents, input.noteBps);
  const earnOutTargetCents = applyRate(input.priceCents, input.earnOutBps);

  const payout = earnOutPayout(
    earnOutTargetCents,
    input.earnOut,
    input.earnOutActualBps,
  );
  if (!payout.ok) {
    return fail(payout.error);
  }

  const monthlyPrincipal = Math.floor(
    notePrincipalCents / input.noteTermMonths,
  );
  const lastPrincipal =
    notePrincipalCents - monthlyPrincipal * (input.noteTermMonths - 1);
  const monthlyNoteRate = input.noteAnnualRateBps / 10000 / 12;
  const monthlyDiscountRate = input.annualDiscountRateBps / 10000 / 12;

  let outstanding = notePrincipalCents;
  let noteInterestCents = 0;
  let notePresentValueCents = 0;
  let firstPaymentCents = 0;
  let lastPaymentCents = 0;

  for (let month = 1; month <= input.noteTermMonths; month += 1) {
    const principal =
      month < input.noteTermMonths ? monthlyPrincipal : lastPrincipal;
    const interest = Math.round(outstanding * monthlyNoteRate);
    const payment = principal + interest;
    if (month === 1) {
      firstPaymentCents = payment;
    }
    lastPaymentCents = payment;
    noteInterestCents += interest;
    notePresentValueCents +=
      payment / Math.pow(1 + monthlyDiscountRate, month);
    outstanding -= principal;
  }

  const earnOutPresentValueCents = Math.round(
    payout.value.payoutCents /
      Math.pow(1 + monthlyDiscountRate, input.earnOutTermMonths),
  );
  const roundedNotePresentValueCents = Math.round(notePresentValueCents);
  const presentValueCents =
    cashCents + roundedNotePresentValueCents + earnOutPresentValueCents;
  const nominalCents =
    cashCents +
    notePrincipalCents +
    noteInterestCents +
    payout.value.payoutCents;

  return ok({
    priceCents: input.priceCents,
    cashCents,
    notePrincipalCents,
    earnOutTargetCents,
    noteInterestCents,
    earnOutPayoutCents: payout.value.payoutCents,
    nominalCents,
    presentValueCents,
    cashPresentValueCents: cashCents,
    notePresentValueCents: roundedNotePresentValueCents,
    earnOutPresentValueCents,
    timeValueDiscountCents: nominalCents - presentValueCents,
    monthsToFullPayment: Math.max(
      input.noteTermMonths,
      input.earnOutTermMonths,
    ),
    noteFirstPaymentCents: firstPaymentCents,
    noteLastPaymentCents: lastPaymentCents,
  });
}