《移动游戏产品的架构·网络、资源与热更新》9.3 双案例的首包账：120MB 与 350MB

// file: src/lab/package-ledger.ts
// tier: L1
// verify: node --test test/lab/package-ledger.test.ts

export interface GameProfile {
  readonly id: string;
  readonly firstPackageBytes: number;
  readonly subpackageBytes: readonly number[];
  readonly downloadSuccess: number;
  readonly weakNetworkSuccess: number | null;
  readonly monthlyInstalls: number;
  readonly dau: number;
  readonly dailyTrafficMb: number;
  readonly incrementalUpdateBytes: number;
  readonly updatePeriodDays: number;
  readonly storeReleaseDays: number;
  readonly deltaMinBytes: number;
  readonly deltaMaxBytes: number;
  readonly assetFiles: number;
  readonly cdnMonthlyTb: number;
}

export interface GameLedger {
  readonly id: string;
  readonly firstPackageBytes: number;
  readonly subpackageBytes: number;
  readonly totalBytes: number;
  readonly firstSharePct: number;
  readonly averageAssetBytes: number;
  readonly monthlyInstalls: number;
  readonly failedInstallsPerMonth: number;
  readonly installFirstTb: number;
  readonly cdnFirstSharePct: number;
  readonly monthlyBusinessTb: number;
  readonly updatesPerYear: number;
  readonly updateBytesPerYear: number;
  readonly storeReleasesPerYear: number;
  readonly weakNetworkSuccess: number | null;
}

export interface LedgerReport {
  readonly entries: readonly GameLedger[];
  readonly combinedInstalls: number;
  readonly combinedCdnTb: number;
  readonly combinedInstallFirstTb: number;
}

const TB_BYTES = 1024 ** 4;
const MB_BYTES = 1024 * 1024;
const MB_PER_TB = 1024 * 1024;

function round1(value: number): number {
  return Math.round(value * 10) / 10;
}

function round2(value: number): number {
  return Math.round(value * 100) / 100;
}

function validate(profile: GameProfile): void {
  if (!Number.isInteger(profile.firstPackageBytes) || profile.firstPackageBytes <= 0) {
    throw new Error(`invalid first package for ${profile.id}: ${profile.firstPackageBytes}`);
  }
  for (const bytes of profile.subpackageBytes) {
    if (!Number.isInteger(bytes) || bytes < 0) {
      throw new Error(`invalid subpackage for ${profile.id}: ${bytes}`);
    }
  }
  if (!(profile.downloadSuccess > 0 && profile.downloadSuccess <= 1)) {
    throw new Error(`invalid download success for ${profile.id}: ${profile.downloadSuccess}`);
  }
  if (
    profile.weakNetworkSuccess !== null &&
    !(profile.weakNetworkSuccess > 0 && profile.weakNetworkSuccess <= 1)
  ) {
    throw new Error(
      `invalid weak network success for ${profile.id}: ${profile.weakNetworkSuccess}`,
    );
  }
  if (!Number.isInteger(profile.monthlyInstalls) || profile.monthlyInstalls < 0) {
    throw new Error(`invalid installs for ${profile.id}: ${profile.monthlyInstalls}`);
  }
  if (!Number.isInteger(profile.dau) || profile.dau < 0) {
    throw new Error(`invalid dau for ${profile.id}: ${profile.dau}`);
  }
  if (profile.dailyTrafficMb < 0) {
    throw new Error(`invalid daily traffic for ${profile.id}: ${profile.dailyTrafficMb}`);
  }
  if (!Number.isInteger(profile.incrementalUpdateBytes) || profile.incrementalUpdateBytes < 0) {
    throw new Error(`invalid update bytes for ${profile.id}: ${profile.incrementalUpdateBytes}`);
  }
  if (!Number.isInteger(profile.updatePeriodDays) || profile.updatePeriodDays <= 0) {
    throw new Error(`invalid update period for ${profile.id}: ${profile.updatePeriodDays}`);
  }
  if (!Number.isInteger(profile.storeReleaseDays) || profile.storeReleaseDays <= 0) {
    throw new Error(`invalid store release period for ${profile.id}: ${profile.storeReleaseDays}`);
  }
  if (
    !Number.isInteger(profile.deltaMinBytes) ||
    !Number.isInteger(profile.deltaMaxBytes) ||
    profile.deltaMinBytes < 0 ||
    profile.deltaMaxBytes < profile.deltaMinBytes
  ) {
    throw new Error(
      `invalid delta range for ${profile.id}: ${profile.deltaMinBytes}..${profile.deltaMaxBytes}`,
    );
  }
  if (!Number.isInteger(profile.assetFiles) || profile.assetFiles <= 0) {
    throw new Error(`invalid asset files for ${profile.id}: ${profile.assetFiles}`);
  }
  if (!Number.isFinite(profile.cdnMonthlyTb) || profile.cdnMonthlyTb <= 0) {
    throw new Error(`invalid cdn volume for ${profile.id}: ${profile.cdnMonthlyTb}`);
  }
}

