《独立开发者的商业指南·资本与退出》1.1 自力更生、借款、股权融资

300,000 ÷ 61,299 = 4.89 年 ≈ 59 个月

利息 = 本金 × 年利率 × 年数
月供 = (本金 + 利息) ÷ 月数

post-money = pre-money + 融资额
稀释比例 = 融资额 ÷ post-money

// file: src/capital/funding.ts
// tier: L1
// verify: node --test test/capital/funding.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 FundingSource = "bootstrap" | "debt" | "equity";

export type EquityTerms = {
  raiseCents: Cents;
  preMoneyCents: Cents;
  postMoneyCents: Cents;
  dilutionBps: Bps;
  investorValueCents: Cents;
};

export type DebtTerms = {
  principalCents: Cents;
  annualRateBps: Bps;
  months: number;
  interestCents: Cents;
  totalRepaymentCents: Cents;
  monthlyPaymentCents: Cents;
};

export type BootstrapPlan = {
  requiredCents: Cents;
  annualFreeCashCents: Cents;
  monthlyFreeCashCents: Cents;
  monthsToFund: number;
};

export type FundingOption = {
  source: FundingSource;
  cashNowCents: Cents;
  timeToCashMonths: number;
  explicitCostCents: Cents;
  economicCostCents: Cents;
  totalRepaymentCents: Cents;
  controlGivenUpBps: Bps;
};

export type FundingComparison = {
  requiredCents: Cents;
  options: FundingOption[];
};

function positive(value: number, label: string): string | null {
  if (!Number.isInteger(value) || value <= 0) {
    return `${label} must be a positive integer`;
  }
  return null;
}

/**
 * A priced equity round is quoted in pre-money. The post-money is the
 * pre-money plus the new cash, so the investor's share is new cash divided by
 * post-money, not divided by pre-money. Dividing by pre-money overstates the
 * dilution and is the most common founder-side arithmetic error.
 */
export function equityTerms(
  raiseCents: Cents,
  preMoneyCents: Cents,
): Result<EquityTerms> {
  const raiseError = positive(raiseCents, "raise");
  if (raiseError) {
    return fail(raiseError);
  }
  const preMoneyError = positive(preMoneyCents, "pre-money");
  if (preMoneyError) {
    return fail(preMoneyError);
  }
  const postMoneyCents = raiseCents + preMoneyCents;
  return ok({
    raiseCents,
    preMoneyCents,
    postMoneyCents,
    dilutionBps: divide(raiseCents, postMoneyCents),
    investorValueCents: raiseCents,
  });
}

/**
 * Debt is quoted as an annual simple rate in this book. The rate is a teaching
 * assumption, not a market quote. Interest is charged on the full principal
 * for the whole term, so the monthly payment is total repayment divided by
 * months and rounded up to the next cent.
 */
export function debtTerms(
  principalCents: Cents,
  annualRateBps: Bps,
  months: number,
): Result<DebtTerms> {
  const principalError = positive(principalCents, "principal");
  if (principalError) {
    return fail(principalError);
  }
  if (
    !Number.isInteger(annualRateBps) ||
    annualRateBps < 0 ||
    annualRateBps > 5000
  ) {
    return fail("annual rate must be between 0 and 5000 bps");
  }
  const monthsError = positive(months, "months");
  if (monthsError) {
    return fail(monthsError);
  }

  const annualInterestCents = applyRate(principalCents, annualRateBps);
  const interestCents = Math.round((annualInterestCents * months) / 12);
  const totalRepaymentCents = principalCents + interestCents;

  return ok({
    principalCents,
    annualRateBps,
    months,
    interestCents,
    totalRepaymentCents,
    monthlyPaymentCents: Math.ceil(totalRepaymentCents / months),
  });
}

/**
 * Bootstrapping does not create cash; it accumulates it from free cash flow.
 * The cost is time: the same growth budget arrives only after enough months of
 * retained cash. Rounding up matters because a partial month cannot fund the
 * full budget.
 */
export function bootstrapPlan(
  requiredCents: Cents,
  annualFreeCashCents: Cents,
): Result<BootstrapPlan> {
  const requiredError = positive(requiredCents, "required amount");
  if (requiredError) {
    return fail(requiredError);
  }
  const freeCashError = positive(annualFreeCashCents, "annual free cash");
  if (freeCashError) {
    return fail(freeCashError);
  }

  return ok({
    requiredCents,
    annualFreeCashCents,
    monthlyFreeCashCents: Math.round(annualFreeCashCents / 12),
    monthsToFund: Math.ceil((requiredCents * 12) / annualFreeCashCents),
  });
}

/**
 * The three sources are compared on the same required amount. Equity has no
 * explicit interest and no repayment date, but it gives up control immediately;
 * debt keeps control and creates a fixed repayment; bootstrapping keeps both
 * and pays with delay. No single number ranks them, so the comparison returns
 * every dimension instead of one score.
 */
export function compareFunding(
  input: {
    requiredCents: Cents;
    preMoneyCents: Cents;
    annualRateBps: Bps;
    debtMonths: number;
    annualFreeCashCents: Cents;
  },
): Result<FundingComparison> {
  const equity = equityTerms(input.requiredCents, input.preMoneyCents);
  if (!equity.ok) {
    return fail(equity.error);
  }
  const debt = debtTerms(
    input.requiredCents,
    input.annualRateBps,
    input.debtMonths,
  );
  if (!debt.ok) {
    return fail(debt.error);
  }
  const bootstrap = bootstrapPlan(
    input.requiredCents,
    input.annualFreeCashCents,
  );
  if (!bootstrap.ok) {
    return fail(bootstrap.error);
  }

  return ok({
    requiredCents: input.requiredCents,
    options: [
      {
        source: "bootstrap",
        cashNowCents: 0,
        timeToCashMonths: bootstrap.value.monthsToFund,
        explicitCostCents: 0,
        economicCostCents: 0,
        totalRepaymentCents: 0,
        controlGivenUpBps: 0,
      },
      {
        source: "debt",
        cashNowCents: input.requiredCents,
        timeToCashMonths: 0,
        explicitCostCents: debt.value.interestCents,
        economicCostCents: debt.value.interestCents,
        totalRepaymentCents: debt.value.totalRepaymentCents,
        controlGivenUpBps: 0,
      },
      {
        source: "equity",
        cashNowCents: input.requiredCents,
        timeToCashMonths: 0,
        explicitCostCents: 0,
        economicCostCents: equity.value.investorValueCents,
        totalRepaymentCents: 0,
        controlGivenUpBps: equity.value.dilutionBps,
      },
    ],
  });
}