《独立开发者的商业指南·资本与退出》11.3 债务、合同与主体注销

可用资金 = 48,000 + 11,264 × 90% = 58,137.60
总义务 = 7,020 + 18,518.40 + 6,000 + 0 + 25,000 + 5,000 + 3,600 + 3,600 = 68,738.40
缺口 = 58,137.60 − 68,738.40 = −10,600.80

// file: src/capital/entity-deregistration.ts
// tier: L1
// verify: node --test test/capital/entity-deregistration.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 ObligationClass =
  | "customer-refund"
  | "customer-commitment"
  | "termination"
  | "employee"
  | "secured-debt"
  | "unsecured-payable"
  | "deregistration"
  | "tail-compliance";

export type ObligationRow = {
  class: ObligationClass;
  label: string;
  amountCents: Cents;
};

export type DeregistrationInput = {
  cashCents: Cents;
  receivablesCents: Cents;
  collectionRateBps: Bps;
  refundCents: Cents;
  minimumCommitmentCents: Cents;
  terminationPenaltyCents: Cents;
  severanceCents: Cents;
  payablesCents: Cents;
  debtCents: Cents;
  filingCents: Cents;
  advisorCents: Cents;
  monthlyComplianceCents: Cents;
  deregistrationMonths: number;
  guaranteeCents: Cents;
  partners: number;
};

export type DeregistrationOutcome = {
  collectedReceivablesCents: Cents;
  availableCents: Cents;
  obligations: ObligationRow[];
  coreObligationsCents: Cents;
  tailComplianceCents: Cents;
  totalObligationsCents: Cents;
  residualCents: Cents;
  guaranteeCallCents: Cents;
  guaranteeShortfallCents: Cents;
  shortfallPerPartnerCents: Cents;
  deregistrationDays: number;
  funded: boolean;
};

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

/**
 * Deregistration is a waterfall, not a switch. Cash and collected receivables
 * pay the obligations in their contractual order: customer refunds and
 * unfulfilled commitments first, then termination and employee costs, then
 * secured debt, then unsecured payables, then the filing and advisor fees. The
 * compliance tail continues after the last customer leaves, so it is added to
 * the same total. A negative residual calls the personal guarantee; anything
 * the guarantee cannot cover stays with the partners.
 */
export function entityDeregistration(
  input: DeregistrationInput,
): Result<DeregistrationOutcome> {
  for (const [value, label] of [
    [input.cashCents, "cash"],
    [input.receivablesCents, "receivables"],
    [input.refundCents, "customer refund"],
    [input.minimumCommitmentCents, "minimum commitment"],
    [input.terminationPenaltyCents, "termination penalty"],
    [input.severanceCents, "severance"],
    [input.payablesCents, "payables"],
    [input.debtCents, "debt"],
    [input.filingCents, "filing fee"],
    [input.advisorCents, "advisor fee"],
    [input.monthlyComplianceCents, "monthly compliance"],
    [input.guaranteeCents, "personal guarantee"],
  ] as Array<[Cents, string]>) {
    const error = checkAmount(value, label);
    if (error) {
      return fail(error);
    }
  }
  if (
    !Number.isInteger(input.collectionRateBps) ||
    input.collectionRateBps < 0 ||
    input.collectionRateBps > 10000
  ) {
    return fail("collection rate must be between 0 and 10000 bps");
  }
  if (
    !Number.isInteger(input.deregistrationMonths) ||
    input.deregistrationMonths < 1 ||
    input.deregistrationMonths > 24
  ) {
    return fail("deregistration months must be an integer between 1 and 24");
  }
  if (!Number.isInteger(input.partners) || input.partners < 1) {
    return fail("partners must be a positive integer");
  }

  const collectedReceivablesCents = applyRate(
    input.receivablesCents,
    input.collectionRateBps,
  );
  const availableCents = input.cashCents + collectedReceivablesCents;
  const tailComplianceCents =
    input.monthlyComplianceCents * input.deregistrationMonths;

  const obligations: ObligationRow[] = [
    {
      class: "customer-refund",
      label: "unused subscription refunds",
      amountCents: input.refundCents,
    },
    {
      class: "customer-commitment",
      label: "unfulfilled minimum commitments",
      amountCents: input.minimumCommitmentCents,
    },
    {
      class: "termination",
      label: "contract termination penalties",
      amountCents: input.terminationPenaltyCents,
    },
    {
      class: "employee",
      label: "severance and notice",
      amountCents: input.severanceCents,
    },
    {
      class: "secured-debt",
      label: "secured or guaranteed debt",
      amountCents: input.debtCents,
    },
    {
      class: "unsecured-payable",
      label: "unsecured payables",
      amountCents: input.payablesCents,
    },
    {
      class: "deregistration",
      label: "filing and advisor fees",
      amountCents: input.filingCents + input.advisorCents,
    },
    {
      class: "tail-compliance",
      label: "post-closure compliance",
      amountCents: tailComplianceCents,
    },
  ];

  const coreObligationsCents = obligations
    .filter((row) => row.class !== "tail-compliance")
    .reduce((acc, row) => acc + row.amountCents, 0);
  const totalObligationsCents = coreObligationsCents + tailComplianceCents;
  const residualCents = availableCents - totalObligationsCents;
  const guaranteeCallCents =
    residualCents < 0 ? Math.min(-residualCents, input.guaranteeCents) : 0;
  const guaranteeShortfallCents =
    residualCents < 0
      ? Math.max(0, -residualCents - input.guaranteeCents)
      : 0;

  return ok({
    collectedReceivablesCents,
    availableCents,
    obligations,
    coreObligationsCents,
    tailComplianceCents,
    totalObligationsCents,
    residualCents,
    guaranteeCallCents,
    guaranteeShortfallCents,
    shortfallPerPartnerCents: Math.round(
      guaranteeCallCents / input.partners,
    ),
    deregistrationDays: input.deregistrationMonths * 30,
    funded: residualCents >= 0,
  });
}