《独立开发者的商业指南·资本与退出》5.2 DCF 与情景加权

FCF_t = FCF_{t-1} × (1 + g)
企业价值 = Σ FCF_t ÷ (1 + r)^t + 终值 ÷ (1 + r)^5
终值 = FCF_5 × 终值倍数

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

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

export type DcfInput = {
  startingFcfCents: Cents;
  growthBps: Bps;
  discountBps: Bps;
  terminalMultipleBps: Bps;
  years: number;
};

export type DcfProjection = {
  year: number;
  fcfCents: Cents;
  presentValueCents: Cents;
};

export type DcfResult = {
  projections: DcfProjection[];
  terminalValueCents: Cents;
  terminalPresentValueCents: Cents;
  enterpriseValueCents: Cents;
  terminalShareBps: Bps;
};

export type Scenario = {
  name: string;
  weightBps: Bps;
  input: DcfInput;
};

export type ScenarioResult = {
  name: string;
  weightBps: Bps;
  enterpriseValueCents: Cents;
  terminalShareBps: Bps;
};

export type WeightedDcf = {
  scenarios: ScenarioResult[];
  lowCents: Cents;
  highCents: Cents;
  weightedCents: Cents;
  weightedTerminalShareBps: Bps;
};

export type CrossCheckVerdict = "aligned" | "dcf-high" | "dcf-low";

export type CrossCheck = {
  dcfCents: Cents;
  multipleCents: Cents;
  gapBps: Bps;
  toleranceBps: Bps;
  verdict: CrossCheckVerdict;
  note: string;
};

function checkInput(input: DcfInput): string | null {
  if (
    !Number.isInteger(input.startingFcfCents) ||
    input.startingFcfCents <= 0
  ) {
    return "starting free cash flow must be a positive integer amount in cents";
  }
  if (!Number.isInteger(input.growthBps) || input.growthBps <= -10000) {
    return "growth must be an integer above -10000 bps";
  }
  if (!Number.isInteger(input.discountBps) || input.discountBps <= 0) {
    return "discount rate must be a positive integer in basis points";
  }
  if (input.discountBps > 10000) {
    return "discount rate above 10000 bps is outside this teaching model";
  }
  if (
    !Number.isInteger(input.terminalMultipleBps) ||
    input.terminalMultipleBps <= 0
  ) {
    return "terminal multiple must be a positive integer in basis points";
  }
  if (!Number.isInteger(input.years) || input.years < 1 || input.years > 10) {
    return "years must be an integer between 1 and 10";
  }
  return null;
}

/**
 * Five-year explicit forecast plus a terminal multiple. Growth, discount rate
 * and terminal multiple are teaching assumptions, not market data. The
 * terminal share is returned because a DCF whose value is mostly terminal is a
 * multiple in disguise.
 */
export function dcf(input: DcfInput): Result<DcfResult> {
  const error = checkInput(input);
  if (error) {
    return fail(error);
  }

  const growthFactor = 1 + ratio(input.growthBps);
  const discountFactor = 1 + ratio(input.discountBps);
  let currentCents = input.startingFcfCents;
  const projections: DcfProjection[] = [];
  let presentValueTotal = 0;

  for (let year = 1; year <= input.years; year += 1) {
    currentCents = Math.round(currentCents * growthFactor);
    const presentValueCents = Math.round(
      currentCents / Math.pow(discountFactor, year),
    );
    projections.push({ year, fcfCents: currentCents, presentValueCents });
    presentValueTotal += presentValueCents;
  }

  const terminalValueCents = applyRate(
    currentCents,
    input.terminalMultipleBps,
  );
  const terminalPresentValueCents = Math.round(
    terminalValueCents / Math.pow(discountFactor, input.years),
  );
  const enterpriseValueCents = presentValueTotal + terminalPresentValueCents;

  return ok({
    projections,
    terminalValueCents,
    terminalPresentValueCents,
    enterpriseValueCents,
    terminalShareBps: divide(
      terminalPresentValueCents,
      enterpriseValueCents,
    ),
  });
}

