《独立开发者的商业指南·收入与财务工程》11.3 估值区间与谈判区间

区间宽度 = (高值 − 低值) ÷ 基准值

// file: src/value/range.ts
// tier: L1
// verify: node --test test/value/range.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 ScenarioMultiples = {
  pessimisticBps: Bps;
  baseBps: Bps;
  optimisticBps: Bps;
};

export type ScenarioRange = {
  lowCents: Cents;
  baseCents: Cents;
  highCents: Cents;
  spreadBps: Bps;
  widthBps: Bps;
};

export type DealTerms = {
  cashShareBps: Bps;
  earnOutShareBps: Bps;
  escrowShareBps: Bps;
  earnOutProbabilityBps: Bps;
  escrowReleaseProbabilityBps: Bps;
  workingCapitalAdjustmentCents: Cents;
};

export type NetProceeds = {
  headlineCents: Cents;
  upfrontCents: Cents;
  escrowExpectedCents: Cents;
  earnOutExpectedCents: Cents;
  adjustmentCents: Cents;
  worstCents: Cents;
  expectedCents: Cents;
  bestCents: Cents;
  haircutBps: Bps;
};

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 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;
}

export function scenarioMultiples(
  baseBps: Bps,
  spreadBps: Bps,
): Result<ScenarioMultiples> {
  if (!Number.isInteger(baseBps) || baseBps <= 0) {
    return fail("base multiple must be a positive integer in basis points");
  }
  if (!Number.isInteger(spreadBps) || spreadBps < 0) {
    return fail("spread must be a non-negative integer in basis points");
  }
  if (baseBps - spreadBps <= 0) {
    return fail("pessimistic multiple must remain positive");
  }
  return ok({
    pessimisticBps: baseBps - spreadBps,
    baseBps,
    optimisticBps: baseBps + spreadBps,
  });
}

/**
 * Build a three-point band around a base multiple. Width is measured against
 * the base-case value so a wider band reads directly as a larger risk signal.
 */
export function scenarioRange(
  baseCents: Cents,
  baseMultipleBps: Bps,
  spreadBps: Bps,
): Result<ScenarioRange> {
  const amountError = checkAmount(baseCents, "base");
  if (amountError) {
    return fail(amountError);
  }
  const multiples = scenarioMultiples(baseMultipleBps, spreadBps);
  if (!multiples.ok) {
    return multiples;
  }
  const lowCents = applyRate(baseCents, multiples.value.pessimisticBps);
  const baseValueCents = applyRate(baseCents, multiples.value.baseBps);
  const highCents = applyRate(baseCents, multiples.value.optimisticBps);
  return ok({
    lowCents,
    baseCents: baseValueCents,
    highCents,
    spreadBps,
    widthBps: divide(highCents - lowCents, baseValueCents),
  });
}

function checkShares(terms: DealTerms): string | null {
  const cashError = checkBps(terms.cashShareBps, "cash share");
  if (cashError) {
    return cashError;
  }
  const earnOutError = checkBps(terms.earnOutShareBps, "earn-out share");
  if (earnOutError) {
    return earnOutError;
  }
  const escrowError = checkBps(terms.escrowShareBps, "escrow share");
  if (escrowError) {
    return escrowError;
  }
  if (terms.cashShareBps + terms.earnOutShareBps !== 10000) {
    return "cash plus earn-out shares must add up to 10000 bps";
  }
  if (terms.escrowShareBps > terms.cashShareBps) {
    return "escrow share cannot exceed the cash share";
  }
  const earnOutProbabilityError = checkBps(
    terms.earnOutProbabilityBps,
    "earn-out probability",
  );
  if (earnOutProbabilityError) {
    return earnOutProbabilityError;
  }
  const escrowProbabilityError = checkBps(
    terms.escrowReleaseProbabilityBps,
    "escrow release probability",
  );
  if (escrowProbabilityError) {
    return escrowProbabilityError;
  }
  if (!Number.isInteger(terms.workingCapitalAdjustmentCents)) {
    return "working capital adjustment must be an integer amount in cents";
  }
  return null;
}

/**
 * Earn-out and escrow are not additional money on top of the headline price;
 * they are parts of the headline that may not be paid. The expected value uses
 * explicit probabilities, while worst and best bracket the structural range.
 */
export function netProceeds(
  headlineCents: Cents,
  terms: DealTerms,
): Result<NetProceeds> {
  const amountError = checkAmount(headlineCents, "headline");
  if (amountError) {
    return fail(amountError);
  }
  const shareError = checkShares(terms);
  if (shareError) {
    return fail(shareError);
  }
  const cashCents = applyRate(headlineCents, terms.cashShareBps);
  const earnOutCents = applyRate(headlineCents, terms.earnOutShareBps);
  const escrowCents = applyRate(headlineCents, terms.escrowShareBps);
  const upfrontCents = cashCents - escrowCents;
  const escrowExpectedCents = applyRate(
    escrowCents,
    terms.escrowReleaseProbabilityBps,
  );
  const earnOutExpectedCents = applyRate(
    earnOutCents,
    terms.earnOutProbabilityBps,
  );
  const adjustmentCents = terms.workingCapitalAdjustmentCents;
  const worstCents = upfrontCents - adjustmentCents;
  const expectedCents =
    upfrontCents +
    escrowExpectedCents +
    earnOutExpectedCents -
    adjustmentCents;
  const bestCents = upfrontCents + escrowCents + earnOutCents - adjustmentCents;
  return ok({
    headlineCents,
    upfrontCents,
    escrowExpectedCents,
    earnOutExpectedCents,
    adjustmentCents,
    worstCents,
    expectedCents,
    bestCents,
    haircutBps: divide(headlineCents - expectedCents, headlineCents),
  });
}