《独立开发者的商业指南·资本与退出》1.2 融资的稀释与治理代价

// file: src/capital/dilution.ts
// tier: L1
// verify: node --test test/capital/dilution.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 RoundDilution = {
  raiseCents: Cents;
  preMoneyCents: Cents;
  postMoneyCents: Cents;
  dilutionBps: Bps;
};

export type OwnershipAfterRounds = {
  startBps: Bps;
  roundDilutionsBps: Bps[];
  finalBps: Bps;
  totalDilutionBps: Bps;
  additiveDilutionBps: Bps;
};

export type PoolInput = {
  founderBps: Bps;
  investorBps: Bps;
  currentPoolBps: Bps;
  targetPoolBps: Bps;
  borneByFounders: boolean;
};

export type PoolResult = {
  additionalPoolBps: Bps;
  founderBps: Bps;
  investorBps: Bps;
  poolBps: Bps;
  founderDilutionBps: Bps;
  investorDilutionBps: Bps;
};

export type WaterfallInput = {
  exitCents: Cents;
  investedCents: Cents;
  investorBps: Bps;
  participating: boolean;
  preferenceBps: Bps;
};

export type WaterfallResult = {
  preferenceCents: Cents;
  conversionValueCents: Cents;
  investorProceedsCents: Cents;
  founderProceedsCents: Cents;
  investorMultipleBps: Bps;
};

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

/** One priced round: investor share = new cash / post-money. */
export function roundDilution(
  raiseCents: Cents,
  preMoneyCents: Cents,
): Result<RoundDilution> {
  if (!Number.isInteger(raiseCents) || raiseCents <= 0) {
    return fail("raise must be a positive integer amount in cents");
  }
  if (!Number.isInteger(preMoneyCents) || preMoneyCents <= 0) {
    return fail("pre-money must be a positive integer amount in cents");
  }
  const postMoneyCents = raiseCents + preMoneyCents;
  return ok({
    raiseCents,
    preMoneyCents,
    postMoneyCents,
    dilutionBps: divide(raiseCents, postMoneyCents),
  });
}

/**
 * Round dilution compounds: (1 - d1)(1 - d2), not 1 - d1 - d2. The additive
 * figure is returned only to show how far the shortcut drifts from the cap
 * table.
 */
export function applyRounds(
  startBps: Bps,
  roundDilutionsBps: Bps[],
): Result<OwnershipAfterRounds> {
  const startError = validBps(startBps, "start ownership");
  if (startError) {
    return fail(startError);
  }
  if (roundDilutionsBps.length === 0) {
    return fail("at least one round is required");
  }
  for (const dilution of roundDilutionsBps) {
    const dilutionError = validBps(dilution, "round dilution");
    if (dilutionError) {
      return fail(dilutionError);
    }
  }

  let currentBps = startBps;
  for (const dilution of roundDilutionsBps) {
    currentBps = Math.round((currentBps * (10000 - dilution)) / 10000);
  }

  return ok({
    startBps,
    roundDilutionsBps: [...roundDilutionsBps],
    finalBps: currentBps,
    totalDilutionBps: startBps - currentBps,
    additiveDilutionBps: roundDilutionsBps.reduce((sum, d) => sum + d, 0),
  });
}

/**
 * A pre-money pool top-up takes the whole increase from founders. A pro-rata
 * top-up solves (current + x) / (total + x) = target and dilutes every
 * existing holder, so the two conventions give different founder numbers.
 */
export function topUpPool(input: PoolInput): Result<PoolResult> {
  const checks: Array<[Bps, string]> = [
    [input.founderBps, "founder"],
    [input.investorBps, "investor"],
    [input.currentPoolBps, "current pool"],
    [input.targetPoolBps, "target pool"],
  ];
  for (const [value, label] of checks) {
    const error = validBps(value, label);
    if (error) {
      return fail(error);
    }
  }
  if (
    input.founderBps + input.investorBps + input.currentPoolBps !==
    10000
  ) {
    return fail("founder, investor and current pool must sum to 10000 bps");
  }
  if (input.targetPoolBps < input.currentPoolBps) {
    return fail("target pool cannot be smaller than the current pool");
  }

  const additionalPoolBps = input.targetPoolBps - input.currentPoolBps;

  if (input.borneByFounders) {
    if (input.founderBps < additionalPoolBps) {
      return fail("founder does not hold enough equity for the pool top-up");
    }
    return ok({
      additionalPoolBps,
      founderBps: input.founderBps - additionalPoolBps,
      investorBps: input.investorBps,
      poolBps: input.targetPoolBps,
      founderDilutionBps: additionalPoolBps,
      investorDilutionBps: 0,
    });
  }

  if (input.targetPoolBps === 10000) {
    return fail("pro-rata top-up requires a target pool below 10000 bps");
  }

  const newShareUnits =
    (10000 * additionalPoolBps) / (10000 - input.targetPoolBps);
  const newTotalUnits = 10000 + newShareUnits;
  const founderBps = Math.round(
    (input.founderBps * 10000) / newTotalUnits,
  );
  const investorBps = Math.round(
    (input.investorBps * 10000) / newTotalUnits,
  );

  return ok({
    additionalPoolBps,
    founderBps,
    investorBps,
    poolBps: input.targetPoolBps,
    founderDilutionBps: input.founderBps - founderBps,
    investorDilutionBps: input.investorBps - investorBps,
  });
}

/**
 * A 1x non-participating preference is a floor the investor abandons when
 * conversion pays more. A participating preference takes the floor and then
 * shares the remaining exit, so the same headline stake pays differently.
 */
export function liquidationWaterfall(
  input: WaterfallInput,
): Result<WaterfallResult> {
  if (!Number.isInteger(input.exitCents) || input.exitCents < 0) {
    return fail("exit must be a non-negative integer amount in cents");
  }
  if (!Number.isInteger(input.investedCents) || input.investedCents <= 0) {
    return fail("invested amount must be a positive integer amount in cents");
  }
  const investorError = validBps(input.investorBps, "investor ownership");
  if (investorError) {
    return fail(investorError);
  }
  if (
    !Number.isInteger(input.preferenceBps) ||
    input.preferenceBps <= 0
  ) {
    return fail("preference must be a positive integer in basis points");
  }

  const preferenceCents = applyRate(
    input.investedCents,
    input.preferenceBps,
  );
  const conversionValueCents = applyRate(
    input.exitCents,
    input.investorBps,
  );

  let investorProceedsCents: Cents;
  if (input.exitCents <= preferenceCents) {
    investorProceedsCents = input.exitCents;
  } else if (input.participating) {
    investorProceedsCents =
      preferenceCents +
      applyRate(input.exitCents - preferenceCents, input.investorBps);
  } else {
    investorProceedsCents = Math.max(
      preferenceCents,
      conversionValueCents,
    );
  }

  return ok({
    preferenceCents,
    conversionValueCents,
    investorProceedsCents,
    founderProceedsCents: input.exitCents - investorProceedsCents,
    investorMultipleBps: divide(
      investorProceedsCents,
      input.investedCents,
    ),
  });
}