《独立开发者的商业指南·收入与财务工程》4.1 预收、递延与确认时点

年付客户数 = 260 × 30% = 78 家
月付客户数 = 260 × 70% = 182 家

年付现金 = 924 × (1 − 15%) = $785.40
月确认收入 = 785.40 ÷ 12 = $65.45

期末递延收入 = 期初递延收入 + 当年新增预收 − 当年确认收入

递延收入增加 = 期末递延 − 期初递延 = 22,000 − 14,000 = $8,000

平均剩余月数 = 22,000 ÷ (78 × 65.45) = 22,000 ÷ 5,105.10 ≈ 4.31 个月

递延收入 / ARR = 22,000 ÷ 240,240 = 9.2%

退款准备 = 191,904 × 4% = $7,676（精确值 $7,676.16）
退款后收入 = 191,904 − 7,676 = $184,228

Steam 退款后收入 = 153,523 − 6,141 = $147,382
Steam 平台分成 = 147,382 × 30% = $44,215
官网支付费 = (38,381 − 1,535) × 5% = $1,842

经营现金流 = 净利润 + 递延收入增加 − 应收增加
           = 58,299 + 8,000 − 2,000
           = $64,299

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

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

export type PrepaidContract = {
  monthlyCents: Cents;
  months: number;
  discountBps: Bps;
};

export type ContractProgress = PrepaidContract & {
  elapsedMonths: number;
};

export type MonthlyEntry = {
  month: number;
  recognizedCents: Cents;
  deferredCents: Cents;
};

export type RefundAdjustment = {
  refundCents: Cents;
  reversedRevenueCents: Cents;
  releasedDeferredCents: Cents;
};

export type OneTimeRefund = {
  grossCents: Cents;
  refundCents: Cents;
  netCents: Cents;
};

function checkContract(contract: PrepaidContract): string | null {
  if (!Number.isInteger(contract.months) || contract.months <= 0) {
    return "months must be a positive integer";
  }
  if (
    !Number.isInteger(contract.monthlyCents) ||
    contract.monthlyCents < 0
  ) {
    return "monthly amount must be a non-negative integer";
  }
  if (
    !Number.isInteger(contract.discountBps) ||
    contract.discountBps < 0 ||
    contract.discountBps >= 10000
  ) {
    return "discount must be between 0 and 9999 bps";
  }
  return null;
}

function splitEvenly(total: Cents, months: number): Cents[] {
  const base = Math.floor(total / months);
  const remainder = total - base * months;
  return Array.from(
    { length: months },
    (_, index) => base + (index < remainder ? 1 : 0),
  );
}

/** Cash collected up front for a discounted prepaid contract. */
export function prepaidCash(contract: PrepaidContract): Result<Cents> {
  const error = checkContract(contract);
  if (error) {
    return fail(error);
  }
  return ok(
    applyRate(
      contract.monthlyCents * contract.months,
      10000 - contract.discountBps,
    ),
  );
}

/**
 * Monthly recognition schedule. The split is rounded in cents, so the first
 * `total % months` entries carry one extra cent and the sum is exact.
 */
export function recognitionSchedule(
  contract: PrepaidContract,
): Result<MonthlyEntry[]> {
  const cash = prepaidCash(contract);
  if (!cash.ok) {
    return cash;
  }
  const parts = splitEvenly(cash.value, contract.months);
  let deferred = cash.value;
  return ok(
    parts.map((recognized, index) => {
      deferred = sub(deferred, recognized);
      return {
        month: index + 1,
        recognizedCents: recognized,
        deferredCents: deferred,
      };
    }),
  );
}

/** Remaining deferred balance for a set of contracts at their current progress. */
export function deferredBalance(
  contracts: ContractProgress[],
): Result<Cents> {
  if (contracts.length === 0) {
    return fail("at least one contract is required");
  }
  const balances: Cents[] = [];
  for (const contract of contracts) {
    const error = checkContract(contract);
    if (error) {
      return fail(error);
    }
    if (
      !Number.isInteger(contract.elapsedMonths) ||
      contract.elapsedMonths < 0 ||
      contract.elapsedMonths > contract.months
    ) {
      return fail("elapsed months out of range");
    }
    const cash = prepaidCash(contract);
    if (!cash.ok) {
      return cash;
    }
    const schedule = recognitionSchedule(contract);
    if (!schedule.ok) {
      return schedule;
    }
    balances.push(
      contract.elapsedMonths === 0
        ? cash.value
        : schedule.value[contract.elapsedMonths - 1].deferredCents,
    );
  }
  return ok(sum(balances));
}

/**
 * A refund after `refundAfterMonths` returns all cash, reverses revenue already
 * recognized, and releases whatever deferred balance remains.
 */
export function refundAdjustment(
  contract: PrepaidContract,
  refundAfterMonths: number,
): Result<RefundAdjustment> {
  const error = checkContract(contract);
  if (error) {
    return fail(error);
  }
  if (
    !Number.isInteger(refundAfterMonths) ||
    refundAfterMonths < 0 ||
    refundAfterMonths > contract.months
  ) {
    return fail("refund month out of range");
  }
  const cash = prepaidCash(contract);
  if (!cash.ok) {
    return cash;
  }
  const schedule = recognitionSchedule(contract);
  if (!schedule.ok) {
    return schedule;
  }
  const reversedRevenueCents = sum(
    schedule.value
      .slice(0, refundAfterMonths)
      .map((entry) => entry.recognizedCents),
  );
  return ok({
    refundCents: cash.value,
    reversedRevenueCents,
    releasedDeferredCents: sub(cash.value, reversedRevenueCents),
  });
}

/** Point-in-time sale with an estimated refund provision. */
export function oneTimeRefund(
  grossCents: Cents,
  refundRateBps: Bps,
): Result<OneTimeRefund> {
  if (!Number.isInteger(grossCents) || grossCents < 0) {
    return fail("gross amount must be a non-negative integer");
  }
  if (
    !Number.isInteger(refundRateBps) ||
    refundRateBps < 0 ||
    refundRateBps > 10000
  ) {
    return fail("refund rate must be between 0 and 10000 bps");
  }
  const refundCents = applyRate(grossCents, refundRateBps);
  return ok({
    grossCents,
    refundCents,
    netCents: sub(grossCents, refundCents),
  });
}