《独立开发者的商业指南·合同、应收与风险》11.2 数据泄露的责任与通知

// file: src/contract/breach-liability.ts
// tier: L1
// verify: node --test test/contract/breach-liability.test.ts

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

export type BreachCostInput = {
  forensicsCents: Cents;
  notificationCents: Cents;
  customerClaimCents: Cents;
  assumedFineCents: Cents;
  fineProbabilityBps: Bps;
};

export type BreachCost = {
  directCostCents: Cents;
  expectedFineCents: Cents;
  grossCostCents: Cents;
};

export type BreachSettlementInput = {
  cost: BreachCostInput;
  liabilityCapCents: Cents;
  insuranceLimitCents: Cents;
  deductibleCents: Cents;
};

export type BreachSettlement = {
  cappedCustomerClaimCents: Cents;
  capSavingCents: Cents;
  insurableCents: Cents;
  expectedFineCents: Cents;
  grossCostCents: Cents;
  insurancePayoutCents: Cents;
  netExposureCents: Cents;
};

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

/**
 * A fine is not a fixed number in a plan. It is an assumed exposure multiplied
 * by a probability tier; the result is an expected cost, not a prediction of
 * any regulator's decision.
 */
export function breachCost(input: BreachCostInput): Result<BreachCost> {
  if (!validAmount(input.forensicsCents)) {
    return fail("forensics must be a non-negative integer amount");
  }
  if (!validAmount(input.notificationCents)) {
    return fail("notification must be a non-negative integer amount");
  }
  if (!validAmount(input.customerClaimCents)) {
    return fail("customer claim must be a non-negative integer amount");
  }
  if (!validAmount(input.assumedFineCents)) {
    return fail("assumed fine must be a non-negative integer amount");
  }
  if (!Number.isInteger(input.fineProbabilityBps) || input.fineProbabilityBps < 0 || input.fineProbabilityBps > 10_000) {
    return fail("fine probability must be an integer between 0 and 10000 bps");
  }

  const directCostCents =
    input.forensicsCents + input.notificationCents + input.customerClaimCents;
  const expectedFineCents = applyRate(
    input.assumedFineCents,
    input.fineProbabilityBps,
  );

  return ok({
    directCostCents,
    expectedFineCents,
    grossCostCents: directCostCents + expectedFineCents,
  });
}

/**
 * The liability cap and the insurance policy are two different walls. The cap
 * decides how much of the customer claim the business owes; insurance decides
 * how much of the paid, insurable cost comes back. Fines sit outside both: the
 * cap does not remove them and the policy is assumed not to pay them.
 */
export function settleBreach(
  input: BreachSettlementInput,
): Result<BreachSettlement> {
  const cost = breachCost(input.cost);
  if (!cost.ok) {
    return fail(cost.error);
  }
  if (!validAmount(input.liabilityCapCents)) {
    return fail("liability cap must be a non-negative integer amount");
  }
  if (!validAmount(input.insuranceLimitCents)) {
    return fail("insurance limit must be a non-negative integer amount");
  }
  if (!validAmount(input.deductibleCents)) {
    return fail("deductible must be a non-negative integer amount");
  }

  const cappedCustomerClaimCents = Math.min(
    input.cost.customerClaimCents,
    input.liabilityCapCents,
  );
  const capSavingCents = input.cost.customerClaimCents - cappedCustomerClaimCents;
  const insurableCents =
    input.cost.forensicsCents +
    input.cost.notificationCents +
    cappedCustomerClaimCents;
  const claim = settleClaim({
    lossCents: insurableCents,
    limitCents: input.insuranceLimitCents,
    deductibleCents: input.deductibleCents,
  });
  if (!claim.ok) {
    return fail(claim.error);
  }

  const grossCostCents = insurableCents + cost.value.expectedFineCents;

  return ok({
    cappedCustomerClaimCents,
    capSavingCents,
    insurableCents,
    expectedFineCents: cost.value.expectedFineCents,
    grossCostCents,
    insurancePayoutCents: claim.value.payoutCents,
    netExposureCents: grossCostCents - claim.value.payoutCents,
  });
}