《独立开发者的商业指南·收入与财务工程》4.3 一次性收入与经常性收入的估值差

ARR = MRR × 12 = 20,020 × 12 = $240,240
估值 = 3.2 × 240,240 = $768,768

标价收入 = 19.99 × 9,600 = $191,904
净得 = 191,904 − 退款 7,676 − 平台分成 44,215 − 支付费 1,842
     = $138,171
估值 = 1.8 × 138,171 = $248,708（1.8 × 138,171 = 248,707.8）

SDE = 毛利 − 运营费用 = 130,320 − 96,000 = $34,320
估值 = 4.5 × 34,320 = $154,440

收入倍数 = 估值 ÷ 收入

经常性中值 = 240,240 × 3.25 = $780,780
一次性中值 = 240,240 × 1.50 = $360,360
中值差 = 780,780 − 360,360 = $420,420

LedgerLite = 130,240 ÷ 240,240 = 54.2%
Tidecast   = 121,171 ÷ 138,171 = 87.7%
Nord       = 34,320 ÷ 154,320 = 22.2%

// file: src/fin/valuation-gap.ts
// tier: L1
// verify: node --test test/fin/valuation-gap.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 MultipleBand = {
  lowBps: Bps;
  highBps: Bps;
};

export type ValuationRange = {
  lowBps: Bps;
  midBps: Bps;
  highBps: Bps;
  lowCents: Cents;
  midCents: Cents;
  highCents: Cents;
};

export type ValuationGap = {
  first: ValuationRange;
  second: ValuationRange;
  lowGapCents: Cents;
  midGapCents: Cents;
  highGapCents: Cents;
};

export const RECURRING_BAND: MultipleBand = {
  lowBps: 25000,
  highBps: 40000,
};

export const ONE_TIME_BAND: MultipleBand = {
  lowBps: 10000,
  highBps: 20000,
};

function checkBand(band: MultipleBand): string | null {
  for (const value of [band.lowBps, band.highBps]) {
    if (!Number.isInteger(value) || value < 0) {
      return "multiple must be a non-negative integer in basis points";
    }
  }
  if (band.lowBps > band.highBps) {
    return "low multiple must not exceed high multiple";
  }
  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;
}

function checkRevenue(revenueCents: Cents): string | null {
  if (!Number.isInteger(revenueCents) || revenueCents <= 0) {
    return "revenue must be a positive integer amount in cents";
  }
  return null;
}

/**
 * Linear blend between the one-time band (0% recurring) and the recurring band
 * (100% recurring). The bands are teaching parameters, not observed prices.
 */
export function blendedBand(
  recurringShareBps: Bps,
  recurring: MultipleBand = RECURRING_BAND,
  oneTime: MultipleBand = ONE_TIME_BAND,
): Result<MultipleBand> {
  const shareError = checkShare(recurringShareBps);
  if (shareError) {
    return fail(shareError);
  }
  const recurringError = checkBand(recurring);
  if (recurringError) {
    return fail(recurringError);
  }
  const oneTimeError = checkBand(oneTime);
  if (oneTimeError) {
    return fail(oneTimeError);
  }
  const low =
    oneTime.lowBps +
    Math.round(
      ((recurring.lowBps - oneTime.lowBps) * recurringShareBps) / 10000,
    );
  const high =
    oneTime.highBps +
    Math.round(
      ((recurring.highBps - oneTime.highBps) * recurringShareBps) / 10000,
    );
  return ok({ lowBps: low, highBps: high });
}

export function valuationRange(
  revenueCents: Cents,
  band: MultipleBand,
): Result<ValuationRange> {
  const revenueError = checkRevenue(revenueCents);
  if (revenueError) {
    return fail(revenueError);
  }
  const bandError = checkBand(band);
  if (bandError) {
    return fail(bandError);
  }
  const midBps = Math.round((band.lowBps + band.highBps) / 2);
  return ok({
    lowBps: band.lowBps,
    midBps,
    highBps: band.highBps,
    lowCents: applyRate(revenueCents, band.lowBps),
    midCents: applyRate(revenueCents, midBps),
    highCents: applyRate(revenueCents, band.highBps),
  });
}

/**
 * Two structures valued on the same revenue. Positive gaps mean the first
 * structure is worth more; the sign is meaningful.
 */
export function valuationGap(
  revenueCents: Cents,
  firstShareBps: Bps,
  secondShareBps: Bps,
): Result<ValuationGap> {
  const firstBand = blendedBand(firstShareBps);
  if (!firstBand.ok) {
    return firstBand;
  }
  const secondBand = blendedBand(secondShareBps);
  if (!secondBand.ok) {
    return secondBand;
  }
  const first = valuationRange(revenueCents, firstBand.value);
  if (!first.ok) {
    return first;
  }
  const second = valuationRange(revenueCents, secondBand.value);
  if (!second.ok) {
    return second;
  }
  return ok({
    first: first.value,
    second: second.value,
    lowGapCents: first.value.lowCents - second.value.lowCents,
    midGapCents: first.value.midCents - second.value.midCents,
    highGapCents: first.value.highCents - second.value.highCents,
  });
}

/** Convert any valuation anchor into a multiple of revenue for comparison. */
export function impliedRevenueMultiple(
  valuationCents: Cents,
  revenueCents: Cents,
): Result<Bps> {
  if (!Number.isInteger(valuationCents) || valuationCents < 0) {
    return fail("valuation must be a non-negative integer amount in cents");
  }
  const revenueError = checkRevenue(revenueCents);
  if (revenueError) {
    return fail(revenueError);
  }
  return ok(divide(valuationCents, revenueCents));
}