《独立开发者的商业指南·收入与财务工程》1.3 生命周期转型：从服务到产品、从买断到订阅

咨询月收入 = 110 小时 × $85/小时 = $9,350

所需客户数 = ceil($9,350 ÷ $39) = ceil(239.74) = 240 家

C(t) = C(t−1) − round(C(t−1) × 3.0%) + 15
MRR(t) = C(t) × $39

咨询月收入(t) = $9,350 × max(0, 12 − t) ÷ 12

月缺口(t) = max(0, $12,860 − 咨询收入(t) − 产品 MRR(t))
累计缺口 = Σ 月缺口(t)

缺口 runway = floor($25,740 ÷ $2,560) = 10 个月
资金缺口 = $38,398 − $25,740 = $12,658

// file: src/fin/transition.ts
// tier: L1
// verify: node --test test/fin/transition.test.ts

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

export type ReplacementInput = {
  targetMrrCents: Cents;
  productPriceCents: Cents;
  currentCustomers: number;
  monthlyChurnBps: Bps;
  grossAddsPerMonth: number;
  maxMonths?: number;
};

export type Replacement = {
  targetMrrCents: Cents;
  customersNeeded: number;
  monthsToReplace: number;
  finalCustomers: number;
  finalMrrCents: Cents;
  series: Cents[];
};

export type GapPoint = {
  month: number;
  serviceCents: Cents;
  productCents: Cents;
  totalCents: Cents;
  gapCents: Cents;
};

export type GapResult = {
  points: GapPoint[];
  totalGapCents: Cents;
  averageGapCents: Cents;
  months: number;
};

function validate(input: ReplacementInput): Result<number> {
  if (!Number.isInteger(input.targetMrrCents) || input.targetMrrCents <= 0) {
    return fail("target MRR must be a positive integer number of cents");
  }
  if (!Number.isInteger(input.productPriceCents) || input.productPriceCents <= 0) {
    return fail("product price must be a positive integer number of cents");
  }
  if (!Number.isInteger(input.currentCustomers) || input.currentCustomers < 0) {
    return fail("current customers must be a non-negative integer");
  }
  if (
    !Number.isInteger(input.monthlyChurnBps) ||
    input.monthlyChurnBps < 0 ||
    input.monthlyChurnBps > 10000
  ) {
    return fail("monthly churn must be an integer between 0 and 10000 bps");
  }
  if (
    !Number.isInteger(input.grossAddsPerMonth) ||
    input.grossAddsPerMonth < 0
  ) {
    return fail("gross adds must be a non-negative integer");
  }
  const maxMonths = input.maxMonths ?? 120;
  if (!Number.isInteger(maxMonths) || maxMonths <= 0) {
    return fail("maxMonths must be a positive integer");
  }
  return ok(maxMonths);
}

/**
 * Customers needed so that product MRR reaches targetMrrCents, and the number
 * of months to get there assuming a fixed monthly gross-add count and churn.
 */
export function replacementMrr(input: ReplacementInput): Result<Replacement> {
  const checked = validate(input);
  if (!checked.ok) {
    return checked;
  }
  const customersNeeded = Math.ceil(
    input.targetMrrCents / input.productPriceCents,
  );
  let customers = input.currentCustomers;
  let mrr = customers * input.productPriceCents;
  if (mrr >= input.targetMrrCents) {
    return ok({
      targetMrrCents: input.targetMrrCents,
      customersNeeded,
      monthsToReplace: 0,
      finalCustomers: customers,
      finalMrrCents: mrr,
      series: [],
    });
  }
  const series: Cents[] = [];
  for (let month = 1; month <= checked.value; month++) {
    const churned = Math.round(
      (customers * input.monthlyChurnBps) / 10000,
    );
    customers = Math.max(0, customers - churned + input.grossAddsPerMonth);
    mrr = customers * input.productPriceCents;
    series.push(mrr);
    if (mrr >= input.targetMrrCents) {
      return ok({
        targetMrrCents: input.targetMrrCents,
        customersNeeded,
        monthsToReplace: month,
        finalCustomers: customers,
        finalMrrCents: mrr,
        series,
      });
    }
  }
  return fail(`target not reached within ${checked.value} months`);
}

/**
 * Monthly cash gap while service revenue runs off linearly and product MRR
 * follows productSeries. gap = max(0, baseline - service - product).
 */
export function transitionGap(
  baselineMonthlyCents: Cents,
  serviceMonthlyCents: Cents,
  serviceRunoffMonths: number,
  productSeries: Cents[],
): Result<GapResult> {
  if (!Number.isInteger(baselineMonthlyCents) || baselineMonthlyCents <= 0) {
    return fail("baseline revenue must be a positive integer number of cents");
  }
  if (!Number.isInteger(serviceMonthlyCents) || serviceMonthlyCents < 0) {
    return fail("service revenue must be a non-negative integer number of cents");
  }
  if (
    !Number.isInteger(serviceRunoffMonths) ||
    serviceRunoffMonths <= 0
  ) {
    return fail("service runoff must be a positive number of months");
  }
  if (productSeries.length === 0) {
    return fail("product series must not be empty");
  }
  for (const mrr of productSeries) {
    if (!Number.isInteger(mrr) || mrr < 0) {
      return fail("product series values must be non-negative integers");
    }
  }
  const points: GapPoint[] = productSeries.map((productCents, index) => {
    const month = index + 1;
    const remaining = Math.max(0, serviceRunoffMonths - month);
    const serviceCents = Math.round(
      (serviceMonthlyCents * remaining) / serviceRunoffMonths,
    );
    const totalCents = serviceCents + productCents;
    return {
      month,
      serviceCents,
      productCents,
      totalCents,
      gapCents: Math.max(0, sub(baselineMonthlyCents, totalCents)),
    };
  });
  const totalGapCents = points.reduce((acc, point) => acc + point.gapCents, 0);
  return ok({
    points,
    totalGapCents,
    averageGapCents: Math.round(totalGapCents / points.length),
    months: points.length,
  });
}

/** Full months of cash at a constant monthly gap; Infinity when the gap is zero. */
export function runwayMonths(
  cashCents: Cents,
  monthlyGapCents: Cents,
): Result<number> {
  if (!Number.isInteger(cashCents) || cashCents < 0) {
    return fail("cash must be a non-negative integer number of cents");
  }
  if (!Number.isInteger(monthlyGapCents) || monthlyGapCents < 0) {
    return fail("monthly gap must be a non-negative integer number of cents");
  }
  if (monthlyGapCents === 0) {
    return ok(Number.POSITIVE_INFINITY);
  }
  return ok(Math.floor(cashCents / monthlyGapCents));
}