/**
 * Weighted scenarios are not a vote. The weights are teaching assumptions that
 * must be written down before the result is known, and the low/high values are
 * kept alongside the weighted value so one optimistic case cannot hide the
 * downside.
 */
export function weightedScenarios(
  scenarios: Scenario[],
): Result<WeightedDcf> {
  if (scenarios.length === 0) {
    return fail("at least one scenario is required");
  }

  let weightTotal = 0;
  let weightedEnterpriseValue = 0;
  let weightedTerminalValue = 0;
  let lowCents = Number.POSITIVE_INFINITY;
  let highCents = 0;
  const results: ScenarioResult[] = [];

  for (const scenario of scenarios) {
    if (typeof scenario.name !== "string" || scenario.name.trim() === "") {
      return fail("scenario name must be a non-empty string");
    }
    if (
      !Number.isInteger(scenario.weightBps) ||
      scenario.weightBps < 0 ||
      scenario.weightBps > 10000
    ) {
      return fail("scenario weight must be between 0 and 10000 bps");
    }
    const error = checkInput(scenario.input);
    if (error) {
      return fail(error);
    }
    const result = dcf(scenario.input);
    if (!result.ok) {
      return result;
    }
    weightTotal += scenario.weightBps;
    results.push({
      name: scenario.name,
      weightBps: scenario.weightBps,
      enterpriseValueCents: result.value.enterpriseValueCents,
      terminalShareBps: result.value.terminalShareBps,
    });
    weightedEnterpriseValue +=
      result.value.enterpriseValueCents * scenario.weightBps;
    weightedTerminalValue +=
      result.value.terminalPresentValueCents * scenario.weightBps;
    lowCents = Math.min(lowCents, result.value.enterpriseValueCents);
    highCents = Math.max(highCents, result.value.enterpriseValueCents);
  }

  if (weightTotal !== 10000) {
    return fail("scenario weights must add up to 10000 bps");
  }

  return ok({
    scenarios: results,
    lowCents,
    highCents,
    weightedCents: Math.round(weightedEnterpriseValue / 10000),
    weightedTerminalShareBps: divide(
      weightedTerminalValue,
      weightedEnterpriseValue,
    ),
  });
}

/**
 * When DCF and a market multiple disagree by more than the tolerance, the
 * question is not which number is more precise but which assumptions can be
 * verified. A high DCF usually means the terminal value is doing the work; a
 * low DCF means the multiple is paying for growth the cash flow cannot support.
 */
export function crossCheck(
  dcfCents: Cents,
  multipleCents: Cents,
  toleranceBps: Bps = 3000,
): Result<CrossCheck> {
  if (!Number.isInteger(dcfCents) || dcfCents <= 0) {
    return fail("dcf value must be a positive integer amount in cents");
  }
  if (!Number.isInteger(multipleCents) || multipleCents <= 0) {
    return fail("multiple value must be a positive integer amount in cents");
  }
  if (
    !Number.isInteger(toleranceBps) ||
    toleranceBps < 0 ||
    toleranceBps > 10000
  ) {
    return fail("tolerance must be between 0 and 10000 bps");
  }

  const gapBps = divide(dcfCents - multipleCents, multipleCents);

  if (Math.abs(gapBps) <= toleranceBps) {
    return ok({
      dcfCents,
      multipleCents,
      gapBps,
      toleranceBps,
      verdict: "aligned",
      note: "dcf and multiple are within tolerance; compare assumptions, not just the number",
    });
  }

  if (gapBps > toleranceBps) {
    return ok({
      dcfCents,
      multipleCents,
      gapBps,
      toleranceBps,
      verdict: "dcf-high",
      note: "dcf is far above the multiple; trust the multiple unless a buyer can name a measurable synergy",
    });
  }

  return ok({
    dcfCents,
    multipleCents,
    gapBps,
    toleranceBps,
    verdict: "dcf-low",
    note: "dcf is far below the multiple; trust the dcf unless the buyer can name a measurable synergy",
  });
}