《独立开发者的商业指南·资本与退出》2.3 合伙人协议与退出机制

// file: src/capital/partner-exit.ts
// tier: L1
// verify: node --test test/capital/partner-exit.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 BuyoutTerms = {
  sdeCents: Cents;
  multipleBps: Bps;
  equityBps: Bps;
};

export type InstallmentPlan = {
  monthlyCents: Cents;
  lastCents: Cents;
  months: number;
  totalCents: Cents;
};

export type CashPressure = {
  monthlySdeCents: Cents;
  monthlyAfterTaxCents: Cents;
  paymentToSdeBps: Bps;
  paymentToCashBps: Bps;
  shortfallCents: Cents;
};

export type DragComparison = {
  differenceCents: Cents;
  discountBps: Bps;
};

export type Holdback = {
  heldCents: Cents;
  releasedCents: Cents;
};

/** Equity value = SDE x multiple x equity share. */
export function buyoutValue(terms: BuyoutTerms): Result<Cents> {
  if (!Number.isInteger(terms.sdeCents) || terms.sdeCents < 0) {
    return fail("SDE must be a non-negative integer amount");
  }
  if (!Number.isInteger(terms.multipleBps) || terms.multipleBps < 0) {
    return fail("multiple must be a non-negative integer in basis points");
  }
  if (
    !Number.isInteger(terms.equityBps) ||
    terms.equityBps < 0 ||
    terms.equityBps > 10000
  ) {
    return fail("equity must be between zero and 10000 basis points");
  }
  const enterpriseCents = applyRate(terms.sdeCents, terms.multipleBps);
  return ok(applyRate(enterpriseCents, terms.equityBps));
}

/** Equal installments; the final payment absorbs any rounding remainder. */
export function installmentPlan(
  principalCents: Cents,
  months: number,
): Result<InstallmentPlan> {
  if (!Number.isInteger(principalCents) || principalCents < 0) {
    return fail("principal must be a non-negative integer amount");
  }
  if (!Number.isInteger(months) || months <= 0) {
    return fail("months must be a positive integer");
  }
  const monthlyCents = Math.floor(principalCents / months);
  const lastCents = principalCents - monthlyCents * (months - 1);
  return ok({
    monthlyCents,
    lastCents,
    months,
    totalCents: monthlyCents * (months - 1) + lastCents,
  });
}

/** Monthly payment measured against monthly SDE and monthly after-tax cash. */
export function cashPressure(
  monthlyPaymentCents: Cents,
  annualSdeCents: Cents,
  annualAfterTaxCents: Cents,
): Result<CashPressure> {
  if (!Number.isInteger(monthlyPaymentCents) || monthlyPaymentCents < 0) {
    return fail("payment must be a non-negative integer amount");
  }
  if (!Number.isInteger(annualSdeCents) || annualSdeCents <= 0) {
    return fail("annual SDE must be a positive integer amount");
  }
  if (!Number.isInteger(annualAfterTaxCents) || annualAfterTaxCents < 0) {
    return fail("annual after-tax cash must be a non-negative integer amount");
  }
  const monthlySdeCents = Math.round(annualSdeCents / 12);
  const monthlyAfterTaxCents = Math.round(annualAfterTaxCents / 12);
  if (monthlySdeCents <= 0) {
    return fail("monthly SDE must be positive");
  }
  return ok({
    monthlySdeCents,
    monthlyAfterTaxCents,
    paymentToSdeBps: divide(monthlyPaymentCents, monthlySdeCents),
    paymentToCashBps:
      monthlyAfterTaxCents === 0
        ? 0
        : divide(monthlyPaymentCents, monthlyAfterTaxCents),
    shortfallCents: Math.max(0, monthlyPaymentCents - monthlyAfterTaxCents),
  });
}

/** Gap between a full-price buyout and a lower-multiple drag sale. */
export function dragDiscount(
  buyoutCents: Cents,
  dragCents: Cents,
): Result<DragComparison> {
  if (!Number.isInteger(buyoutCents) || buyoutCents <= 0) {
    return fail("buyout value must be a positive integer amount");
  }
  if (!Number.isInteger(dragCents) || dragCents < 0) {
    return fail("drag value must be a non-negative integer amount");
  }
  return ok({
    differenceCents: buyoutCents - dragCents,
    discountBps: divide(buyoutCents - dragCents, buyoutCents),
  });
}

/** Amount held back from closing and the amount released later. */
export function holdback(
  principalCents: Cents,
  holdbackBps: Bps,
): Result<Holdback> {
  if (!Number.isInteger(principalCents) || principalCents < 0) {
    return fail("principal must be a non-negative integer amount");
  }
  if (
    !Number.isInteger(holdbackBps) ||
    holdbackBps < 0 ||
    holdbackBps > 10000
  ) {
    return fail("holdback must be between zero and 10000 basis points");
  }
  const heldCents = applyRate(principalCents, holdbackBps);
  return ok({
    heldCents,
    releasedCents: principalCents - heldCents,
  });
}

/** Buyout price expressed as years of SDE. */
export function sdeYears(
  principalCents: Cents,
  annualSdeCents: Cents,
): Result<Bps> {
  if (!Number.isInteger(principalCents) || principalCents < 0) {
    return fail("principal must be a non-negative integer amount");
  }
  if (!Number.isInteger(annualSdeCents) || annualSdeCents <= 0) {
    return fail("annual SDE must be a positive integer amount");
  }
  return ok(divide(principalCents, annualSdeCents));
}