《独立开发者的商业指南·资本与退出》11.2 用户、数据与订阅的收尾

第 1 个月：260 × (1 − 8%) = 239
第 2 个月：239 × (1 − 8%) = 220
第 3 个月：220 × (1 − 8%) = 202
流失客户 = 260 − 202 = 58

潜在退款 = 78 × 77 × 5 = 30,030
账面递延收入 = 22,000
实际退款上限 = min(30,030, 22,000) = 22,000
退款缺口 = 30,030 − 22,000 = 8,030

// file: src/capital/user-data-winddown.ts
// tier: L1
// verify: node --test test/capital/user-data-winddown.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 WinddownInput = {
  customers: number;
  arpaCents: Cents;
  annualShareBps: Bps;
  prepaidMonths: number;
  unusedMonths: number;
  deferredRevenueCents: Cents;
  baselineMonthlyChurnBps: Bps;
  announcementChurnBps: Bps;
  winddownMonths: number;
  exportRequestBps: Bps;
  exportCostCents: Cents;
  deletionCostCents: Cents;
  supportHours: number;
  supportRateCents: Cents;
  notificationCents: Cents;
};

export type WinddownOutcome = {
  annualCustomers: number;
  potentialRefundCents: Cents;
  refundCents: Cents;
  refundCapGapCents: Cents;
  remainingCustomers: number;
  churnedCustomers: number;
  churnMultipleBps: Bps;
  lostMrrCents: Cents;
  lostArrCents: Cents;
  exportRequests: number;
  exportCostCents: Cents;
  supportCostCents: Cents;
  totalWinddownCostCents: Cents;
  refundShareOfDeferredBps: Bps;
};

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 shutdown announcement changes two numbers at once. Churn rises above the
 * steady-state rate, so the customer base shrinks faster than the business
 * plan assumed. Prepaid annual customers also gain a refund claim measured by
 * unused months; that claim can exceed the deferred-revenue balance because
 * the balance was recorded net of the annual discount. The refund is capped at
 * the recorded liability, and the gap is the cash the owner must find.
 */
export function userDataWinddown(
  input: WinddownInput,
): Result<WinddownOutcome> {
  if (!Number.isInteger(input.customers) || input.customers <= 0) {
    return fail("customers must be a positive integer");
  }
  if (!Number.isInteger(input.arpaCents) || input.arpaCents <= 0) {
    return fail("ARPA must be a positive integer amount in cents");
  }
  for (const [value, label] of [
    [input.annualShareBps, "annual share"],
    [input.baselineMonthlyChurnBps, "baseline monthly churn"],
    [input.announcementChurnBps, "announcement churn"],
    [input.exportRequestBps, "export request share"],
  ] as Array<[Bps, string]>) {
    const error = checkBps(value, label);
    if (error) {
      return fail(error);
    }
  }
  for (const [value, label] of [
    [input.prepaidMonths, "prepaid months"],
    [input.unusedMonths, "unused months"],
  ] as Array<[number, string]>) {
    if (!Number.isInteger(value) || value < 0 || value > 36) {
      return fail(`${label} must be an integer between 0 and 36`);
    }
  }
  if (input.unusedMonths > input.prepaidMonths) {
    return fail("unused months cannot exceed prepaid months");
  }
  if (
    !Number.isInteger(input.winddownMonths) ||
    input.winddownMonths < 1 ||
    input.winddownMonths > 12
  ) {
    return fail("wind-down months must be an integer between 1 and 12");
  }
  if (!Number.isInteger(input.supportHours) || input.supportHours < 0) {
    return fail("support hours must be a non-negative integer");
  }
  for (const [value, label] of [
    [input.deferredRevenueCents, "deferred revenue"],
    [input.exportCostCents, "export cost"],
    [input.deletionCostCents, "deletion cost"],
    [input.supportRateCents, "support rate"],
    [input.notificationCents, "notification"],
  ] as Array<[Cents, string]>) {
    const error = checkAmount(value, label);
    if (error) {
      return fail(error);
    }
  }

  const annualCustomers = Math.round(
    (input.customers * input.annualShareBps) / 10000,
  );
  const potentialRefundCents =
    annualCustomers * input.arpaCents * input.unusedMonths;
  const refundCents = Math.min(
    potentialRefundCents,
    input.deferredRevenueCents,
  );
  const refundCapGapCents = potentialRefundCents - refundCents;

  let remainingCustomers = input.customers;
  for (let month = 0; month < input.winddownMonths; month += 1) {
    remainingCustomers = Math.round(
      (remainingCustomers * (10000 - input.announcementChurnBps)) / 10000,
    );
  }
  const churnedCustomers = input.customers - remainingCustomers;
  const lostMrrCents = churnedCustomers * input.arpaCents;

  const exportRequests = Math.round(
    (input.customers * input.exportRequestBps) / 10000,
  );
  const exportCostCents = exportRequests * input.exportCostCents;
  const supportCostCents = input.supportHours * input.supportRateCents;

  return ok({
    annualCustomers,
    potentialRefundCents,
    refundCents,
    refundCapGapCents,
    remainingCustomers,
    churnedCustomers,
    churnMultipleBps: divide(
      input.announcementChurnBps,
      input.baselineMonthlyChurnBps,
    ),
    lostMrrCents,
    lostArrCents: lostMrrCents * 12,
    exportRequests,
    exportCostCents,
    supportCostCents,
    totalWinddownCostCents:
      refundCents +
      input.notificationCents +
      exportCostCents +
      input.deletionCostCents +
      supportCostCents,
    refundShareOfDeferredBps: divide(
      refundCents,
      input.deferredRevenueCents,
    ),
  });
}