《独立开发者的商业指南·合同、应收与风险》8.3 授权审计与终止

// file: src/contract/license-audit.ts
// tier: L1
// verify: node --test test/contract/license-audit.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 AuditInput = {
  reportedRoyaltyCents: Cents;
  underpaymentRateBps: Bps;
  auditCostCents: Cents;
  costShiftThresholdBps: Bps;
};

export type AuditOutcome = {
  underpaymentCents: Cents;
  auditCostCents: Cents;
  costShifted: boolean;
  licensorNetCents: Cents;
  licenseeTotalCents: Cents;
  recoveryRateBps: Bps;
};

export type TerminationGapInput = {
  remainingYears: number;
  annualGuaranteeCents: Cents;
  replacementAnnualCents: Cents;
  transitionMonths: number;
  auditCostCents: Cents;
};

export type TerminationGap = {
  lostGuaranteeCents: Cents;
  replacementCents: Cents;
  replacementShareBps: Bps;
  revenueGapCents: Cents;
  totalGapCents: Cents;
};

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;
}

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;
}

/**
 * An audit clause rarely makes the licensee pay every time. The usual shape
 * is a materiality threshold: if the underpayment exceeds a stated share of
 * reported royalties, the licensee bears the audit cost; otherwise the
 * licensor does.
 */
export function auditOutcome(input: AuditInput): Result<AuditOutcome> {
  const reportedError = checkAmount(
    input.reportedRoyaltyCents,
    "reported royalty",
  );
  if (reportedError) {
    return fail(reportedError);
  }
  const costError = checkAmount(input.auditCostCents, "audit cost");
  if (costError) {
    return fail(costError);
  }
  for (const [value, label] of [
    [input.underpaymentRateBps, "underpayment rate"],
    [input.costShiftThresholdBps, "cost shift threshold"],
  ] as Array<[Bps, string]>) {
    const error = checkBps(value, label);
    if (error) {
      return fail(error);
    }
  }
  const underpaymentCents = applyRate(
    input.reportedRoyaltyCents,
    input.underpaymentRateBps,
  );
  const costShifted =
    input.underpaymentRateBps >= input.costShiftThresholdBps;
  return ok({
    underpaymentCents,
    auditCostCents: input.auditCostCents,
    costShifted,
    licensorNetCents:
      underpaymentCents - (costShifted ? 0 : input.auditCostCents),
    licenseeTotalCents:
      underpaymentCents + (costShifted ? input.auditCostCents : 0),
    recoveryRateBps:
      input.reportedRoyaltyCents === 0
        ? 0
        : divide(underpaymentCents, input.reportedRoyaltyCents),
  });
}

/**
 * The reported royalty at which the expected underpayment exactly pays the
 * audit cost. Above this line a licensor-funded audit is cash-positive;
 * below it, auditing is a loss unless the clause shifts the cost.
 */
export function auditBreakEvenRoyalty(
  auditCostCents: Cents,
  underpaymentRateBps: Bps,
): Result<Cents> {
  const costError = checkAmount(auditCostCents, "audit cost");
  if (costError) {
    return fail(costError);
  }
  const rateError = checkBps(underpaymentRateBps, "underpayment rate");
  if (rateError) {
    return fail(rateError);
  }
  if (underpaymentRateBps === 0) {
    return fail("underpayment rate must be positive");
  }
  return ok(Math.ceil((auditCostCents * 10000) / underpaymentRateBps));
}

/**
 * Termination does not just stop the royalty; it removes the remaining
 * guarantee. Replacement revenue arrives only after a transition gap, so the
 * cash hole is the lost guarantee minus what the replacement actually pays.
 */
export function terminationGap(
  input: TerminationGapInput,
): Result<TerminationGap> {
  if (!Number.isInteger(input.remainingYears) || input.remainingYears <= 0) {
    return fail("remaining years must be a positive integer");
  }
  for (const [value, label] of [
    [input.annualGuaranteeCents, "annual guarantee"],
    [input.replacementAnnualCents, "replacement annual fee"],
    [input.auditCostCents, "audit cost"],
  ] as Array<[Cents, string]>) {
    const error = checkAmount(value, label);
    if (error) {
      return fail(error);
    }
  }
  const totalMonths = input.remainingYears * 12;
  if (
    !Number.isInteger(input.transitionMonths) ||
    input.transitionMonths < 0 ||
    input.transitionMonths > totalMonths
  ) {
    return fail("transition months must fit inside the remaining term");
  }
  const lostGuaranteeCents = input.annualGuaranteeCents * input.remainingYears;
  const replacementMonths = totalMonths - input.transitionMonths;
  const replacementCents = Math.round(
    (input.replacementAnnualCents * replacementMonths) / 12,
  );
  return ok({
    lostGuaranteeCents,
    replacementCents,
    replacementShareBps:
      lostGuaranteeCents === 0
        ? 0
        : divide(replacementCents, lostGuaranteeCents),
    revenueGapCents: lostGuaranteeCents - replacementCents,
    totalGapCents:
      lostGuaranteeCents - replacementCents + input.auditCostCents,
  });
}