《独立开发者的商业指南·资本与退出》6.1 财务尽调

// file: src/capital/dd.ts
// tier: L1
// verify: node --test test/capital/dd.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 FindingCategory =
  | "revenue-recognition"
  | "receivables"
  | "expense-attribution"
  | "related-party"
  | "tax";

export const FINDING_ORDER: FindingCategory[] = [
  "revenue-recognition",
  "receivables",
  "expense-attribution",
  "related-party",
  "tax",
];

/**
 * A finding turns a due-diligence observation into a price adjustment. The
 * base is the amount the observation applies to, the adjustment is the share
 * of that base at issue, and the multiple converts an annual impact into an
 * enterprise-value impact. A direct adjustment uses a multiple of 10000 bps,
 * which is 1x.
 */
export type Finding = {
  id: string;
  category: FindingCategory;
  label: string;
  baseCents: Cents;
  adjustmentBps: Bps;
  multipleBps: Bps;
};

export type FindingImpact = {
  id: string;
  category: FindingCategory;
  label: string;
  annualImpactCents: Cents;
  multipleBps: Bps;
  priceImpactCents: Cents;
};

export type CategoryImpact = {
  category: FindingCategory;
  priceImpactCents: Cents;
  shareBps: Bps;
};

export type ImpactSummary = {
  rows: FindingImpact[];
  totalPriceImpactCents: Cents;
  priceCents: Cents;
  adjustedPriceCents: Cents;
  totalBpsOfPrice: Bps;
  byCategory: CategoryImpact[];
};

export type ReceivablesInput = {
  arCents: Cents;
  overdueBps: Bps;
  reserveBps: Bps;
  materialityBps: Bps;
  fullEscrowMonths: number;
  partialEscrowMonths: number;
};

export type EscrowPlan = {
  overdueCents: Cents;
  reserveCents: Cents;
  riskBps: Bps;
  fullEscrow: boolean;
  escrowCents: Cents;
  months: number;
};

function isCategory(value: string): value is FindingCategory {
  return (FINDING_ORDER as string[]).includes(value);
}

function validCents(value: Cents): boolean {
  return Number.isInteger(value) && value >= 0;
}

function validBps(value: Bps): boolean {
  return Number.isInteger(value) && value >= 0 && value <= 10000;
}

/**
 * One finding becomes one row. The annual impact is rounded before the
 * multiple is applied, so the same inputs always produce the same cents.
 */
export function priceImpact(finding: Finding): Result<FindingImpact> {
  if (finding.id.trim() === "") {
    return fail("finding id cannot be empty");
  }
  if (!isCategory(finding.category)) {
    return fail(`unknown category ${finding.category}`);
  }
  if (finding.label.trim() === "") {
    return fail(`${finding.id} needs a label`);
  }
  if (!validCents(finding.baseCents)) {
    return fail(`${finding.id} base must be a non-negative integer amount`);
  }
  if (!validBps(finding.adjustmentBps)) {
    return fail(`${finding.id} adjustment must be between 0 and 100%`);
  }
  if (
    !Number.isInteger(finding.multipleBps) ||
    finding.multipleBps < 10000 ||
    finding.multipleBps > 100000
  ) {
    return fail(`${finding.id} multiple must be between 1x and 10x`);
  }

  const annualImpactCents = applyRate(
    finding.baseCents,
    finding.adjustmentBps,
  );
  const priceImpactCents = Math.round(
    (annualImpactCents * finding.multipleBps) / 10000,
  );

  return ok({
    id: finding.id,
    category: finding.category,
    label: finding.label,
    annualImpactCents,
    multipleBps: finding.multipleBps,
    priceImpactCents,
  });
}

/**
 * Findings are grouped by category so a seller can see whether the cut comes
 * from revenue, working capital, cost normalization or tax. The total is not
 * capped: an adjustment larger than the price is a signal that the deal does
 * not work at this anchor, not a number to hide.
 */
export function summarizeImpacts(
  findings: Finding[],
  priceCents: Cents,
): Result<ImpactSummary> {
  if (!Number.isInteger(priceCents) || priceCents <= 0) {
    return fail("price must be a positive integer amount in cents");
  }
  if (findings.length === 0) {
    return fail("at least one finding is required");
  }

  const seen = new Set<string>();
  const rows: FindingImpact[] = [];
  for (const finding of findings) {
    if (seen.has(finding.id)) {
      return fail(`duplicate finding ${finding.id}`);
    }
    const impact = priceImpact(finding);
    if (!impact.ok) {
      return impact;
    }
    seen.add(finding.id);
    rows.push(impact.value);
  }

  const totalPriceImpactCents = rows.reduce(
    (acc, row) => acc + row.priceImpactCents,
    0,
  );
  const byCategory: CategoryImpact[] = [];
  for (const category of FINDING_ORDER) {
    const inCategory = rows.filter((row) => row.category === category);
    if (inCategory.length === 0) {
      continue;
    }
    const categoryImpact = inCategory.reduce(
      (acc, row) => acc + row.priceImpactCents,
      0,
    );
    byCategory.push({
      category,
      priceImpactCents: categoryImpact,
      shareBps: divide(categoryImpact, totalPriceImpactCents),
    });
  }

  return ok({
    rows,
    totalPriceImpactCents,
    priceCents,
    adjustedPriceCents: priceCents - totalPriceImpactCents,
    totalBpsOfPrice: divide(totalPriceImpactCents, priceCents),
    byCategory,
  });
}

/**
 * Receivables are treated as collected only after they clear. The materiality
 * threshold and both holding periods are teaching assumptions: when overdue
 * plus reserve reaches the threshold, the buyer holds the whole balance; below
 * it, the buyer holds only the at-risk portion. Either way the money is
 * escrowed, not deducted from the headline price.
 */
export function receivablesEscrow(
  input: ReceivablesInput,
): Result<EscrowPlan> {
  if (!Number.isInteger(input.arCents) || input.arCents <= 0) {
    return fail("accounts receivable must be a positive integer amount");
  }
  if (!validBps(input.overdueBps)) {
    return fail("overdue share must be between 0 and 100%");
  }
  if (!validBps(input.reserveBps)) {
    return fail("reserve share must be between 0 and 100%");
  }
  if (!validBps(input.materialityBps)) {
    return fail("materiality threshold must be between 0 and 100%");
  }
  if (input.overdueBps + input.reserveBps > 10000) {
    return fail("overdue plus reserve cannot exceed the whole balance");
  }
  if (
    !Number.isInteger(input.fullEscrowMonths) ||
    input.fullEscrowMonths <= 0
  ) {
    return fail("full escrow months must be a positive integer");
  }
  if (
    !Number.isInteger(input.partialEscrowMonths) ||
    input.partialEscrowMonths <= 0
  ) {
    return fail("partial escrow months must be a positive integer");
  }

  const overdueCents = applyRate(input.arCents, input.overdueBps);
  const reserveCents = applyRate(input.arCents, input.reserveBps);
  const riskBps = input.overdueBps + input.reserveBps;
  const fullEscrow = riskBps >= input.materialityBps;

  return ok({
    overdueCents,
    reserveCents,
    riskBps,
    fullEscrow,
    escrowCents: fullEscrow ? input.arCents : overdueCents + reserveCents,
    months: fullEscrow ? input.fullEscrowMonths : input.partialEscrowMonths,
  });
}