《独立开发者的商业指南·资本与退出》7.1 资产收购与股权收购

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

export const STRUCTURE_ORDER: DealStructure[] = ["asset", "stock"];

export type ContractGroup = {
  count: number;
  reSignCostCents: Cents;
  consentRequired: boolean;
  consentCostCents: Cents;
};

export type StructureInput = {
  structure: DealStructure;
  priceCents: Cents;
  contractGroups: ContractGroup[];
  accountTransferCostCents: Cents;
  entitySetupCostCents: Cents;
  assumedLiabilityCents: Cents;
  retainedLiabilityCents: Cents;
};

export type StructureCost = {
  structure: DealStructure;
  priceCents: Cents;
  contractCount: number;
  contractsToRepaper: number;
  reSignCents: Cents;
  consentCents: Cents;
  accountTransferCents: Cents;
  entitySetupCents: Cents;
  migrationCents: Cents;
  migrationBpsOfPrice: Bps;
  assumedLiabilityCents: Cents;
  retainedLiabilityCents: Cents;
  sellerNetCents: Cents;
};

export type StructureComparison = {
  cheaper: DealStructure | "equal";
  deltaMigrationCents: Cents;
  deltaSellerNetCents: Cents;
  deltaMigrationBpsOfPrice: Bps;
};

function isStructure(value: string): value is DealStructure {
  return (STRUCTURE_ORDER as string[]).includes(value);
}

/**
 * An asset deal re-papers every contract because the contracting party is a
 * new entity. A stock deal keeps the contracts inside the old entity and only
 * pays for change-of-control consents. Retained liabilities stay with the
 * seller in an asset deal; a stock deal has no retained liabilities because the
 * entity itself changes hands. This is a teaching model, not legal or tax
 * advice.
 */
export function assessStructure(
  input: StructureInput,
): Result<StructureCost> {
  if (!isStructure(input.structure)) {
    return fail("structure must be asset or stock");
  }
  if (!Number.isInteger(input.priceCents) || input.priceCents <= 0) {
    return fail("price must be a positive integer amount in cents");
  }
  if (
    !Number.isInteger(input.accountTransferCostCents) ||
    input.accountTransferCostCents < 0
  ) {
    return fail("account transfer cost must be a non-negative integer amount");
  }
  if (
    !Number.isInteger(input.entitySetupCostCents) ||
    input.entitySetupCostCents < 0
  ) {
    return fail("entity setup cost must be a non-negative integer amount");
  }
  if (
    !Number.isInteger(input.assumedLiabilityCents) ||
    input.assumedLiabilityCents < 0
  ) {
    return fail("assumed liability must be a non-negative integer amount");
  }
  if (
    !Number.isInteger(input.retainedLiabilityCents) ||
    input.retainedLiabilityCents < 0
  ) {
    return fail("retained liability must be a non-negative integer amount");
  }
  if (input.structure === "stock" && input.retainedLiabilityCents > 0) {
    return fail("a stock deal does not leave liabilities with the seller");
  }
  if (input.structure === "stock" && input.entitySetupCostCents > 0) {
    return fail("a stock deal reuses the target entity; no setup cost");
  }

  let contractCount = 0;
  let reSignCents = 0;
  let consentCents = 0;

  for (const group of input.contractGroups) {
    if (!Number.isInteger(group.count) || group.count < 0) {
      return fail("contract count must be a non-negative integer");
    }
    if (
      !Number.isInteger(group.reSignCostCents) ||
      group.reSignCostCents < 0
    ) {
      return fail("re-sign cost must be a non-negative integer amount");
    }
    if (
      !Number.isInteger(group.consentCostCents) ||
      group.consentCostCents < 0
    ) {
      return fail("consent cost must be a non-negative integer amount");
    }
    contractCount += group.count;
    if (input.structure === "asset") {
      reSignCents += group.count * group.reSignCostCents;
    }
    if (group.consentRequired) {
      consentCents += group.count * group.consentCostCents;
    }
  }

  const contractsToRepaper =
    input.structure === "asset" ? contractCount : 0;
  const entitySetupCents =
    input.structure === "asset" ? input.entitySetupCostCents : 0;
  const migrationCents =
    reSignCents +
    consentCents +
    input.accountTransferCostCents +
    entitySetupCents;
  const retainedLiabilityCents =
    input.structure === "asset" ? input.retainedLiabilityCents : 0;
  const sellerNetCents =
    input.priceCents - migrationCents - retainedLiabilityCents;

  return ok({
    structure: input.structure,
    priceCents: input.priceCents,
    contractCount,
    contractsToRepaper,
    reSignCents,
    consentCents,
    accountTransferCents: input.accountTransferCostCents,
    entitySetupCents,
    migrationCents,
    migrationBpsOfPrice: divide(migrationCents, input.priceCents),
    assumedLiabilityCents: input.assumedLiabilityCents,
    retainedLiabilityCents,
    sellerNetCents,
  });
}

/**
 * Compares the seller's net proceeds under both structures at the same price.
 * The comparison is deliberately narrow: it counts migration cost and retained
 * liabilities, not the buyer's post-closing risk, tax basis or financing.
 */
export function compareStructures(
  asset: StructureCost,
  stock: StructureCost,
): Result<StructureComparison> {
  if (asset.structure !== "asset" || stock.structure !== "stock") {
    return fail("expected one asset deal and one stock deal");
  }
  if (asset.contractCount !== stock.contractCount) {
    return fail("both structures must describe the same contract base");
  }
  if (asset.priceCents !== stock.priceCents) {
    return fail("both structures must use the same headline price");
  }

  const deltaMigrationCents = asset.migrationCents - stock.migrationCents;
  const deltaSellerNetCents = asset.sellerNetCents - stock.sellerNetCents;
  const cheaper =
    deltaSellerNetCents < 0
      ? "stock"
      : deltaSellerNetCents > 0
        ? "asset"
        : "equal";

  return ok({
    cheaper,
    deltaMigrationCents,
    deltaSellerNetCents,
    deltaMigrationBpsOfPrice: divide(
      Math.abs(deltaMigrationCents),
      asset.priceCents,
    ),
  });
}