《独立开发者的商业指南·资本与退出》6.3 技术与知识产权尽调

// file: src/capital/tech-ip-dd.ts
// tier: L1
// verify: node --test test/capital/tech-ip-dd.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 RemediationPath =
  | "rewrite"
  | "commercial-license"
  | "compliance"
  | "rebuy"
  | "rebuy-premium"
  | "fix";

export type RemediationOption = {
  path: RemediationPath;
  oneTimeCents: Cents;
  annualCents: Cents;
  years: number;
};

export type PathTotal = {
  path: RemediationPath;
  totalCents: Cents;
};

export type PathComparison = {
  rows: PathTotal[];
  cheapest: RemediationPath;
  cheapestCents: Cents;
  spreadCents: Cents;
};

export type EscrowInput = {
  priceCents: Cents;
  standardEscrowBps: Bps;
  remediationCents: Cents;
  bufferBps: Bps;
};

export type EscrowPlan = {
  standardEscrowCents: Cents;
  requiredEscrowCents: Cents;
  shortfallCents: Cents;
  requiredBps: Bps;
  covered: boolean;
};

function isPath(value: string): value is RemediationPath {
  return (
    value === "rewrite" ||
    value === "commercial-license" ||
    value === "compliance" ||
    value === "rebuy" ||
    value === "rebuy-premium" ||
    value === "fix"
  );
}

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

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

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

/**
 * Paths are compared on total cost, not on headline quote. A rewrite is
 * one-time; compliance usually carries an annual competition loss. Sorting is
 * ascending, and ties keep the input order so the seller can present the
 * preferred path first.
 */
export function compareRemediation(
  options: RemediationOption[],
): Result<PathComparison> {
  if (options.length === 0) {
    return fail("at least one remediation path is required");
  }

  const seen = new Set<RemediationPath>();
  const rows: { row: PathTotal; index: number }[] = [];
  for (const option of options) {
    if (!isPath(option.path)) {
      return fail(`unknown remediation path ${option.path}`);
    }
    if (seen.has(option.path)) {
      return fail(`duplicate remediation path ${option.path}`);
    }
    if (!validCost(option.oneTimeCents)) {
      return fail(`${option.path} one-time cost must be a non-negative integer`);
    }
    if (!validCost(option.annualCents)) {
      return fail(`${option.path} annual cost must be a non-negative integer`);
    }
    if (!validYears(option.years)) {
      return fail(`${option.path} years must be a non-negative integer`);
    }
    seen.add(option.path);
    rows.push({
      row: {
        path: option.path,
        totalCents: option.oneTimeCents + option.annualCents * option.years,
      },
      index: rows.length,
    });
  }

  const ordered = rows
    .sort(
      (a, b) => a.row.totalCents - b.row.totalCents || a.index - b.index,
    )
    .map((entry) => entry.row);
  const cheapest = ordered[0];
  const mostExpensive = ordered[ordered.length - 1];

  return ok({
    rows: ordered,
    cheapest: cheapest.path,
    cheapestCents: cheapest.totalCents,
    spreadCents: mostExpensive.totalCents - cheapest.totalCents,
  });
}

/**
 * The standard escrow is a percentage of price. Cure cost can exceed it, so
 * the required escrow is the cure cost plus a buffer. The return value shows
 * both the shortfall and the escrow as a share of price, which is the number
 * that belongs in the term sheet.
 */
export function escrowPlan(input: EscrowInput): Result<EscrowPlan> {
  if (!Number.isInteger(input.priceCents) || input.priceCents <= 0) {
    return fail("price must be a positive integer amount");
  }
  if (!validBps(input.standardEscrowBps)) {
    return fail("standard escrow must be between 0 and 100%");
  }
  if (!validCost(input.remediationCents)) {
    return fail("remediation cost must be a non-negative integer");
  }
  if (!validBps(input.bufferBps)) {
    return fail("escrow buffer must be between 0 and 100%");
  }

  const standardEscrowCents = Math.round(
    (input.priceCents * input.standardEscrowBps) / 10000,
  );
  const requiredEscrowCents = Math.round(
    (input.remediationCents * (10000 + input.bufferBps)) / 10000,
  );

  return ok({
    standardEscrowCents,
    requiredEscrowCents,
    shortfallCents: Math.max(0, requiredEscrowCents - standardEscrowCents),
    requiredBps: divide(requiredEscrowCents, input.priceCents),
    covered: requiredEscrowCents <= standardEscrowCents,
  });
}