《独立开发者的商业指南·资本与退出》9.2 竞业、保密与留任

// file: src/capital/noncompete.ts
// tier: L1
// verify: node --test test/capital/noncompete.test.ts

import { type Cents } from "../core/money.ts";
import { type Bps, divide } from "../core/rate.ts";
import { type Result, fail, ok } from "../core/result.ts";

export type RetentionPerson = {
  role: string;
  count: number;
  monthlySalaryCents: Cents;
  retentionMonths: number;
  bonusBps: Bps;
};

export type RetentionInput = {
  people: RetentionPerson[];
  annualRevenueCents: Cents;
  revenueAtRiskBps: Bps;
  protectionYears: number;
  enforceabilityBps: Bps;
  noncompeteMonths: number;
};

export type RetentionOutcome = {
  headcount: number;
  monthlySalaryCents: Cents;
  annualSalaryCents: Cents;
  bonusPoolCents: Cents;
  bonusPoolBpsOfRevenue: Bps;
  annualRevenueAtRiskCents: Cents;
  totalRevenueAtRiskCents: Cents;
  protectedRevenueCents: Cents;
  lostRevenueCents: Cents;
  netBenefitCents: Cents;
  costPerProtectedMonthCents: Cents;
  breakEvenMonths: number;
};

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

function checkBps(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;
}

/**
 * A retention bonus is a prepaid bet on a noncompete. The bonus is paid over
 * the retention period, while the protection only exists if the restriction is
 * enforceable and the customers actually stay. This model separates the three
 * numbers: what the bonus costs, how much revenue is exposed, and how much of
 * that exposure the restriction plausibly protects. It is a teaching model,
 * not legal advice; enforceability is an input, not a conclusion.
 */
export function retentionPlan(
  input: RetentionInput,
): Result<RetentionOutcome> {
  if (!Array.isArray(input.people) || input.people.length === 0) {
    return fail("at least one retention group is required");
  }
  if (
    !Number.isInteger(input.annualRevenueCents) ||
    input.annualRevenueCents <= 0
  ) {
    return fail("annual revenue must be a positive integer amount in cents");
  }
  for (const [value, label] of [
    [input.revenueAtRiskBps, "revenue at risk"],
    [input.enforceabilityBps, "enforceability"],
  ] as Array<[Bps, string]>) {
    const error = checkBps(value, label);
    if (error) {
      return fail(error);
    }
  }
  if (
    !Number.isInteger(input.protectionYears) ||
    input.protectionYears < 1 ||
    input.protectionYears > 10
  ) {
    return fail("protection years must be an integer between 1 and 10");
  }
  if (
    !Number.isInteger(input.noncompeteMonths) ||
    input.noncompeteMonths < 1 ||
    input.noncompeteMonths > 60
  ) {
    return fail("noncompete months must be an integer between 1 and 60");
  }

  let headcount = 0;
  let monthlySalaryCents = 0;
  let bonusPoolCents = 0;

  for (const person of input.people) {
    if (typeof person.role !== "string" || person.role.trim() === "") {
      return fail("each retention group needs a role label");
    }
    if (!Number.isInteger(person.count) || person.count <= 0) {
      return fail("retention headcount must be a positive integer");
    }
    if (
      !Number.isInteger(person.monthlySalaryCents) ||
      person.monthlySalaryCents <= 0
    ) {
      return fail("monthly salary must be a positive integer amount in cents");
    }
    if (
      !Number.isInteger(person.retentionMonths) ||
      person.retentionMonths < 1 ||
      person.retentionMonths > 60
    ) {
      return fail("retention months must be an integer between 1 and 60");
    }
    const bpsError = checkBps(person.bonusBps, "retention bonus");
    if (bpsError) {
      return fail(bpsError);
    }

    headcount += person.count;
    monthlySalaryCents += person.count * person.monthlySalaryCents;
    bonusPoolCents += Math.round(
      (person.count *
        person.monthlySalaryCents *
        person.retentionMonths *
        person.bonusBps) /
        10000,
    );
  }

  const annualSalaryCents = monthlySalaryCents * 12;
  const annualRevenueAtRiskCents = Math.round(
    (input.annualRevenueCents * input.revenueAtRiskBps) / 10000,
  );
  const totalRevenueAtRiskCents =
    annualRevenueAtRiskCents * input.protectionYears;
  const protectedRevenueCents = Math.round(
    (totalRevenueAtRiskCents * input.enforceabilityBps) / 10000,
  );
  const lostRevenueCents = totalRevenueAtRiskCents - protectedRevenueCents;
  const protectedPerMonthCents =
    protectedRevenueCents / (input.protectionYears * 12);
  const breakEvenMonths =
    protectedPerMonthCents > 0
      ? Math.ceil(bonusPoolCents / protectedPerMonthCents)
      : 0;

  return ok({
    headcount,
    monthlySalaryCents,
    annualSalaryCents,
    bonusPoolCents,
    bonusPoolBpsOfRevenue: divide(bonusPoolCents, input.annualRevenueCents),
    annualRevenueAtRiskCents,
    totalRevenueAtRiskCents,
    protectedRevenueCents,
    lostRevenueCents,
    netBenefitCents: protectedRevenueCents - bonusPoolCents,
    costPerProtectedMonthCents: Math.round(
      bonusPoolCents / input.noncompeteMonths,
    ),
    breakEvenMonths,
  });
}

export type RestrictionInput = {
  durationMonths: number;
  geographyCount: number;
  scopeBps: Bps;
};

export type RestrictionOutcome = {
  durationMonths: number;
  geographyCount: number;
  scopeBps: Bps;
  breadthUnits: number;
  breadthPerMonth: number;
};

/**
 * Quantifies how broad a restriction is without deciding whether it is valid.
 * One breadth unit is one month, one geography and the full business scope.
 * A 24-month restriction covering two regions at full scope scores 48 units;
 * a 12-month restriction covering one region at half scope scores 6. The same
 * score can be reasonable in one jurisdiction and unenforceable in another, so
 * the number is a comparison aid, not a legal test.
 */
export function restrictionBreadth(
  input: RestrictionInput,
): Result<RestrictionOutcome> {
  if (
    !Number.isInteger(input.durationMonths) ||
    input.durationMonths < 1 ||
    input.durationMonths > 60
  ) {
    return fail("duration months must be an integer between 1 and 60");
  }
  if (
    !Number.isInteger(input.geographyCount) ||
    input.geographyCount < 1 ||
    input.geographyCount > 100
  ) {
    return fail("geography count must be an integer between 1 and 100");
  }
  const bpsError = checkBps(input.scopeBps, "scope");
  if (bpsError) {
    return fail(bpsError);
  }

  const breadthUnits = Math.round(
    (input.durationMonths * input.geographyCount * input.scopeBps) / 10000,
  );

  return ok({
    durationMonths: input.durationMonths,
    geographyCount: input.geographyCount,
    scopeBps: input.scopeBps,
    breadthUnits,
    breadthPerMonth: Math.round(
      (input.geographyCount * input.scopeBps) / 10000,
    ),
  });
}