《独立开发者的商业指南·资本与退出》9.1 雇佣与外包合同的承继

// file: src/capital/contract-assignment.ts
// tier: L1
// verify: node --test test/capital/contract-assignment.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 DealStructure = "stock" | "asset";

export type ContractKind = "employment" | "supplier" | "customer";

export const CONTRACT_KINDS: ContractKind[] = [
  "employment",
  "supplier",
  "customer",
];

export type ContractGroup = {
  kind: ContractKind;
  count: number;
  annualRevenueCents: Cents;
  reSignHours: number;
  consentRequired: boolean;
  consentCostCents: Cents;
  changeOfControlBps: Bps;
};

export type AssignmentInput = {
  structure: DealStructure;
  hourlyRateCents: Cents;
  groups: ContractGroup[];
};

export type AssignmentOutcome = {
  structure: DealStructure;
  automaticSuccession: boolean;
  contractCount: number;
  contractsToRepaper: number;
  contractsWithConsent: number;
  reSignHours: number;
  reSignCostCents: Cents;
  consentCostCents: Cents;
  totalCostCents: Cents;
  annualRevenueCents: Cents;
  totalCostBpsOfRevenue: Bps;
  atRiskContracts: number;
  atRiskRevenueCents: Cents;
  atRiskRevenueBps: Bps;
};

function isKind(value: string): value is ContractKind {
  return (CONTRACT_KINDS as string[]).includes(value);
}

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

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

/**
 * A stock deal changes the owner of the contracting entity, so an employment,
 * supplier or customer contract continues with the same legal party. An asset
 * deal moves the contract to a new entity, so every contract must be re-papered
 * or transferred with consent. Separately, a change-of-control clause gives the
 * counterparty a termination right even when the entity itself survives. This
 * model counts both costs and the revenue exposed to that right. It is a
 * teaching model, not legal advice.
 */
export function assessAssignment(
  input: AssignmentInput,
): Result<AssignmentOutcome> {
  if (input.structure !== "stock" && input.structure !== "asset") {
    return fail("structure must be stock or asset");
  }
  if (!Number.isInteger(input.hourlyRateCents) || input.hourlyRateCents <= 0) {
    return fail("hourly rate must be a positive integer amount in cents");
  }
  if (!Array.isArray(input.groups) || input.groups.length === 0) {
    return fail("at least one contract group is required");
  }

  let contractCount = 0;
  let contractsWithConsent = 0;
  let reSignHours = 0;
  let reSignCostCents = 0;
  let consentCostCents = 0;
  let annualRevenueCents = 0;
  let atRiskContracts = 0;
  let atRiskRevenueCents = 0;

  for (const group of input.groups) {
    if (!isKind(group.kind)) {
      return fail("contract kind must be employment, supplier or customer");
    }
    if (!Number.isInteger(group.count) || group.count < 0) {
      return fail("contract count must be a non-negative integer");
    }
    if (
      !Number.isFinite(group.reSignHours) ||
      group.reSignHours < 0 ||
      group.reSignHours > 1000
    ) {
      return fail("re-sign hours must be between 0 and 1000 per contract");
    }
    for (const [value, label] of [
      [group.annualRevenueCents, "annual revenue"],
      [group.consentCostCents, "consent cost"],
    ] as Array<[Cents, string]>) {
      const error = checkAmount(value, label);
      if (error) {
        return fail(error);
      }
    }
    const bpsError = checkBps(
      group.changeOfControlBps,
      "change-of-control probability",
    );
    if (bpsError) {
      return fail(bpsError);
    }

    contractCount += group.count;
    annualRevenueCents += group.count * group.annualRevenueCents;
    if (group.consentRequired) {
      contractsWithConsent += group.count;
      consentCostCents += group.count * group.consentCostCents;
    }
    if (input.structure === "asset") {
      reSignHours += group.count * group.reSignHours;
    }
    atRiskContracts += Math.round(
      (group.count * group.changeOfControlBps) / 10000,
    );
    atRiskRevenueCents += Math.round(
      (group.count * group.annualRevenueCents * group.changeOfControlBps) /
        10000,
    );
  }

  if (contractCount === 0) {
    return fail("contract groups must describe at least one contract");
  }
  if (input.structure === "asset") {
    reSignCostCents = Math.round(reSignHours * input.hourlyRateCents);
  }
  const totalCostCents = reSignCostCents + consentCostCents;

  return ok({
    structure: input.structure,
    automaticSuccession: input.structure === "stock",
    contractCount,
    contractsToRepaper: input.structure === "asset" ? contractCount : 0,
    contractsWithConsent,
    reSignHours,
    reSignCostCents,
    consentCostCents,
    totalCostCents,
    annualRevenueCents,
    totalCostBpsOfRevenue: divide(totalCostCents, annualRevenueCents),
    atRiskContracts,
    atRiskRevenueCents,
    atRiskRevenueBps: divide(atRiskRevenueCents, annualRevenueCents),
  });
}

export type AssignmentComparison = {
  cheaper: DealStructure | "equal";
  deltaCostCents: Cents;
  deltaCostBpsOfRevenue: Bps;
  sameAtRiskRevenue: boolean;
};

/**
 * Compares the two structures on contract work only. It deliberately ignores
 * price, tax basis, entity setup and the buyer's appetite for inherited
 * liabilities, because those belong to the deal-structure model. The point of
 * this comparison is narrow: how much does it cost to keep the same revenue
 * attached to a contracting party after closing?
 */
export function compareAssignment(
  asset: AssignmentOutcome,
  stock: AssignmentOutcome,
): Result<AssignmentComparison> {
  if (asset.structure !== "asset" || stock.structure !== "stock") {
    return fail("expected one asset outcome and one stock outcome");
  }
  if (asset.contractCount !== stock.contractCount) {
    return fail("both structures must describe the same contract base");
  }
  if (asset.annualRevenueCents !== stock.annualRevenueCents) {
    return fail("both structures must describe the same revenue base");
  }

  const deltaCostCents = asset.totalCostCents - stock.totalCostCents;
  const cheaper =
    deltaCostCents < 0 ? "asset" : deltaCostCents > 0 ? "stock" : "equal";

  return ok({
    cheaper,
    deltaCostCents,
    deltaCostBpsOfRevenue: divide(
      Math.abs(deltaCostCents),
      asset.annualRevenueCents,
    ),
    sameAtRiskRevenue:
      asset.atRiskRevenueCents === stock.atRiskRevenueCents,
  });
}