《独立开发者的商业指南·收入与财务工程》11.1 三种估值口径：ARR 倍数、SDE 倍数、DCF

估值 = 分母 × 倍数
倍数 = 估值 ÷ 分母

// file: src/value/multiple.ts
// tier: L1
// verify: node --test test/value/multiple.test.ts

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

export type MultipleBase = "arr" | "revenue" | "sde";

export type MultipleQuote = {
  base: MultipleBase;
  multipleBps: Bps;
  baseCents: Cents;
  valueCents: Cents;
  recurringShareBps: Bps;
  ownerSalaryDeducted: boolean | null;
  warnings: string[];
};

function checkAmount(amount: Cents, label: string): string | null {
  if (!Number.isInteger(amount) || amount <= 0) {
    return `${label} must be a positive integer amount in cents`;
  }
  return null;
}

function checkMultiple(multipleBps: Bps): string | null {
  if (!Number.isInteger(multipleBps) || multipleBps <= 0) {
    return "multiple must be a positive integer in basis points";
  }
  return null;
}

function checkShare(shareBps: Bps): string | null {
  if (!Number.isInteger(shareBps) || shareBps < 0 || shareBps > 10000) {
    return "recurring share must be between 0 and 10000 bps";
  }
  return null;
}

/**
 * ARR is by definition fully recurring. Passing total revenue as ARR is the
 * most common valuation mistake, so a partial recurring share is rejected.
 */
export function quoteArr(
  arrCents: Cents,
  multipleBps: Bps,
  recurringShareBps: Bps = 10000,
): Result<MultipleQuote> {
  const amountError = checkAmount(arrCents, "arr");
  if (amountError) {
    return fail(amountError);
  }
  const multipleError = checkMultiple(multipleBps);
  if (multipleError) {
    return fail(multipleError);
  }
  const shareError = checkShare(recurringShareBps);
  if (shareError) {
    return fail(shareError);
  }
  if (recurringShareBps !== 10000) {
    return fail("arr base must be fully recurring; pass only the recurring amount");
  }
  return ok({
    base: "arr",
    multipleBps,
    baseCents: arrCents,
    valueCents: applyRate(arrCents, multipleBps),
    recurringShareBps,
    ownerSalaryDeducted: null,
    warnings: [],
  });
}

/**
 * Revenue may mix recurring and one-time income. The quote is valid, but the
 * warnings keep the caller from describing it as recurring or as ARR.
 */
export function quoteRevenue(
  revenueCents: Cents,
  multipleBps: Bps,
  recurringShareBps: Bps = 0,
): Result<MultipleQuote> {
  const amountError = checkAmount(revenueCents, "revenue");
  if (amountError) {
    return fail(amountError);
  }
  const multipleError = checkMultiple(multipleBps);
  if (multipleError) {
    return fail(multipleError);
  }
  const shareError = checkShare(recurringShareBps);
  if (shareError) {
    return fail(shareError);
  }
  const warnings: string[] = [];
  if (recurringShareBps < 10000) {
    warnings.push("revenue base mixes recurring and one-time income");
  }
  if (recurringShareBps === 0) {
    warnings.push("no recurring share: do not label this multiple as ARR");
  }
  return ok({
    base: "revenue",
    multipleBps,
    baseCents: revenueCents,
    valueCents: applyRate(revenueCents, multipleBps),
    recurringShareBps,
    ownerSalaryDeducted: null,
    warnings,
  });
}

/**
 * SDE only means the same thing when owner compensation has been handled the
 * same way. The flag is mandatory; a false value is allowed but warned.
 */
export function quoteSde(
  sdeCents: Cents,
  multipleBps: Bps,
  ownerSalaryDeducted: boolean,
): Result<MultipleQuote> {
  const amountError = checkAmount(sdeCents, "sde");
  if (amountError) {
    return fail(amountError);
  }
  const multipleError = checkMultiple(multipleBps);
  if (multipleError) {
    return fail(multipleError);
  }
  if (typeof ownerSalaryDeducted !== "boolean") {
    return fail("sde quote must state whether owner salary was deducted");
  }
  const warnings: string[] = [];
  if (!ownerSalaryDeducted) {
    warnings.push(
      "owner salary not deducted; this sde is not comparable to a post-salary sde",
    );
  }
  return ok({
    base: "sde",
    multipleBps,
    baseCents: sdeCents,
    valueCents: applyRate(sdeCents, multipleBps),
    recurringShareBps: 0,
    ownerSalaryDeducted,
    warnings,
  });
}

/** Recover the multiple from a price and a base, for checking a quoted anchor. */
export function impliedMultiple(
  valueCents: Cents,
  baseCents: Cents,
): Result<Bps> {
  const valueError = checkAmount(valueCents, "valuation");
  if (valueError) {
    return fail(valueError);
  }
  const baseError = checkAmount(baseCents, "base");
  if (baseError) {
    return fail(baseError);
  }
  return ok(divide(valueCents, baseCents));
}

/**
 * Comparing two multiples is only meaningful when their denominators and
 * adjustments match. Different bases are a hard failure, not a warning.
 */
export function compareQuotes(
  first: MultipleQuote,
  second: MultipleQuote,
): Result<{ differenceBps: Bps }> {
  if (first.base !== second.base) {
    return fail(
      `cannot compare ${first.base} multiple with ${second.base} multiple`,
    );
  }
  if (
    first.base === "sde" &&
    first.ownerSalaryDeducted !== second.ownerSalaryDeducted
  ) {
    return fail("sde quotes differ on owner salary treatment");
  }
  if (
    first.base === "revenue" &&
    first.recurringShareBps !== second.recurringShareBps
  ) {
    return fail("revenue quotes differ on recurring share; normalize the base first");
  }
  return ok({ differenceBps: first.multipleBps - second.multipleBps });
}

/** Convert any quote into a revenue multiple so the denominators match. */
export function toRevenueMultiple(
  quote: MultipleQuote,
  revenueCents: Cents,
): Result<Bps> {
  const revenueError = checkAmount(revenueCents, "revenue");
  if (revenueError) {
    return fail(revenueError);
  }
  return ok(divide(quote.valueCents, revenueCents));
}

MRR = 付费客户数 × 每户月收入
ARR = MRR × 12

SDE = 毛利 − 运营费用

估值 = Σ 未来自由现金流 ÷ (1 + 折现率)^t + 终值 ÷ (1 + 折现率)^n