《独立开发者的商业指南·资本与退出》1.3 什么时候不该融资

// file: src/capital/no-funding.ts
// tier: L1
// verify: node --test test/capital/no-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 FundingRecommendation = "raise" | "self-fund" | "debt";

export type FundingNeedInput = {
  annualOperatingCashFlowCents: Cents;
  annualGrowthSpendCents: Cents;
  currentSdeCents: Cents;
  raiseCents: Cents;
  preMoneyCents: Cents;
  anchorValueCents: Cents;
  valuationMultipleBps: Bps;
  governanceCostBps: Bps;
  maxDilutionBps: Bps;
};

export type FundingNeedResult = {
  positiveCashFlow: boolean;
  selfFundsGrowth: boolean;
  dilutionAtPreMoneyBps: Bps;
  dilutionAtAnchorBps: Bps;
  valuationTooLow: boolean;
  requiredSdeIncreaseCents: Cents;
  requiredSdeGrowthBps: Bps;
  governanceCostCents: Cents;
  governanceExceedsRaise: boolean;
  recommendation: FundingRecommendation;
};

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

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

/**
 * Four tests decide whether equity is the right source. Two are about need:
 * operating cash flow is positive, and growth spend fits inside that cash
 * flow. Two are about price: dilution at the defensible anchor stays under
 * the limit, and the estimated governance cost stays below the cash raised.
 * A positive answer on all four does not forbid raising; it says the company
 * can grow without selling equity, so any round should be for acceleration or
 * a buffer, not for survival.
 *
 * The required SDE increase is the value-neutral test: at a given SDE
 * multiple, the cash raised must eventually add raise / multiple of SDE, or
 * the founder has sold a share of the company for cash that did not create
 * matching value.
 */
export function evaluateFundingNeed(
  input: FundingNeedInput,
): Result<FundingNeedResult> {
  if (!Number.isInteger(input.annualOperatingCashFlowCents)) {
    return fail("operating cash flow must be an integer amount in cents");
  }
  const growthError = nonNegative(
    input.annualGrowthSpendCents,
    "annual growth spend",
  );
  if (growthError) {
    return fail(growthError);
  }
  const sdeError = positive(input.currentSdeCents, "current sde");
  if (sdeError) {
    return fail(sdeError);
  }
  const raiseError = positive(input.raiseCents, "raise");
  if (raiseError) {
    return fail(raiseError);
  }
  const preMoneyError = positive(input.preMoneyCents, "pre-money");
  if (preMoneyError) {
    return fail(preMoneyError);
  }
  const anchorError = positive(input.anchorValueCents, "anchor value");
  if (anchorError) {
    return fail(anchorError);
  }
  const multipleError = positive(
    input.valuationMultipleBps,
    "valuation multiple",
  );
  if (multipleError) {
    return fail(multipleError);
  }
  const governanceError = nonNegative(
    input.governanceCostBps,
    "governance cost",
  );
  if (governanceError) {
    return fail(governanceError);
  }
  if (input.governanceCostBps > 10000) {
    return fail("governance cost must be at most 10000 bps");
  }
  const maxDilutionError = nonNegative(
    input.maxDilutionBps,
    "maximum dilution",
  );
  if (maxDilutionError) {
    return fail(maxDilutionError);
  }
  if (input.maxDilutionBps > 10000) {
    return fail("maximum dilution must be at most 10000 bps");
  }

  const positiveCashFlow = input.annualOperatingCashFlowCents > 0;
  const selfFundsGrowth =
    input.annualOperatingCashFlowCents >= input.annualGrowthSpendCents;

  const dilutionAtPreMoneyBps = divide(
    input.raiseCents,
    input.raiseCents + input.preMoneyCents,
  );
  const dilutionAtAnchorBps = divide(
    input.raiseCents,
    input.raiseCents + input.anchorValueCents,
  );
  const valuationTooLow = dilutionAtAnchorBps > input.maxDilutionBps;

  const requiredSdeIncreaseCents = Math.round(
    (input.raiseCents * 10000) / input.valuationMultipleBps,
  );
  const requiredSdeGrowthBps = divide(
    requiredSdeIncreaseCents,
    input.currentSdeCents,
  );

  const governanceCostCents = applyRate(
    input.anchorValueCents,
    input.governanceCostBps,
  );
  const governanceExceedsRaise =
    governanceCostCents > input.raiseCents;

  let recommendation: FundingRecommendation;
  if (positiveCashFlow && selfFundsGrowth) {
    recommendation = "self-fund";
  } else if (
    !positiveCashFlow &&
    !valuationTooLow &&
    !governanceExceedsRaise
  ) {
    recommendation = "raise";
  } else {
    recommendation = "debt";
  }

  return ok({
    positiveCashFlow,
    selfFundsGrowth,
    dilutionAtPreMoneyBps,
    dilutionAtAnchorBps,
    valuationTooLow,
    requiredSdeIncreaseCents,
    requiredSdeGrowthBps,
    governanceCostCents,
    governanceExceedsRaise,
    recommendation,
  });
}