《独立开发者的商业指南·合同、应收与风险》5.1 违约的四种形态

违约金 = 8,500 × 1% × 2 = 170
上限   = 8,500 × 10% = 850

减价 = 8,500 × 15% = 1,275

已付 60 × 85 = 5,100
替代 40 × 110 = 4,400
合计 = 9,500
替代差价 = 9,500 − 8,500 = 1,000

退款 = 8,500 × 30% = 2,550

// file: src/contract/breach.ts
// tier: L1
// verify: node --test test/contract/breach.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";

export type BreachType =
  | "delay"
  | "defect"
  | "refusal"
  | "partial-impossibility";

export type BreachInput =
  | {
      type: "delay";
      contractCents: Cents;
      weeklyRateBps: Bps;
      weeks: number;
      capBps: Bps;
    }
  | {
      type: "defect";
      contractCents: Cents;
      missingScopeBps: Bps;
      cureHours: number;
      hourlyCostCents: Cents;
    }
  | {
      type: "refusal";
      remainingHours: number;
      originalHourlyCents: Cents;
      replacementHourlyCents: Cents;
    }
  | {
      type: "partial-impossibility";
      contractCents: Cents;
      affectedScopeBps: Bps;
      nonRecoverableCostCents: Cents;
    };

export type BreachResult = {
  type: BreachType;
  claimCents: Cents;
  performerExposureCents: Cents;
  route: "pay" | "cure" | "reduce" | "refund";
  detail: string;
};

function rateError(value: Bps, label: string): string | null {
  return Number.isInteger(value) && value >= 0 && value <= 10000
    ? null
    : `${label} must be between 0 and 10000 bps`;
}

function amountError(value: Cents, label: string, positive = false): string | null {
  const minimum = positive ? 1 : 0;
  return Number.isInteger(value) && value >= minimum
    ? null
    : `${label} must be ${positive ? "a positive" : "a non-negative"} integer amount in cents`;
}

/**
 * Delay: contract x weekly rate x weeks, capped at a share of the contract.
 * The cap makes the exposure knowable before the delay happens.
 */
function delay(input: Extract<BreachInput, { type: "delay" }>): Result<BreachResult> {
  const error =
    amountError(input.contractCents, "contract", true) ??
    rateError(input.weeklyRateBps, "weekly rate") ??
    rateError(input.capBps, "cap rate");
  if (error) return fail(error);
  if (!Number.isFinite(input.weeks) || input.weeks <= 0) {
    return fail("weeks must be greater than zero");
  }
  const rawCents = Math.round(
    applyRate(input.contractCents, input.weeklyRateBps) * input.weeks,
  );
  const capCents = applyRate(input.contractCents, input.capBps);
  const claimCents = Math.min(rawCents, capCents);
  return ok({
    type: "delay",
    claimCents,
    performerExposureCents: claimCents,
    route: "pay",
    detail: rawCents > capCents ? "penalty capped" : "penalty as agreed",
  });
}

/**
 * Defect: the client's claim is the reduction for the missing scope; the
 * performer pays whichever is cheaper, provided a cure is still acceptable.
 */
function defect(input: Extract<BreachInput, { type: "defect" }>): Result<BreachResult> {
  const error =
    amountError(input.contractCents, "contract", true) ??
    rateError(input.missingScopeBps, "missing scope") ??
    amountError(input.hourlyCostCents, "hourly cost");
  if (error) return fail(error);
  if (input.missingScopeBps === 0) {
    return fail("missing scope must be greater than zero");
  }
  if (!Number.isFinite(input.cureHours) || input.cureHours < 0) {
    return fail("cure hours must be a non-negative number");
  }
  const reductionCents = applyRate(input.contractCents, input.missingScopeBps);
  const cureCostCents = Math.round(input.cureHours * input.hourlyCostCents);
  const cureIsCheaper = cureCostCents <= reductionCents;
  return ok({
    type: "defect",
    claimCents: reductionCents,
    performerExposureCents: cureIsCheaper ? cureCostCents : reductionCents,
    route: cureIsCheaper ? "cure" : "reduce",
    detail: cureIsCheaper
      ? "curing costs less than the reduction"
      : "the reduction is cheaper than curing",
  });
}

/**
 * Refusal: the client buys the remaining hours elsewhere and claims only the
 * replacement premium, not the whole replacement invoice.
 */
function refusal(input: Extract<BreachInput, { type: "refusal" }>): Result<BreachResult> {
  const error =
    amountError(input.originalHourlyCents, "original hourly rate", true) ??
    amountError(input.replacementHourlyCents, "replacement hourly rate", true);
  if (error) return fail(error);
  if (!Number.isFinite(input.remainingHours) || input.remainingHours <= 0) {
    return fail("remaining hours must be greater than zero");
  }
  const premium = Math.max(
    0,
    input.replacementHourlyCents - input.originalHourlyCents,
  );
  const claimCents = Math.round(input.remainingHours * premium);
  return ok({
    type: "refusal",
    claimCents,
    performerExposureCents: claimCents,
    route: "pay",
    detail:
      premium === 0
        ? "replacement is not more expensive"
        : "cover is the replacement premium",
  });
}

/**
 * Partial impossibility: the affected scope is refunded, and cost already
 * committed to that scope stays with the performer.
 */
function partial(
  input: Extract<BreachInput, { type: "partial-impossibility" }>,
): Result<BreachResult> {
  const error =
    amountError(input.contractCents, "contract", true) ??
    rateError(input.affectedScopeBps, "affected scope") ??
    amountError(input.nonRecoverableCostCents, "non-recoverable cost");
  if (error) return fail(error);
  if (input.affectedScopeBps === 0) {
    return fail("affected scope must be greater than zero");
  }
  const refundCents = applyRate(input.contractCents, input.affectedScopeBps);
  return ok({
    type: "partial-impossibility",
    claimCents: refundCents,
    performerExposureCents: refundCents + input.nonRecoverableCostCents,
    route: "refund",
    detail: "refund plus cost already committed to the affected scope",
  });
}

export function quantifyBreach(input: BreachInput): Result<BreachResult> {
  switch (input.type) {
    case "delay":
      return delay(input);
    case "defect":
      return defect(input);
    case "refusal":
      return refusal(input);
    case "partial-impossibility":
      return partial(input);
    default: {
      const exhaustive: never = input;
      return fail(`unknown breach type: ${String(exhaustive)}`);
    }
  }
}