function installFirstTb(profile: GameProfile): number {
  return (profile.monthlyInstalls * profile.firstPackageBytes) / TB_BYTES;
}

export function summarizeGame(profile: GameProfile): GameLedger {
  validate(profile);

  const subpackageBytes = profile.subpackageBytes.reduce((sum, bytes) => sum + bytes, 0);
  const totalBytes = profile.firstPackageBytes + subpackageBytes;
  const updatesPerYear = Math.round(365 / profile.updatePeriodDays);
  const firstTb = installFirstTb(profile);

  return {
    id: profile.id,
    firstPackageBytes: profile.firstPackageBytes,
    subpackageBytes,
    totalBytes,
    firstSharePct: round2((profile.firstPackageBytes / totalBytes) * 100),
    averageAssetBytes: Math.round(totalBytes / profile.assetFiles),
    monthlyInstalls: profile.monthlyInstalls,
    failedInstallsPerMonth: Math.round(
      profile.monthlyInstalls * (1 - profile.downloadSuccess),
    ),
    installFirstTb: round2(firstTb),
    cdnFirstSharePct: round2((firstTb / profile.cdnMonthlyTb) * 100),
    monthlyBusinessTb: round2(
      (profile.dau * 30 * profile.dailyTrafficMb) / MB_PER_TB,
    ),
    updatesPerYear,
    updateBytesPerYear: updatesPerYear * profile.incrementalUpdateBytes,
    storeReleasesPerYear: round1(365 / profile.storeReleaseDays),
    weakNetworkSuccess: profile.weakNetworkSuccess,
  };
}

export function compareLedger(profiles: readonly GameProfile[]): LedgerReport {
  if (profiles.length === 0) {
    throw new Error("ledger needs at least one game");
  }

  const seen = new Set<string>();
  const entries: GameLedger[] = [];
  let combinedInstalls = 0;
  let combinedCdnTb = 0;
  let combinedInstallFirstTb = 0;

  for (const profile of profiles) {
    if (seen.has(profile.id)) throw new Error(`duplicate game: ${profile.id}`);
    seen.add(profile.id);
    validate(profile);
    entries.push(summarizeGame(profile));
    combinedInstalls += profile.monthlyInstalls;
    combinedCdnTb += profile.cdnMonthlyTb;
    combinedInstallFirstTb += installFirstTb(profile);
  }

  entries.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));

  return {
    entries,
    combinedInstalls,
    combinedCdnTb: round2(combinedCdnTb),
    combinedInstallFirstTb: round2(combinedInstallFirstTb),
  };
}

function mb(bytes: number): string {
  return (bytes / MB_BYTES).toFixed(2);
}

export function formatLedger(report: LedgerReport): string {
  const lines = [
    "game\tfirstMB\tsubMB\ttotalMB\tfirst%\tinstalls/mo\tfail/mo\tinstallFirstTiB\tcdnShare%\tupdateMB/yr",
  ];
  for (const entry of report.entries) {
    lines.push(
      [
        entry.id,
        mb(entry.firstPackageBytes),
        mb(entry.subpackageBytes),
        mb(entry.totalBytes),
        entry.firstSharePct.toFixed(2),
        entry.monthlyInstalls,
        entry.failedInstallsPerMonth,
        entry.installFirstTb.toFixed(2),
        entry.cdnFirstSharePct.toFixed(1),
        entry.updateBytesPerYear / MB_BYTES,
      ].join("\t"),
    );
  }
  lines.push(
    `combined\t-\t-\t-\t-\t${report.combinedInstalls}\t-\t${report.combinedInstallFirstTb.toFixed(2)}\t-\t-`,
  );
  lines.push(
    `cdn\t${report.combinedCdnTb.toFixed(2)}TB/mo\t${report.entries.length} games\t-\t-\t-\t-\t-\t-\t-`,
  );
  return lines.join("\n");
}

game	firstMB	subMB	totalMB	first%	installs/mo	fail/mo	installFirstTiB	cdnShare%	updateMB/yr
casual	120.00	360.00	480.00	25.00	420000	10500	48.07	23.9	312
midcore	350.00	1490.00	1840.00	19.02	80000	1120	26.70	18.2	2340
combined	-	-	-	-	500000	-	74.77	-	-
cdn	348.00TB/mo	2 games	-	-	-	-	-	-	-