《独立开发者的商业指南·资本与退出》2.2 期权池与归属

// file: src/capital/option-pool.ts
// tier: L1
// verify: node --test test/capital/option-pool.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 VestingTerms = {
  grantCents: Cents;
  totalMonths: number;
  cliffMonths: number;
};

export type VestingPoint = {
  month: number;
  vestedBps: Bps;
  vestedCents: Cents;
};

export type PoolUse = {
  consumedBps: Bps;
  remainingBps: Bps;
};

export type Repurchase = {
  unvestedCents: Cents;
  costCents: Cents;
  retainedCents: Cents;
};

function validateTerms(terms: VestingTerms): Result<null> {
  if (!Number.isInteger(terms.grantCents) || terms.grantCents <= 0) {
    return fail("grant must be a positive integer amount");
  }
  if (!Number.isInteger(terms.totalMonths) || terms.totalMonths <= 0) {
    return fail("total months must be a positive integer");
  }
  if (
    !Number.isInteger(terms.cliffMonths) ||
    terms.cliffMonths < 0 ||
    terms.cliffMonths > terms.totalMonths
  ) {
    return fail("cliff months must be between zero and total months");
  }
  return ok(null);
}

/**
 * Four-year vesting with a one-year cliff: 25% at the cliff, then the
 * remaining 75% in equal monthly steps. Cents are computed from the
 * remaining balance so the final month lands exactly on the grant.
 */
export function vestedAt(terms: VestingTerms, month: number): Result<VestingPoint> {
  const checked = validateTerms(terms);
  if (!checked.ok) {
    return checked;
  }
  if (!Number.isInteger(month) || month < 0 || month > terms.totalMonths) {
    return fail("month must be an integer between zero and total months");
  }
  if (month < terms.cliffMonths) {
    return ok({ month, vestedBps: 0, vestedCents: 0 });
  }

  const cliffBps = divide(terms.cliffMonths, terms.totalMonths);
  const cliffCents = applyRate(terms.grantCents, cliffBps);
  const tailMonths = terms.totalMonths - terms.cliffMonths;
  if (tailMonths === 0) {
    return ok({ month, vestedBps: 10000, vestedCents: terms.grantCents });
  }
  const monthlyCents = Math.round((terms.grantCents - cliffCents) / tailMonths);
  const steps = month - terms.cliffMonths;
  const vestedCents = Math.min(
    terms.grantCents,
    cliffCents + monthlyCents * steps,
  );
  return ok({
    month,
    vestedBps: divide(vestedCents, terms.grantCents),
    vestedCents,
  });
}

/** Every month boundary from zero through the end of the schedule. */
export function vestingSchedule(terms: VestingTerms): Result<VestingPoint[]> {
  const checked = validateTerms(terms);
  if (!checked.ok) {
    return checked;
  }
  const points: VestingPoint[] = [];
  for (let month = 0; month <= terms.totalMonths; month += 1) {
    const point = vestedAt(terms, month);
    if (!point.ok) {
      return point;
    }
    points.push(point.value);
  }
  return ok(points);
}

/** Value of a grant, using the company valuation as the per-share anchor. */
export function grantValue(valuationCents: Cents, grantBps: Bps): Result<Cents> {
  if (!Number.isInteger(valuationCents) || valuationCents < 0) {
    return fail("valuation must be a non-negative integer amount");
  }
  if (!Number.isInteger(grantBps) || grantBps < 0 || grantBps > 10000) {
    return fail("grant must be between zero and 10000 basis points");
  }
  return ok(applyRate(valuationCents, grantBps));
}

/** How much of the pool a grant consumes, and what remains. */
export function poolUse(poolBps: Bps, grantBps: Bps): Result<PoolUse> {
  if (!Number.isInteger(poolBps) || poolBps <= 0 || poolBps > 10000) {
    return fail("pool must be between one and 10000 basis points");
  }
  if (!Number.isInteger(grantBps) || grantBps < 0 || grantBps > poolBps) {
    return fail("grant must be between zero and the pool size");
  }
  return ok({
    consumedBps: divide(grantBps, poolBps),
    remainingBps: poolBps - grantBps,
  });
}

/**
 * Repurchase of unvested units at the original strike. The company pays
 * at most the unvested value; the difference is the value it retains.
 */
export function repurchase(
  grantCents: Cents,
  vestedCents: Cents,
  strikeCents: Cents,
): Result<Repurchase> {
  if (!Number.isInteger(grantCents) || grantCents <= 0) {
    return fail("grant must be a positive integer amount");
  }
  if (
    !Number.isInteger(vestedCents) ||
    vestedCents < 0 ||
    vestedCents > grantCents
  ) {
    return fail("vested amount must be between zero and the grant");
  }
  if (!Number.isInteger(strikeCents) || strikeCents < 0) {
    return fail("strike must be a non-negative integer amount");
  }
  const unvestedCents = grantCents - vestedCents;
  const costCents = Math.min(strikeCents, unvestedCents);
  return ok({
    unvestedCents,
    costCents,
    retainedCents: unvestedCents - costCents,
  });
}

/** Value that must vest immediately under a single- or double-trigger. */
export function accelerationCost(
  grantCents: Cents,
  vestedCents: Cents,
): Result<Cents> {
  if (
    !Number.isInteger(grantCents) ||
    grantCents <= 0 ||
    !Number.isInteger(vestedCents) ||
    vestedCents < 0 ||
    vestedCents > grantCents
  ) {
    return fail("grant and vested amounts are inconsistent");
  }
  return ok(grantCents - vestedCents);
}

/** Expected acceleration cost when a double trigger is only probabilistic. */
export function expectedAcceleration(
  unvestedCents: Cents,
  triggerProbabilityBps: Bps,
): Result<Cents> {
  if (!Number.isInteger(unvestedCents) || unvestedCents < 0) {
    return fail("unvested amount must be a non-negative integer");
  }
  if (
    !Number.isInteger(triggerProbabilityBps) ||
    triggerProbabilityBps < 0 ||
    triggerProbabilityBps > 10000
  ) {
    return fail("probability must be between zero and 10000 basis points");
  }
  return ok(applyRate(unvestedCents, triggerProbabilityBps));
}