《移动游戏产品的架构·商业化与发行工程》12.3 商店审核材料与驳回应对

// file: src/biz/store-review.ts
// tier: L1
// verify: node --test test/biz/store-review.test.ts

export type Platform = "ios" | "android-cn" | "google-play" | "taptap";

export type MaterialKind =
  | "privacy-policy" | "icon" | "screenshots" | "description" | "age-rating"
  | "iap-disclosure" | "account-deletion" | "permission-strings" | "test-account" | "demo-video";

export const REQUIRED_MATERIALS: readonly MaterialKind[] = [
  "privacy-policy", "icon", "screenshots", "description", "age-rating",
  "iap-disclosure", "account-deletion", "permission-strings", "test-account",
];

export interface ReviewMaterial {
  readonly kind: MaterialKind;
  readonly present: boolean;
  readonly updatedAtMs: number;
  readonly note: string;
}

export interface ReviewPackage {
  readonly product: string;
  readonly platform: Platform;
  readonly version: string;
  readonly privacyPolicyVersion: string;
  readonly iapDisclosed: boolean;
  readonly minorProtection: boolean;
  readonly permissionPurposeComplete: boolean;
  readonly materials: readonly ReviewMaterial[];
}

export type ReviewIssueCode =
  | "missing-material" | "stale-asset" | "policy-mismatch"
  | "undisclosed-iap" | "minor-protection-missing" | "permission-purpose-missing";

export interface ReviewIssue {
  readonly code: ReviewIssueCode;
  readonly subject: string;
  readonly blocking: boolean;
  readonly detail: string;
}

export interface ReviewOptions {
  readonly nowMs: number;
  readonly maxAssetAgeMs: number;
}

export interface ReviewWindow {
  readonly minHours: number;
  readonly maxHours: number;
}

export interface ReviewReport {
  readonly product: string;
  readonly platform: Platform;
  readonly version: string;
  readonly ready: boolean;
  readonly blockingCount: number;
  readonly issues: readonly ReviewIssue[];
  readonly window: ReviewWindow | null;
}

export interface ReviewWindowEntry extends ReviewWindow {
  readonly product: string;
  readonly platform: Platform;
}

export const REVIEW_WINDOWS: readonly ReviewWindowEntry[] = [
  { product: "潮汐消消", platform: "ios", minHours: 24, maxHours: 24 },
  { product: "潮汐方舟", platform: "ios", minHours: 48, maxHours: 48 },
  { product: "潮汐消消", platform: "android-cn", minHours: 72, maxHours: 120 },
  { product: "潮汐方舟", platform: "android-cn", minHours: 72, maxHours: 120 },
];

export interface SubmissionBaseline {
  readonly product: string;
  readonly averageAttempts: number;
  readonly assetRefreshDays: number;
}

export const SUBMISSION_BASELINES: readonly SubmissionBaseline[] = [
  { product: "潮汐消消", averageAttempts: 1.8, assetRefreshDays: 14 },
  { product: "潮汐方舟", averageAttempts: 2.4, assetRefreshDays: 28 },
];

export function reviewWindow(product: string, platform: Platform): ReviewWindow | null {
  const entry = REVIEW_WINDOWS.find(
    (item) => item.product === product && item.platform === platform,
  );
  return entry === undefined ? null : { minHours: entry.minHours, maxHours: entry.maxHours };
}

export function resubmitBudget(averageAttempts: number): number {
  if (!Number.isFinite(averageAttempts) || averageAttempts < 1) {
    return 0;
  }
  return Math.round((averageAttempts - 1) * 100) / 100;
}

