《独立开发者的商业指南·资本与退出》5.3 估值调整项：现金、负债、营运资金

股权价值 = 企业价值 + 现金 − 债务类负债 ± 营运资金调整
营运资金调整 = 实际营运资金 − 目标营运资金

算法 A：768,768 + 95,000 − 22,000 − 3,000 = 838,768
算法 B：768,768 + 95,000 + (12,000 − 22,000 − 15,000) = 838,768

// file: src/capital/adjustments.ts
// tier: L1
// verify: node --test test/capital/adjustments.test.ts

import { type Cents } from "../core/money.ts";
import { type Result, fail, ok } from "../core/result.ts";

export type BridgeInput = {
  enterpriseValueCents: Cents;
  cashCents: Cents;
  debtCents: Cents;
  workingCapitalActualCents: Cents;
  workingCapitalTargetCents: Cents;
};

export type BridgeResult = {
  enterpriseValueCents: Cents;
  cashCents: Cents;
  debtCents: Cents;
  netDebtCents: Cents;
  workingCapitalAdjustmentCents: Cents;
  equityValueCents: Cents;
  negativeEquity: boolean;
};

export type AddBack = {
  label: string;
  amountCents: Cents;
  verified: boolean;
};

export type AddBackResult = {
  startingCents: Cents;
  acceptedCents: Cents;
  rejectedCents: Cents;
  adjustedCents: Cents;
  acceptedLabels: string[];
  rejectedLabels: string[];
};

export type CapexArrears = {
  maintenanceCents: Cents;
  actualCents: Cents;
  arrearsCents: Cents;
  overInvestedCents: Cents;
};

function checkNonNegative(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;
}

/**
 * Working capital adjustment = actual minus target. A shortfall produces a
 * negative adjustment and reduces the price; a surplus produces a positive
 * adjustment only if the contract says the buyer pays for it.
 */
export function workingCapitalAdjustment(
  actualCents: Cents,
  targetCents: Cents,
): Result<Cents> {
  const actualError = checkNonNegative(actualCents, "actual working capital");
  if (actualError) {
    return fail(actualError);
  }
  const targetError = checkNonNegative(targetCents, "target working capital");
  if (targetError) {
    return fail(targetError);
  }
  return ok(actualCents - targetCents);
}

/**
 * Equity value bridge: start from enterprise value, add cash, subtract
 * debt-like liabilities, then apply the working capital adjustment. Cash and
 * debt must be defined before signing; a dollar counted in both places moves
 * the price twice.
 */
export function bridgeToEquity(
  input: BridgeInput,
): Result<BridgeResult> {
  if (
    !Number.isInteger(input.enterpriseValueCents) ||
    input.enterpriseValueCents <= 0
  ) {
    return fail("enterprise value must be a positive integer amount in cents");
  }
  const cashError = checkNonNegative(input.cashCents, "cash");
  if (cashError) {
    return fail(cashError);
  }
  const debtError = checkNonNegative(input.debtCents, "debt");
  if (debtError) {
    return fail(debtError);
  }
  const adjustment = workingCapitalAdjustment(
    input.workingCapitalActualCents,
    input.workingCapitalTargetCents,
  );
  if (!adjustment.ok) {
    return adjustment;
  }

  const netDebtCents = input.debtCents - input.cashCents;
  const equityValueCents =
    input.enterpriseValueCents - netDebtCents + adjustment.value;

  return ok({
    enterpriseValueCents: input.enterpriseValueCents,
    cashCents: input.cashCents,
    debtCents: input.debtCents,
    netDebtCents,
    workingCapitalAdjustmentCents: adjustment.value,
    equityValueCents,
    negativeEquity: equityValueCents < 0,
  });
}

/**
 * Add-backs increase the earnings base only when they are documented. The
 * function keeps rejected claims visible instead of silently dropping them,
 * because an unverified add-back is usually the first thing a buyer removes.
 */
export function applyAddBacks(
  startingCents: Cents,
  addBacks: AddBack[],
): Result<AddBackResult> {
  if (!Number.isInteger(startingCents) || startingCents <= 0) {
    return fail("starting earnings must be a positive integer amount in cents");
  }

  const seen = new Set<string>();
  let acceptedCents = 0;
  let rejectedCents = 0;
  const acceptedLabels: string[] = [];
  const rejectedLabels: string[] = [];

  for (const addBack of addBacks) {
    if (
      typeof addBack.label !== "string" ||
      addBack.label.trim() === ""
    ) {
      return fail("add-back label must be a non-empty string");
    }
    if (seen.has(addBack.label)) {
      return fail(`duplicate add-back label ${addBack.label}`);
    }
    seen.add(addBack.label);
    if (
      !Number.isInteger(addBack.amountCents) ||
      addBack.amountCents <= 0
    ) {
      return fail(
        `add-back ${addBack.label} must be a positive integer amount in cents`,
      );
    }
    if (typeof addBack.verified !== "boolean") {
      return fail(`add-back ${addBack.label} must state verified true or false`);
    }
    if (addBack.verified) {
      acceptedCents += addBack.amountCents;
      acceptedLabels.push(addBack.label);
    } else {
      rejectedCents += addBack.amountCents;
      rejectedLabels.push(addBack.label);
    }
  }

  return ok({
    startingCents,
    acceptedCents,
    rejectedCents,
    adjustedCents: startingCents + acceptedCents,
    acceptedLabels,
    rejectedLabels,
  });
}

/**
 * Deferred maintenance is a price adjustment, not a financing item. If actual
 * capex is below the maintenance level, the shortfall is an arrears the buyer
 * will eventually pay; over-investment does not create a credit.
 */
export function capexArrears(
  maintenanceCents: Cents,
  actualCents: Cents,
): Result<CapexArrears> {
  const maintenanceError = checkNonNegative(
    maintenanceCents,
    "maintenance capex",
  );
  if (maintenanceError) {
    return fail(maintenanceError);
  }
  const actualError = checkNonNegative(actualCents, "actual capex");
  if (actualError) {
    return fail(actualError);
  }
  const difference = maintenanceCents - actualCents;
  return ok({
    maintenanceCents,
    actualCents,
    arrearsCents: difference > 0 ? difference : 0,
    overInvestedCents: difference < 0 ? -difference : 0,
  });
}