《独立开发者的商业指南·资本与退出》10.1 税后所得与分期

年应税 = 报价 ÷ 年数
年税额 = 年应税 × 教学税率
年税后 = 年应税 − 年税额
现值 = Σ 年税后 ÷ (1 + 折现率)^年
折现损失 = 一次性税后 − 分期现值

盈亏平衡税率 = 1 − 一次性税后 ÷ (年应税 × 年金系数)
             = 1 − 576,576 ÷ (256,256 × 2.5771)
             = 12.69%

// file: src/capital/after-tax.ts
// tier: L1
// verify: node --test test/capital/after-tax.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 TaxAssumptions = {
  capitalGainsBps: Bps;
  stateBps: Bps;
};

export type AfterTax = {
  grossCents: Cents;
  taxCents: Cents;
  netCents: Cents;
  effectiveRateBps: Bps;
};

export type InstallmentRow = {
  year: number;
  grossCents: Cents;
  taxCents: Cents;
  netCents: Cents;
  discountFactor: number;
  presentValueCents: Cents;
};

export type InstallmentPlan = {
  years: number;
  rows: InstallmentRow[];
  nominalTaxCents: Cents;
  nominalNetCents: Cents;
  presentValueCents: Cents;
  lumpSumNetCents: Cents;
  deferralLossCents: Cents;
  breakEvenTaxBps: Bps;
};

function validBps(value: Bps): boolean {
  return Number.isInteger(value) && value >= 0 && value <= 10000;
}

/**
 * Combines the long-term capital gains rate and the state rate into one
 * teaching rate. Both inputs are assumptions, not a tax table.
 */
export function combinedRateBps(assumptions: TaxAssumptions): Result<Bps> {
  if (
    !validBps(assumptions.capitalGainsBps) ||
    !validBps(assumptions.stateBps)
  ) {
    return fail("tax rates must be between 0 and 10000 basis points");
  }
  const combined = assumptions.capitalGainsBps + assumptions.stateBps;
  if (combined > 10000) {
    return fail("combined tax rate cannot exceed 100%");
  }
  return ok(combined);
}

export function afterTax(
  grossCents: Cents,
  assumptions: TaxAssumptions,
): Result<AfterTax> {
  if (!Number.isInteger(grossCents) || grossCents < 0) {
    return fail("gross proceeds must be a non-negative integer amount");
  }
  const rate = combinedRateBps(assumptions);
  if (!rate.ok) {
    return rate;
  }
  const taxCents = applyRate(grossCents, rate.value);
  const netCents = grossCents - taxCents;
  return ok({
    grossCents,
    taxCents,
    netCents,
    effectiveRateBps: grossCents === 0 ? 0 : divide(taxCents, grossCents),
  });
}

/**
 * Splits proceeds into equal annual installments. The last year absorbs the
 * cent remainder. Every year pays the same teaching rate, and each net amount
 * is discounted to close at the annual discount rate. The break-even tax rate
 * is the rate at which discounted installments equal the lump-sum after-tax
 * amount; above it, deferral loses to paying tax at close.
 */
export function installmentPlan(
  grossCents: Cents,
  years: number,
  assumptions: TaxAssumptions,
  annualDiscountBps: Bps,
): Result<InstallmentPlan> {
  if (!Number.isInteger(grossCents) || grossCents <= 0) {
    return fail("gross proceeds must be a positive integer amount");
  }
  if (!Number.isInteger(years) || years <= 0 || years > 40) {
    return fail("years must be an integer between 1 and 40");
  }
  if (!validBps(annualDiscountBps)) {
    return fail("discount rate must be between 0 and 10000 basis points");
  }
  const rate = combinedRateBps(assumptions);
  if (!rate.ok) {
    return rate;
  }
  const lumpTaxCents = applyRate(grossCents, rate.value);
  const lumpSumNetCents = grossCents - lumpTaxCents;

  const base = Math.floor(grossCents / years);
  const remainder = grossCents - base * years;
  const discountRate = annualDiscountBps / 10000;

  const rows: InstallmentRow[] = [];
  let nominalTaxCents = 0;
  let nominalNetCents = 0;
  let presentValueCents = 0;
  let annuityFactor = 0;

  for (let year = 1; year <= years; year += 1) {
    const gross = year === years ? base + remainder : base;
    const taxCents = applyRate(gross, rate.value);
    const netCents = gross - taxCents;
    const discountFactor = 1 / Math.pow(1 + discountRate, year);
    const rowPresentValueCents = Math.round(netCents * discountFactor);
    nominalTaxCents += taxCents;
    nominalNetCents += netCents;
    presentValueCents += rowPresentValueCents;
    annuityFactor += discountFactor;
    rows.push({
      year,
      grossCents: gross,
      taxCents,
      netCents,
      discountFactor,
      presentValueCents: rowPresentValueCents,
    });
  }

  const averageGrossCents = grossCents / years;
  const breakEvenNetCents = lumpSumNetCents / annuityFactor;
  const rawBreakEvenBps = Math.round(
    (1 - breakEvenNetCents / averageGrossCents) * 10000,
  );
  const breakEvenTaxBps = Math.min(10000, Math.max(0, rawBreakEvenBps));

  return ok({
    years,
    rows,
    nominalTaxCents,
    nominalNetCents,
    presentValueCents,
    lumpSumNetCents,
    deferralLossCents: lumpSumNetCents - presentValueCents,
    breakEvenTaxBps,
  });
}