《独立开发者的商业指南·资本与退出》12.3 家族、合伙与继承

// file: src/capital/succession.ts
// tier: L1
// verify: node --test test/capital/succession.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 BuySellRange = {
  highValueCents: Cents;
  lowValueCents: Cents;
  differenceCents: Cents;
  discountBps: Bps;
};

export type PaymentPlan = {
  principalCents: Cents;
  downPaymentCents: Cents;
  financedCents: Cents;
  monthlyCents: Cents;
  lastCents: Cents;
  months: number;
  totalCents: Cents;
};

export type TransferStep = {
  year: number;
  trancheBps: Bps;
  cumulativeBps: Bps;
  remainingBps: Bps;
};

export type StagedTransfer = {
  startBps: Bps;
  trancheBps: Bps;
  years: number;
  thresholdBps: Bps;
  steps: TransferStep[];
  firstThresholdYear: number | null;
  finalRemainingBps: Bps;
};

export type InsuranceCoverage = {
  benefitCents: Cents;
  annualPremiumCents: Cents;
  buyoutCents: Cents;
  coverageBps: Bps;
  gapCents: Cents;
  funded: boolean;
};

function amountError(value: Cents, label: string): string | null {
  return Number.isInteger(value) && value >= 0
    ? null
    : `${label} must be a non-negative integer amount in cents`;
}

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

/**
 * A buy-sell agreement needs a formula, not a single number: SDE x multiple x
 * equity share. The two multiples bracket what the partners accept in a good
 * year and what a buyer would pay for the same business. The discount between
 * them is the price of liquidity.
 */
export function buySellRange(
  sdeCents: Cents,
  equityBps: Bps,
  highMultipleBps: Bps,
  lowMultipleBps: Bps,
): Result<BuySellRange> {
  const sdeError = amountError(sdeCents, "SDE");
  if (sdeError) return fail(sdeError);
  if (sdeCents === 0) return fail("SDE must be positive");
  const equityError = bpsError(equityBps, "equity");
  if (equityError) return fail(equityError);
  for (const [value, label] of [
    [highMultipleBps, "high multiple"],
    [lowMultipleBps, "low multiple"],
  ] as Array<[Bps, string]>) {
    if (!Number.isInteger(value) || value < 0) {
      return fail(`${label} must be a non-negative integer in basis points`);
    }
  }
  if (lowMultipleBps > highMultipleBps) {
    return fail("low multiple cannot exceed the high multiple");
  }
  const highValueCents = applyRate(applyRate(sdeCents, highMultipleBps), equityBps);
  const lowValueCents = applyRate(applyRate(sdeCents, lowMultipleBps), equityBps);
  const differenceCents = highValueCents - lowValueCents;
  return ok({
    highValueCents,
    lowValueCents,
    differenceCents,
    discountBps: highValueCents === 0 ? 0 : divide(differenceCents, highValueCents),
  });
}

/**
 * A down payment changes the size of the note, not the total price. The
 * financed balance is split into equal payments and the final payment absorbs
 * the rounding remainder, so the schedule always sums to the price.
 */
export function paymentPlan(
  principalCents: Cents,
  downPaymentBps: Bps,
  months: number,
): Result<PaymentPlan> {
  const principalError = amountError(principalCents, "principal");
  if (principalError) return fail(principalError);
  if (principalCents === 0) return fail("principal must be positive");
  const downError = bpsError(downPaymentBps, "down payment");
  if (downError) return fail(downError);
  if (!Number.isInteger(months) || months <= 0) {
    return fail("months must be a positive integer");
  }
  const downPaymentCents = applyRate(principalCents, downPaymentBps);
  const financedCents = principalCents - downPaymentCents;
  const monthlyCents = Math.floor(financedCents / months);
  return ok({
    principalCents,
    downPaymentCents,
    financedCents,
    monthlyCents,
    lastCents: financedCents - monthlyCents * (months - 1),
    months,
    totalCents: downPaymentCents + financedCents,
  });
}

/**
 * Staged transfer separates the timing of ownership from the timing of cash.
 * Each annual tranche is applied against the remaining holding; the threshold
 * year is the first year the cumulative transfer reaches the control or
 * disclosure line the agreement cares about.
 */
export function stagedTransfer(
  startBps: Bps,
  trancheBps: Bps,
  years: number,
  thresholdBps: Bps,
): Result<StagedTransfer> {
  const startError = bpsError(startBps, "starting stake");
  if (startError) return fail(startError);
  if (!Number.isInteger(trancheBps) || trancheBps <= 0 || trancheBps > 10000) {
    return fail("tranche must be a positive integer up to 10000 bps");
  }
  if (!Number.isInteger(years) || years <= 0) {
    return fail("years must be a positive integer");
  }
  const thresholdError = bpsError(thresholdBps, "threshold");
  if (thresholdError) return fail(thresholdError);
  if (trancheBps * years > startBps) {
    return fail("tranches exceed the starting stake");
  }
  const steps: TransferStep[] = [];
  let firstThresholdYear: number | null = null;
  let previousCumulative = 0;
  for (let year = 1; year <= years; year += 1) {
    const cumulativeBps = trancheBps * year;
    if (
      firstThresholdYear === null &&
      thresholdBps > 0 &&
      cumulativeBps >= thresholdBps &&
      previousCumulative < thresholdBps
    ) {
      firstThresholdYear = year;
    }
    steps.push({
      year,
      trancheBps,
      cumulativeBps,
      remainingBps: startBps - cumulativeBps,
    });
    previousCumulative = cumulativeBps;
  }
  return ok({
    startBps,
    trancheBps,
    years,
    thresholdBps,
    steps,
    firstThresholdYear,
    finalRemainingBps: startBps - trancheBps * years,
  });
}

/**
 * Insurance-funded buy-sell is a coverage calculation before it is a policy
 * purchase. A policy that covers 80% still leaves a 20% cash call at exactly
 * the moment the surviving partner has the least liquidity.
 */
export function insuranceCoverage(
  benefitCents: Cents,
  premiumBps: Bps,
  buyoutCents: Cents,
): Result<InsuranceCoverage> {
  for (const [value, label] of [
    [benefitCents, "benefit"],
    [buyoutCents, "buyout"],
  ] as Array<[Cents, string]>) {
    const error = amountError(value, label);
    if (error) return fail(error);
  }
  if (buyoutCents === 0) return fail("buyout must be positive");
  const premiumError = bpsError(premiumBps, "premium");
  if (premiumError) return fail(premiumError);
  return ok({
    benefitCents,
    annualPremiumCents: applyRate(benefitCents, premiumBps),
    buyoutCents,
    coverageBps: divide(benefitCents, buyoutCents),
    gapCents: Math.max(0, buyoutCents - benefitCents),
    funded: benefitCents >= buyoutCents,
  });
}