《独立开发者的商业指南·资本与退出》5.1 ARR/SDE/EBITDA 倍数

// file: src/capital/multiples.ts
// tier: L1
// verify: node --test test/capital/multiples.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" | "ebitda";
export type BusinessModel =
  | "subscription"
  | "transactional"
  | "service"
  | "company";

export const BASE_ORDER: MultipleBase[] = ["arr", "revenue", "sde", "ebitda"];

export type BusinessProfile = {
  model: BusinessModel;
  annualRevenueCents: Cents;
  arrCents: Cents;
  sdeCents: Cents;
  ebitdaCents: Cents;
  recurringShareBps: Bps;
  ownerOperated: boolean;
  ownerSalaryCents: Cents;
  profitable: boolean;
};

export type BaseSelection = {
  base: MultipleBase;
  amountCents: Cents;
  warnings: string[];
};

export type BaseQuote = {
  base: MultipleBase;
  baseCents: Cents;
  multipleBps: Bps;
  valueCents: Cents;
  recommended: boolean;
};

export type BaseComparison = {
  selection: BaseSelection;
  quotes: BaseQuote[];
  lowCents: Cents;
  highCents: Cents;
  spreadCents: Cents;
  spreadBps: Bps;
};

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

function checkBps(value: Bps, label: string): string | null {
  if (!Number.isInteger(value) || value < 0 || value > 10000) {
    return `${label} must be between 0 and 10000 bps`;
  }
  return null;
}

function checkProfile(profile: BusinessProfile): string | null {
  const models: BusinessModel[] = [
    "subscription",
    "transactional",
    "service",
    "company",
  ];
  if (!models.includes(profile.model)) {
    return "unknown business model";
  }
  const amounts: Array<[Cents, string]> = [
    [profile.annualRevenueCents, "annual revenue"],
    [profile.arrCents, "arr"],
    [profile.ownerSalaryCents, "owner salary"],
  ];
  for (const [value, label] of amounts) {
    const error = checkAmount(value, label);
    if (error) {
      return error;
    }
  }
  if (profile.arrCents > profile.annualRevenueCents) {
    return "arr cannot exceed annual revenue";
  }
  if (!Number.isInteger(profile.sdeCents)) {
    return "sde must be an integer amount in cents";
  }
  if (!Number.isInteger(profile.ebitdaCents)) {
    return "ebitda must be an integer amount in cents";
  }
  const shareError = checkBps(profile.recurringShareBps, "recurring share");
  if (shareError) {
    return shareError;
  }
  if (
    typeof profile.ownerOperated !== "boolean" ||
    typeof profile.profitable !== "boolean"
  ) {
    return "owner-operated and profitable flags must be booleans";
  }
  return null;
}

/**
 * Pick the base before picking the multiple. ARR needs recurring revenue, SDE
 * needs an owner-operated profit base, EBITDA needs professional management,
 * and a transactional product falls back to revenue.
 */
export function selectBase(
  profile: BusinessProfile,
): Result<BaseSelection> {
  const error = checkProfile(profile);
  if (error) {
    return fail(error);
  }
  const warnings: string[] = [];
  if (profile.model === "subscription" && profile.recurringShareBps < 9000) {
    warnings.push(
      "recurring share below 90%: normalize the recurring amount before using ARR",
    );
  }
  if (
    profile.model === "subscription" &&
    profile.recurringShareBps >= 9000 &&
    profile.arrCents > 0
  ) {
    if (profile.arrCents !== profile.annualRevenueCents) {
      warnings.push(
        "arr is lower than total revenue; quote only the recurring portion",
      );
    }
    return ok({ base: "arr", amountCents: profile.arrCents, warnings });
  }
  if (profile.model === "transactional" && profile.annualRevenueCents > 0) {
    warnings.push(
      "revenue multiple buys the current title, not a renewal base",
    );
    return ok({
      base: "revenue",
      amountCents: profile.annualRevenueCents,
      warnings,
    });
  }
  if (
    profile.model === "company" &&
    profile.profitable &&
    profile.ebitdaCents > 0
  ) {
    warnings.push("normalize one-off items before applying an EBITDA multiple");
    return ok({ base: "ebitda", amountCents: profile.ebitdaCents, warnings });
  }
  if (profile.ownerOperated && profile.sdeCents > 0) {
    if (profile.ownerSalaryCents <= 0) {
      warnings.push("owner salary is not stated; sde may not be comparable");
    }
    if (profile.ebitdaCents > 0) {
      warnings.push(
        "ebitda needs an owner-salary normalization before comparison",
      );
    }
    return ok({ base: "sde", amountCents: profile.sdeCents, warnings });
  }

  if (profile.profitable && profile.ebitdaCents > 0) {
    warnings.push("normalize one-off items before applying an EBITDA multiple");
    return ok({ base: "ebitda", amountCents: profile.ebitdaCents, warnings });
  }

  if (profile.sdeCents > 0) {
    return ok({ base: "sde", amountCents: profile.sdeCents, warnings });
  }

  if (profile.annualRevenueCents > 0) {
    warnings.push("revenue multiple does not imply recurrence or profitability");
    return ok({
      base: "revenue",
      amountCents: profile.annualRevenueCents,
      warnings,
    });
  }

  return fail("no positive base available");
}

/** Apply a multiple to one base; the caller is responsible for base choice. */
export function quoteBase(
  base: MultipleBase,
  baseCents: Cents,
  multipleBps: Bps,
): Result<BaseQuote> {
  if (!BASE_ORDER.includes(base)) {
    return fail("unknown multiple base");
  }
  if (!Number.isInteger(baseCents) || baseCents <= 0) {
    return fail("base must be a positive integer amount in cents");
  }
  if (!Number.isInteger(multipleBps) || multipleBps <= 0) {
    return fail("multiple must be a positive integer in basis points");
  }
  return ok({
    base,
    baseCents,
    multipleBps,
    valueCents: applyRate(baseCents, multipleBps),
    recommended: false,
  });
}

/**
 * Apply the same multiple to every positive base. This is a diagnostic, not a
 * recommendation: it shows how far the price moves when the denominator
 * changes while the headline multiple stays fixed.
 */
export function compareBases(
  profile: BusinessProfile,
  multipleBps: Bps,
): Result<BaseComparison> {
  const selection = selectBase(profile);
  if (!selection.ok) {
    return selection;
  }

  const quotes: BaseQuote[] = [];
  for (const base of BASE_ORDER) {
    const amount =
      base === "arr"
        ? profile.arrCents
        : base === "revenue"
          ? profile.annualRevenueCents
          : base === "sde"
            ? profile.sdeCents
            : profile.ebitdaCents;
    if (amount <= 0) {
      continue;
    }
    const quote = quoteBase(base, amount, multipleBps);
    if (!quote.ok) {
      return quote;
    }
    quotes.push({
      ...quote.value,
      recommended: base === selection.value.base,
    });
  }

  if (quotes.length === 0) {
    return fail("no positive base available");
  }

  let lowCents = quotes[0].valueCents;
  let highCents = quotes[0].valueCents;
  for (const quote of quotes) {
    lowCents = Math.min(lowCents, quote.valueCents);
    highCents = Math.max(highCents, quote.valueCents);
  }

  return ok({
    selection: selection.value,
    quotes,
    lowCents,
    highCents,
    spreadCents: highCents - lowCents,
    spreadBps: divide(highCents - lowCents, lowCents),
  });
}