export function auditSubmission(pkg: ReviewPackage, options: ReviewOptions): ReviewReport {
  const issues: ReviewIssue[] = [];
  const byKind = new Map<MaterialKind, ReviewMaterial>();
  for (const material of pkg.materials) {
    byKind.set(material.kind, material);
  }

  for (const kind of REQUIRED_MATERIALS) {
    const material = byKind.get(kind);
    if (material === undefined || !material.present) {
      issues.push({
        code: "missing-material",
        subject: kind,
        blocking: true,
        detail: `${kind} is required but absent`,
      });
      continue;
    }
    const isAsset = kind === "screenshots" || kind === "icon" || kind === "description";
    if (isAsset && options.nowMs - material.updatedAtMs > options.maxAssetAgeMs) {
      const days = Math.round(options.maxAssetAgeMs / 86_400_000);
      issues.push({
        code: "stale-asset",
        subject: kind,
        blocking: false,
        detail: `${kind} is older than ${days} days`,
      });
    }
    if (kind === "privacy-policy" && material.note !== pkg.privacyPolicyVersion) {
      issues.push({
        code: "policy-mismatch",
        subject: kind,
        blocking: true,
        detail: `material ${material.note} != package ${pkg.privacyPolicyVersion}`,
      });
    }
  }

  if (!pkg.iapDisclosed) {
    issues.push({
      code: "undisclosed-iap",
      subject: "iap-disclosure",
      blocking: true,
      detail: "in-app purchases are not disclosed on the store page",
    });
  }
  if (!pkg.minorProtection) {
    issues.push({
      code: "minor-protection-missing",
      subject: "minor-protection",
      blocking: true,
      detail: "minor protection is not described in the submission",
    });
  }
  if (!pkg.permissionPurposeComplete) {
    issues.push({
      code: "permission-purpose-missing",
      subject: "permission-strings",
      blocking: true,
      detail: "one or more permission purpose strings are empty",
    });
  }

  const blockingCount = issues.filter((issue) => issue.blocking).length;
  return {
    product: pkg.product,
    platform: pkg.platform,
    version: pkg.version,
    ready: blockingCount === 0,
    blockingCount,
    issues,
    window: reviewWindow(pkg.product, pkg.platform),
  };
}

export type RejectionCode =
  | "missing-demo-account" | "privacy-mismatch" | "iap-undisclosed"
  | "metadata-misleading" | "permission-purpose" | "crash-on-launch" | "minor-protection";

export type Owner = "client" | "backend" | "ops" | "legal" | "marketing";

export interface RejectionGuide {
  readonly code: RejectionCode;
  readonly owner: Owner;
  readonly blocking: boolean;
  readonly firstAction: string;
}

const GUIDES: Readonly<Record<RejectionCode, RejectionGuide>> = {
  "missing-demo-account": { code: "missing-demo-account", owner: "ops", blocking: true,
    firstAction: "ship a demo account with a non-empty inventory and no payment step" },
  "privacy-mismatch": { code: "privacy-mismatch", owner: "legal", blocking: true,
    firstAction: "align the in-app policy, the store URL and the declared SDK list" },
  "iap-undisclosed": { code: "iap-undisclosed", owner: "marketing", blocking: true,
    firstAction: "disclose every paid tier and the currency on the store page" },
  "metadata-misleading": { code: "metadata-misleading", owner: "marketing", blocking: true,
    firstAction: "replace screenshots and copy that promise features the build does not have" },
  "permission-purpose": { code: "permission-purpose", owner: "client", blocking: true,
    firstAction: "write a player-facing purpose string for each sensitive permission" },
  "crash-on-launch": { code: "crash-on-launch", owner: "client", blocking: true,
    firstAction: "reproduce on a clean device with the submitted package, not a debug build" },
  "minor-protection": { code: "minor-protection", owner: "backend", blocking: true,
    firstAction: "expose real-name, play window and spend limit behavior in the review notes" },
};

export function classifyRejection(code: string): RejectionGuide | null {
  if (!Object.prototype.hasOwnProperty.call(GUIDES, code)) {
    return null;
  }
  return GUIDES[code as RejectionCode];
}

export function formatReviewReport(report: ReviewReport): string {
  const windowText =
    report.window === null ? "unknown" : `${report.window.minHours}-${report.window.maxHours}h`;
  const codes = [...new Set(report.issues.map((issue) => issue.code))].join(",") || "none";
  return `${report.product} ${report.version} ${report.platform} ${report.ready ? "ready" : "blocked"} blocking=${report.blockingCount} window=${windowText} codes=${codes}`;
}