《移动游戏产品的架构·商业化与发行工程》3.3 渠道包构建：变体、签名与合规检查

// file: src/biz/channel-build.ts
// tier: L1
// verify: node --test test/biz/channel-build.test.ts

export type BuildPlatform = "android" | "ios";

export interface VariantSpec {
  readonly id: string;
  readonly platform: BuildPlatform;
  readonly extraSizeMB: number;
  readonly signingKeyId: string;
  readonly packageSuffix: string;
  readonly thirdPartySdkCount: number;
  readonly permissionCount: number;
  readonly privacyVersion: string;
}

export interface BuildRules {
  readonly baseSizeMB: number;
  readonly maxExtraSizeMB: number;
  readonly expectedVariants: number;
  readonly maxThirdPartySdks: number;
  readonly maxPermissions: number;
  readonly requiredPrivacyVersion: string;
}

export interface ComplianceIssue {
  readonly code: string;
  readonly variantId: string;
  readonly detail: string;
}

export interface BuildReport {
  readonly packages: number;
  readonly largestExtraMB: number;
  readonly smallestExtraMB: number;
  readonly largestPackageMB: number;
  readonly androidKeys: number;
  readonly iosKeys: number;
  readonly issues: readonly ComplianceIssue[];
  readonly blocking: boolean;
}

function validateRules(rules: BuildRules): void {
  if (!Number.isFinite(rules.baseSizeMB) || rules.baseSizeMB <= 0) {
    throw new RangeError("baseSizeMB must be positive");
  }
  if (!Number.isFinite(rules.maxExtraSizeMB) || rules.maxExtraSizeMB < 0) {
    throw new RangeError("maxExtraSizeMB must be >= 0");
  }
  if (!Number.isInteger(rules.expectedVariants) || rules.expectedVariants <= 0) {
    throw new RangeError("expectedVariants must be a positive integer");
  }
  if (!Number.isInteger(rules.maxThirdPartySdks) || rules.maxThirdPartySdks <= 0) {
    throw new RangeError("maxThirdPartySdks must be a positive integer");
  }
  if (!Number.isInteger(rules.maxPermissions) || rules.maxPermissions <= 0) {
    throw new RangeError("maxPermissions must be a positive integer");
  }
  if (typeof rules.requiredPrivacyVersion !== "string" || rules.requiredPrivacyVersion.length === 0) {
    throw new Error("requiredPrivacyVersion is required");
  }
}

export function buildReport(variants: readonly VariantSpec[], rules: BuildRules): BuildReport {
  validateRules(rules);
  if (variants.length === 0) {
    throw new Error("buildReport needs at least one variant");
  }

  const issues: ComplianceIssue[] = [];
  const seenIds = new Set<string>();
  const seenSuffixes = new Set<string>();
  const androidKeys = new Set<string>();
  const iosKeys = new Set<string>();
  let largestExtra = -Infinity;
  let smallestExtra = Infinity;

  if (variants.length !== rules.expectedVariants) {
    issues.push({
      code: "variant-count",
      variantId: "*",
      detail: `expected ${rules.expectedVariants} variants, got ${variants.length}`,
    });
  }

  for (const variant of variants) {
    if (seenIds.has(variant.id)) {
      issues.push({ code: "duplicate-variant", variantId: variant.id, detail: "duplicate variant id" });
    }
    seenIds.add(variant.id);

    if (!Number.isFinite(variant.extraSizeMB) || variant.extraSizeMB < 0) {
      issues.push({ code: "negative-size", variantId: variant.id, detail: `extra size ${variant.extraSizeMB}MB` });
    } else {
      largestExtra = Math.max(largestExtra, variant.extraSizeMB);
      smallestExtra = Math.min(smallestExtra, variant.extraSizeMB);
      if (variant.extraSizeMB > rules.maxExtraSizeMB) {
        issues.push({
          code: "size-budget",
          variantId: variant.id,
          detail: `+${variant.extraSizeMB}MB exceeds +${rules.maxExtraSizeMB}MB`,
        });
      }
    }

    if (typeof variant.signingKeyId !== "string" || variant.signingKeyId.length === 0) {
      issues.push({ code: "missing-signing-key", variantId: variant.id, detail: "signing key is empty" });
    } else if (variant.platform === "android") {
      androidKeys.add(variant.signingKeyId);
    } else if (variant.platform === "ios") {
      iosKeys.add(variant.signingKeyId);
    } else {
      issues.push({ code: "unknown-platform", variantId: variant.id, detail: String(variant.platform) });
    }

    if (typeof variant.packageSuffix !== "string" || variant.packageSuffix.length === 0) {
      issues.push({ code: "missing-suffix", variantId: variant.id, detail: "package suffix is empty" });
    } else if (seenSuffixes.has(variant.packageSuffix)) {
      issues.push({ code: "duplicate-suffix", variantId: variant.id, detail: variant.packageSuffix });
    } else {
      seenSuffixes.add(variant.packageSuffix);
    }

    if (!Number.isInteger(variant.thirdPartySdkCount) || variant.thirdPartySdkCount < 0) {
      issues.push({ code: "invalid-sdk-count", variantId: variant.id, detail: String(variant.thirdPartySdkCount) });
    } else if (variant.thirdPartySdkCount > rules.maxThirdPartySdks) {
      issues.push({
        code: "sdk-budget",
        variantId: variant.id,
        detail: `${variant.thirdPartySdkCount} > ${rules.maxThirdPartySdks}`,
      });
    }

    if (!Number.isInteger(variant.permissionCount) || variant.permissionCount < 0) {
      issues.push({ code: "invalid-permission-count", variantId: variant.id, detail: String(variant.permissionCount) });
    } else if (variant.permissionCount > rules.maxPermissions) {
      issues.push({
        code: "permission-budget",
        variantId: variant.id,
        detail: `${variant.permissionCount} > ${rules.maxPermissions}`,
      });
    }

    if (variant.privacyVersion !== rules.requiredPrivacyVersion) {
      issues.push({
        code: "privacy-version",
        variantId: variant.id,
        detail: `${variant.privacyVersion} != ${rules.requiredPrivacyVersion}`,
      });
    }
  }

  const largestPackageMB = rules.baseSizeMB + (largestExtra === -Infinity ? 0 : largestExtra);
  return {
    packages: variants.length,
    largestExtraMB: largestExtra === -Infinity ? 0 : largestExtra,
    smallestExtraMB: smallestExtra === Infinity ? 0 : smallestExtra,
    largestPackageMB,
    androidKeys: androidKeys.size,
    iosKeys: iosKeys.size,
    issues,
    blocking: issues.length > 0,
  };
}

export function formatBuildReport(report: BuildReport): string {
  return `packages=${report.packages} largest=+${report.largestExtraMB}MB smallest=+${report.smallestExtraMB}MB maxPackage=${report.largestPackageMB}MB keys=${report.androidKeys}android/${report.iosKeys}ios blocking=${report.blocking} issues=${report.issues.length}`;
}

export function formatIssues(report: BuildReport): string {
  if (report.issues.length === 0) {
    return "none";
  }
  return report.issues.map((issue) => `${issue.code}@${issue.variantId}:${issue.detail}`).join("; ");
}

packages=11 largest=+18MB smallest=+0MB maxPackage=138MB keys=1android/1ios blocking=false issues=0