@gpc-cli/core 0.9.73 → 0.9.75

package/dist/index.js

@@ -1247,8 +1247,8 @@ var ALL_IMAGE_TYPES = [
   "tvBanner"
 ];
 async function exportImages(client, packageName, dir, options) {
-  const { mkdir: mkdir8, writeFile: writeFile9 } = await import("fs/promises");
-  const { join: join12 } = await import("path");
+  const { mkdir: mkdir9, writeFile: writeFile10 } = await import("fs/promises");
+  const { join: join13 } = await import("path");
   const edit = await client.edits.insert(packageName);
   try {
     let languages;
@@ -1279,8 +1279,8 @@ async function exportImages(client, packageName, dir, options) {
       const batch = tasks.slice(i, i + concurrency);
       const results = await Promise.all(
         batch.map(async (task) => {
-          const dirPath = join12(dir, task.language, task.imageType);
-          await mkdir8(dirPath, { recursive: true });
+          const dirPath = join13(dir, task.language, task.imageType);
+          await mkdir9(dirPath, { recursive: true });
           const response = await fetch(task.url);
           if (!response.ok) {
             throw new GpcError(
@@ -1291,8 +1291,8 @@ async function exportImages(client, packageName, dir, options) {
             );
           }
           const buffer = Buffer.from(await response.arrayBuffer());
-          const filePath = join12(dirPath, `${task.index}.png`);
-          await writeFile9(filePath, buffer);
+          const filePath = join13(dirPath, `${task.index}.png`);
+          await writeFile10(filePath, buffer);
           return buffer.length;
         })
       );
@@ -1983,7 +1983,67 @@ function analyzeReviews(reviews) {
   };
 }
 
+// src/utils/sort.ts
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function compare(a, b) {
+  if (a === void 0 && b === void 0) return 0;
+  if (a === void 0) return 1;
+  if (b === void 0) return -1;
+  if (typeof a === "number" && typeof b === "number") {
+    return a - b;
+  }
+  return String(a).localeCompare(String(b));
+}
+function sortResults(items, sortSpec) {
+  if (!sortSpec || items.length === 0) {
+    return items;
+  }
+  const descending = sortSpec.startsWith("-");
+  const field = descending ? sortSpec.slice(1) : sortSpec;
+  const hasField = items.some((item) => getNestedValue(item, field) !== void 0);
+  if (!hasField) {
+    return items;
+  }
+  const sorted = [...items].sort((a, b) => {
+    const aVal = getNestedValue(a, field);
+    const bVal = getNestedValue(b, field);
+    const result = compare(aVal, bVal);
+    return descending ? -result : result;
+  });
+  return sorted;
+}
+
 // src/commands/reviews.ts
+var REVIEW_SORT_PRESETS = ["newest", "oldest", "rating"];
+function reviewTimestamp(r) {
+  const secs = Number(r.comments?.[0]?.userComment?.lastModified?.seconds);
+  return Number.isFinite(secs) ? secs : 0;
+}
+function reviewRating(r) {
+  return r.comments?.[0]?.userComment?.starRating ?? 0;
+}
+function sortReviews(reviews, spec) {
+  switch (spec) {
+    case "newest":
+      return [...reviews].sort((a, b) => reviewTimestamp(b) - reviewTimestamp(a));
+    case "oldest":
+      return [...reviews].sort((a, b) => reviewTimestamp(a) - reviewTimestamp(b));
+    case "rating":
+      return [...reviews].sort((a, b) => reviewRating(b) - reviewRating(a));
+    default:
+      return sortResults(reviews, spec);
+  }
+}
 async function listReviews(client, packageName, options) {
   let reviews;
   let nextPageToken;
@@ -2918,6 +2978,19 @@ async function getAppStatus(client, reporting, packageName, options = {}) {
   if (reviewsResult.status === "rejected")
     sectionErrors.push(`reviews: ${String(reviewsResult.reason)}`);
   const reviews = computeReviewSentiment(rawReviews, reviewDays);
+  if (options.full && sections.has("reviews")) {
+    const windowStartSec = (Date.now() - reviewDays * 24 * 60 * 60 * 1e3) / 1e3;
+    const items = rawReviews.filter((r) => {
+      const secs = Number(r.comments?.[0]?.userComment?.lastModified?.seconds);
+      return Number.isFinite(secs) && secs >= windowStartSec;
+    }).map((r) => {
+      const uc = r.comments?.[0]?.userComment;
+      return { text: uc?.text ?? "", rating: uc?.starRating };
+    }).filter((r) => r.text.length > 0);
+    if (items.length > 0) {
+      reviews.analysis = analyzeReviews(items);
+    }
+  }
   return {
     packageName,
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3040,10 +3113,31 @@ function formatStatusTable(status) {
       const trend = formatTrend(averageRating, previousAverageRating);
       const positiveStr = positivePercent !== void 0 ? `  ${positivePercent}% positive` : "";
       lines.push(`  ${formatRating(averageRating)}   ${totalNew} new${positiveStr}${trend}`);
+      lines.push(...formatReviewInsights(status.reviews.analysis));
     }
   }
   return lines.join("\n");
 }
+function formatReviewInsights(analysis) {
+  if (!analysis || analysis.totalReviews === 0) return [];
+  const total = analysis.totalReviews;
+  const pct = (n) => Math.round(n / total * 100);
+  const s = analysis.sentiment;
+  const lines = [
+    "",
+    "  REVIEW INSIGHTS",
+    `    text sentiment  ${pct(s.positive)}% positive  ${pct(s.negative)}% negative  ${pct(s.neutral)}% neutral`
+  ];
+  if (analysis.topics.length > 0) {
+    lines.push(
+      `    top topics      ${analysis.topics.slice(0, 5).map((t) => `${t.topic} (${t.count})`).join(", ")}`
+    );
+  }
+  if (analysis.keywords.length > 0) {
+    lines.push(`    keywords        ${analysis.keywords.slice(0, 8).map((k) => k.word).join(", ")}`);
+  }
+  return lines;
+}
 function formatStatusSummary(status) {
   const parts = [status.packageName];
   const latestRelease = status.releases.find((r) => r.status !== "draft") ?? status.releases[0];
@@ -4607,6 +4701,8 @@ async function executeStage(apiClient, packageName, state, stageIndex) {
 }
 
 // src/commands/games.ts
+import { mkdir as mkdir5, readdir as readdir4, readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
+import { extname as extname2, join as join6 } from "path";
 async function listLeaderboards(client, packageName) {
   const result = await client.leaderboards.list(packageName);
   return result.items ?? [];
@@ -4707,6 +4803,141 @@ async function diffLeaderboardConfig(client, leaderboardId, localData) {
   }
   return diffs;
 }
+var ICON_CONTENT_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg"
+};
+function iconContentType(filePath) {
+  const ext = extname2(filePath).toLowerCase();
+  const contentType = ICON_CONTENT_TYPES[ext];
+  if (!contentType) {
+    throw new GpcError(
+      `Unsupported icon format: ${ext || "(no extension)"}`,
+      "GAMES_INVALID_ICON_FORMAT",
+      2,
+      "Provide a .png, .jpg, or .jpeg image (Play Games icons are 512x512)."
+    );
+  }
+  return contentType;
+}
+async function setAchievementIcon(client, achievementId, filePath) {
+  validateResourceId(achievementId, "achievement");
+  return client.images.upload(achievementId, "ACHIEVEMENT_ICON", filePath, iconContentType(filePath));
+}
+async function setLeaderboardIcon(client, leaderboardId, filePath) {
+  validateResourceId(leaderboardId, "leaderboard");
+  return client.images.upload(leaderboardId, "LEADERBOARD_ICON", filePath, iconContentType(filePath));
+}
+function safeConfigFilename(id) {
+  return `${id.replace(/[^a-zA-Z0-9_-]/g, "_")}.json`;
+}
+async function readConfigDir(dir) {
+  const entries = (await readdir4(dir)).filter((f) => f.toLowerCase().endsWith(".json"));
+  const out = [];
+  for (const file of entries) {
+    const raw = await readFile8(join6(dir, file), "utf-8");
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      throw new GpcError(
+        `Invalid JSON in ${file}: ${err instanceof Error ? err.message : String(err)}`,
+        "GAMES_INVALID_CONFIG_JSON",
+        2,
+        "Each file in the sync directory must be a valid config JSON."
+      );
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new GpcError(
+        `${file} is not a config object.`,
+        "GAMES_INVALID_CONFIG_JSON",
+        2,
+        "Each file must contain a single achievement or leaderboard config object."
+      );
+    }
+    out.push({ file, config: parsed });
+  }
+  return out;
+}
+async function pushAchievementConfigs(client, applicationId, dir, options) {
+  validateApplicationId(applicationId);
+  const created = [];
+  const updated = [];
+  for (const { file, config } of await readConfigDir(dir)) {
+    if (config.id) {
+      if (!options?.dryRun) await client.achievements.update(config.id, config);
+      updated.push(config.id);
+    } else {
+      if (options?.dryRun) {
+        created.push(file);
+      } else {
+        const res = await client.achievements.insert(applicationId, config);
+        created.push(res.id ?? file);
+      }
+    }
+  }
+  return { created, updated };
+}
+async function pullAchievementConfigs(client, applicationId, dir) {
+  validateApplicationId(applicationId);
+  await mkdir5(dir, { recursive: true });
+  const written = [];
+  let pageToken;
+  do {
+    const result = await client.achievements.list(applicationId, { maxResults: 200, pageToken });
+    for (const config of result.items ?? []) {
+      const id = config.id ?? "unknown";
+      await writeFile5(
+        join6(dir, safeConfigFilename(id)),
+        JSON.stringify(config, null, 2) + "\n",
+        "utf-8"
+      );
+      written.push(id);
+    }
+    pageToken = result.nextPageToken;
+  } while (pageToken);
+  return written;
+}
+async function pushLeaderboardConfigs(client, applicationId, dir, options) {
+  validateApplicationId(applicationId);
+  const created = [];
+  const updated = [];
+  for (const { file, config } of await readConfigDir(dir)) {
+    if (config.id) {
+      if (!options?.dryRun) await client.leaderboards.update(config.id, config);
+      updated.push(config.id);
+    } else {
+      if (options?.dryRun) {
+        created.push(file);
+      } else {
+        const res = await client.leaderboards.insert(applicationId, config);
+        created.push(res.id ?? file);
+      }
+    }
+  }
+  return { created, updated };
+}
+async function pullLeaderboardConfigs(client, applicationId, dir) {
+  validateApplicationId(applicationId);
+  await mkdir5(dir, { recursive: true });
+  const written = [];
+  let pageToken;
+  do {
+    const result = await client.leaderboards.list(applicationId, { maxResults: 200, pageToken });
+    for (const config of result.items ?? []) {
+      const id = config.id ?? "unknown";
+      await writeFile5(
+        join6(dir, safeConfigFilename(id)),
+        JSON.stringify(config, null, 2) + "\n",
+        "utf-8"
+      );
+      written.push(id);
+    }
+    pageToken = result.nextPageToken;
+  } while (pageToken);
+  return written;
+}
 
 // src/commands/enterprise.ts
 async function createEnterpriseApp(client, params) {
@@ -4721,8 +4952,8 @@ async function publishEnterpriseApp(client, params) {
 }
 
 // src/audit.ts
-import { appendFile, chmod, mkdir as mkdir5, readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
-import { join as join6 } from "path";
+import { appendFile, chmod, mkdir as mkdir6, readFile as readFile9, writeFile as writeFile6 } from "fs/promises";
+import { join as join7 } from "path";
 var auditDir = null;
 function initAudit(configDir) {
   auditDir = configDir;
@@ -4730,8 +4961,8 @@ function initAudit(configDir) {
 async function writeAuditLog(entry) {
   if (!auditDir) return;
   try {
-    await mkdir5(auditDir, { recursive: true, mode: 448 });
-    const logPath = join6(auditDir, "audit.log");
+    await mkdir6(auditDir, { recursive: true, mode: 448 });
+    const logPath = join7(auditDir, "audit.log");
     const redactedEntry = redactAuditArgs(entry);
     const line = JSON.stringify(redactedEntry) + "\n";
     await appendFile(logPath, line, { encoding: "utf-8", mode: 384 });
@@ -4786,10 +5017,10 @@ function createAuditEntry(command, args, app) {
 }
 async function listAuditEvents(options) {
   if (!auditDir) return [];
-  const logPath = join6(auditDir, "audit.log");
+  const logPath = join7(auditDir, "audit.log");
   let content;
   try {
-    content = await readFile8(logPath, "utf-8");
+    content = await readFile9(logPath, "utf-8");
   } catch {
     return [];
   }
@@ -4824,10 +5055,10 @@ async function searchAuditEvents(query) {
 }
 async function clearAuditLog(options) {
   if (!auditDir) return { deleted: 0, remaining: 0 };
-  const logPath = join6(auditDir, "audit.log");
+  const logPath = join7(auditDir, "audit.log");
   let content;
   try {
-    content = await readFile8(logPath, "utf-8");
+    content = await readFile9(logPath, "utf-8");
   } catch {
     return { deleted: 0, remaining: 0 };
   }
@@ -4835,7 +5066,7 @@ async function clearAuditLog(options) {
   if (!options?.before) {
     const count = lines.length;
     if (!options?.dryRun) {
-      await writeFile5(logPath, "", { encoding: "utf-8", mode: 384 });
+      await writeFile6(logPath, "", { encoding: "utf-8", mode: 384 });
     }
     return { deleted: count, remaining: 0 };
   }
@@ -4855,7 +5086,7 @@ async function clearAuditLog(options) {
     }
   }
   if (!options?.dryRun) {
-    await writeFile5(logPath, keep.length > 0 ? keep.join("\n") + "\n" : "", {
+    await writeFile6(logPath, keep.length > 0 ? keep.join("\n") + "\n" : "", {
       encoding: "utf-8",
       mode: 384
     });
@@ -4915,8 +5146,8 @@ function safePathWithin(userPath, baseDir) {
 }
 
 // src/commands/init.ts
-import { mkdir as mkdir6, writeFile as writeFile6, stat as stat5 } from "fs/promises";
-import { join as join7 } from "path";
+import { mkdir as mkdir7, writeFile as writeFile7, stat as stat5 } from "fs/promises";
+import { join as join8 } from "path";
 async function exists2(path) {
   try {
     await stat5(path);
@@ -4933,8 +5164,8 @@ async function safeWrite(filePath, content, created, skipped, skipExisting) {
     }
   }
   const dir = filePath.substring(0, filePath.lastIndexOf("/"));
-  await mkdir6(dir, { recursive: true });
-  await writeFile6(filePath, content, "utf-8");
+  await mkdir7(dir, { recursive: true });
+  await writeFile7(filePath, content, "utf-8");
   created.push(filePath);
 }
 async function initProject(options) {
@@ -4951,7 +5182,7 @@ async function initProject(options) {
     null,
     2
   );
-  await safeWrite(join7(dir, ".gpcrc.json"), gpcrc + "\n", created, skipped, skipExisting);
+  await safeWrite(join8(dir, ".gpcrc.json"), gpcrc + "\n", created, skipped, skipExisting);
   const preflightrc = JSON.stringify(
     {
       failOn: "error",
@@ -4965,27 +5196,27 @@ async function initProject(options) {
     2
   );
   await safeWrite(
-    join7(dir, ".preflightrc.json"),
+    join8(dir, ".preflightrc.json"),
     preflightrc + "\n",
     created,
     skipped,
     skipExisting
   );
-  const metaDir = join7(dir, "metadata", "android", "en-US");
-  await safeWrite(join7(metaDir, "title.txt"), "", created, skipped, skipExisting);
-  await safeWrite(join7(metaDir, "short_description.txt"), "", created, skipped, skipExisting);
-  await safeWrite(join7(metaDir, "full_description.txt"), "", created, skipped, skipExisting);
-  await safeWrite(join7(metaDir, "video.txt"), "", created, skipped, skipExisting);
-  const ssDir = join7(metaDir, "images", "phoneScreenshots");
-  await mkdir6(ssDir, { recursive: true });
-  await safeWrite(join7(ssDir, ".gitkeep"), "", created, skipped, skipExisting);
+  const metaDir = join8(dir, "metadata", "android", "en-US");
+  await safeWrite(join8(metaDir, "title.txt"), "", created, skipped, skipExisting);
+  await safeWrite(join8(metaDir, "short_description.txt"), "", created, skipped, skipExisting);
+  await safeWrite(join8(metaDir, "full_description.txt"), "", created, skipped, skipExisting);
+  await safeWrite(join8(metaDir, "video.txt"), "", created, skipped, skipExisting);
+  const ssDir = join8(metaDir, "images", "phoneScreenshots");
+  await mkdir7(ssDir, { recursive: true });
+  await safeWrite(join8(ssDir, ".gitkeep"), "", created, skipped, skipExisting);
   if (ci === "github") {
     const workflow = githubActionsTemplate(pkg);
-    const workflowDir = join7(dir, ".github", "workflows");
-    await safeWrite(join7(workflowDir, "gpc-release.yml"), workflow, created, skipped, skipExisting);
+    const workflowDir = join8(dir, ".github", "workflows");
+    await safeWrite(join8(workflowDir, "gpc-release.yml"), workflow, created, skipped, skipExisting);
   } else if (ci === "gitlab") {
     const pipeline = gitlabCiTemplate(pkg);
-    await safeWrite(join7(dir, ".gitlab-ci-gpc.yml"), pipeline, created, skipped, skipExisting);
+    await safeWrite(join8(dir, ".gitlab-ci-gpc.yml"), pipeline, created, skipped, skipExisting);
   }
   return { created, skipped };
 }
@@ -5081,13 +5312,13 @@ var DEFAULT_PREFLIGHT_CONFIG = {
 };
 
 // src/preflight/config.ts
-import { readFile as readFile9 } from "fs/promises";
+import { readFile as readFile10 } from "fs/promises";
 var VALID_SEVERITIES = /* @__PURE__ */ new Set(["critical", "error", "warning", "info"]);
 async function loadPreflightConfig(configPath) {
   const path = configPath || ".preflightrc.json";
   let raw;
   try {
-    raw = await readFile9(path, "utf-8");
+    raw = await readFile10(path, "utf-8");
   } catch {
     return { ...DEFAULT_PREFLIGHT_CONFIG };
   }
@@ -5132,7 +5363,8 @@ async function loadPreflightConfig(configPath) {
 }
 
 // src/preflight/aab-reader.ts
-import { open as yauzlOpen } from "yauzl";
+import { readFile as readFile11 } from "fs/promises";
+import { fromBuffer } from "yauzl";
 
 // src/preflight/manifest-parser.ts
 import protobuf from "protobufjs";
@@ -5321,12 +5553,20 @@ var AAB_MANIFEST_PATH = "base/manifest/AndroidManifest.xml";
 var APK_MANIFEST_PATH = "AndroidManifest.xml";
 var SO_HEADER_BYTES = 4096;
 var SO_PATH_RE = /(?:^|\/)lib\/[^/]+\/[^/]+\.so$/;
+var SCAN_TIMEOUT_MS = 6e4;
 function detectManifestPath(filePath) {
   return filePath.toLowerCase().endsWith(".apk") ? APK_MANIFEST_PATH : AAB_MANIFEST_PATH;
 }
 async function readAab(aabPath) {
   const manifestPath = detectManifestPath(aabPath);
-  const { zipfile, entries, manifestBuf, soHeaders } = await openAndScan(aabPath, manifestPath);
+  let buffer;
+  try {
+    buffer = await readFile11(aabPath);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Could not read ${aabPath}: ${msg}`, { cause: err });
+  }
+  const { zipfile, entries, manifestBuf, soHeaders } = await openAndScan(buffer, manifestPath);
   zipfile.close();
   if (!manifestBuf) {
     const fileType = aabPath.toLowerCase().endsWith(".apk") ? "APK" : "AAB";
@@ -5363,98 +5603,125 @@ function createFallbackManifest() {
     providers: []
   };
 }
-function openAndScan(aabPath, manifestPath = AAB_MANIFEST_PATH) {
+function openAndScan(buffer, manifestPath = AAB_MANIFEST_PATH) {
   return new Promise((resolve2, reject) => {
-    yauzlOpen(aabPath, { lazyEntries: true, autoClose: false }, (err, zipfile) => {
-      if (err || !zipfile) {
-        reject(err ?? new Error("Failed to open AAB file"));
-        return;
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        reject(new Error("Timed out reading the archive. The file may be corrupt or truncated."));
       }
-      const entries = [];
-      const soHeaders = /* @__PURE__ */ new Map();
-      let manifestBuf = null;
-      let rejected = false;
-      let pendingStreams = 0;
-      let entrysDone = false;
-      function fail(error) {
-        if (!rejected) {
-          rejected = true;
-          zipfile.close();
-          reject(error);
+    }, SCAN_TIMEOUT_MS);
+    function settleResolve(value) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve2(value);
+    }
+    function settleReject(error) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(error);
+    }
+    try {
+      fromBuffer(buffer, { lazyEntries: true }, (err, zipfile) => {
+        if (err || !zipfile) {
+          settleReject(err ?? new Error("Failed to open AAB file"));
+          return;
         }
-      }
-      function maybeResolve() {
-        if (!rejected && entrysDone && pendingStreams === 0) {
-          resolve2({ zipfile, entries, manifestBuf, soHeaders });
+        const entries = [];
+        const soHeaders = /* @__PURE__ */ new Map();
+        let manifestBuf = null;
+        let pendingStreams = 0;
+        let entrysDone = false;
+        function fail(error) {
+          if (settled) return;
+          try {
+            zipfile.close();
+          } catch {
+          }
+          settleReject(error);
         }
-      }
-      function readEntryStream(entry, onData, maxBytes) {
-        pendingStreams++;
-        zipfile.openReadStream(entry, (streamErr, stream) => {
-          if (streamErr || !stream) {
-            fail(streamErr ?? new Error(`Failed to read ${entry.fileName}`));
-            return;
+        function maybeResolve() {
+          if (!settled && entrysDone && pendingStreams === 0) {
+            settleResolve({ zipfile, entries, manifestBuf, soHeaders });
           }
-          const chunks = [];
-          let totalBytes = 0;
-          let done = false;
-          stream.on("data", (chunk) => {
-            chunks.push(chunk);
-            totalBytes += chunk.length;
-            if (maxBytes && totalBytes >= maxBytes) {
-              stream.destroy();
-            }
-          });
-          stream.on("error", (e) => {
-            if (maxBytes && totalBytes >= maxBytes) return;
-            fail(e);
-          });
-          const finish = () => {
-            if (done) return;
-            done = true;
-            const buf = Buffer.concat(chunks);
-            onData(maxBytes ? buf.subarray(0, maxBytes) : buf);
-            pendingStreams--;
-            maybeResolve();
-          };
-          stream.on("end", finish);
-          stream.on("close", () => {
-            if (totalBytes > 0 && maxBytes) finish();
-          });
-        });
-      }
-      zipfile.on("error", fail);
-      zipfile.on("entry", (entry) => {
-        if (rejected) return;
-        const path = entry.fileName;
-        if (!path.endsWith("/")) {
-          entries.push({
-            path,
-            compressedSize: entry.compressedSize,
-            uncompressedSize: entry.uncompressedSize
-          });
         }
-        if (path === manifestPath) {
-          readEntryStream(entry, (buf) => {
-            manifestBuf = buf;
+        function readEntryStream(entry, onData, maxBytes) {
+          pendingStreams++;
+          zipfile.openReadStream(entry, (streamErr, stream) => {
+            if (streamErr || !stream) {
+              fail(streamErr ?? new Error(`Failed to read ${entry.fileName}`));
+              return;
+            }
+            const chunks = [];
+            let totalBytes = 0;
+            let done = false;
+            stream.on("data", (chunk) => {
+              chunks.push(chunk);
+              totalBytes += chunk.length;
+              if (maxBytes && totalBytes >= maxBytes) {
+                stream.destroy();
+              }
+            });
+            stream.on("error", (e) => {
+              if (maxBytes && totalBytes >= maxBytes) return;
+              fail(e);
+            });
+            const finish = () => {
+              if (done) return;
+              done = true;
+              const buf = Buffer.concat(chunks);
+              onData(maxBytes ? buf.subarray(0, maxBytes) : buf);
+              pendingStreams--;
+              maybeResolve();
+            };
+            stream.on("end", finish);
+            stream.on("close", () => {
+              if (totalBytes > 0 && maxBytes) finish();
+            });
           });
-        } else if (SO_PATH_RE.test(path)) {
-          readEntryStream(
-            entry,
-            (buf) => {
-              soHeaders.set(path, buf);
-            },
-            SO_HEADER_BYTES
-          );
         }
+        zipfile.on("error", fail);
+        zipfile.on("entry", (entry) => {
+          if (settled) return;
+          try {
+            const path = entry.fileName;
+            if (!path.endsWith("/")) {
+              entries.push({
+                path,
+                compressedSize: entry.compressedSize,
+                uncompressedSize: entry.uncompressedSize
+              });
+            }
+            if (path === manifestPath) {
+              readEntryStream(entry, (buf) => {
+                manifestBuf = buf;
+              });
+            } else if (SO_PATH_RE.test(path)) {
+              readEntryStream(
+                entry,
+                (buf) => {
+                  soHeaders.set(path, buf);
+                },
+                SO_HEADER_BYTES
+              );
+            }
+            zipfile.readEntry();
+          } catch (e) {
+            fail(e instanceof Error ? e : new Error(String(e)));
+          }
+        });
+        zipfile.on("end", () => {
+          entrysDone = true;
+          maybeResolve();
+        });
         zipfile.readEntry();
       });
-      zipfile.on("end", () => {
-        entrysDone = true;
-        maybeResolve();
-      });
-      zipfile.readEntry();
-    });
+    } catch (err) {
+      settleReject(err instanceof Error ? err : new Error(String(err)));
+    }
   });
 }
 
@@ -6018,8 +6285,8 @@ ${fileList}` + (hasPageSizeCompat ? "\nandroid:pageSizeCompat is set, so the app
 }
 
 // src/preflight/scanners/metadata-scanner.ts
-import { readdir as readdir4, stat as stat6, readFile as readFile10 } from "fs/promises";
-import { join as join8 } from "path";
+import { readdir as readdir5, stat as stat6, readFile as readFile12 } from "fs/promises";
+import { join as join9 } from "path";
 var SAFE_LANG = /^[a-zA-Z]{2,3}(-[a-zA-Z0-9]{2,8})*$/;
 var FILE_MAP2 = {
   "title.txt": "title",
@@ -6045,7 +6312,7 @@ var metadataScanner = {
     const findings = [];
     let entries;
     try {
-      entries = await readdir4(dir);
+      entries = await readdir5(dir);
     } catch {
       findings.push({
         scanner: "metadata",
@@ -6070,14 +6337,14 @@ var metadataScanner = {
       return findings;
     }
     for (const lang of locales) {
-      const langDir = join8(dir, lang);
+      const langDir = join9(dir, lang);
       const langStat = await stat6(langDir).catch(() => null);
       if (!langStat?.isDirectory()) continue;
       const fields = {};
       for (const [fileName, field] of Object.entries(FILE_MAP2)) {
-        const filePath = join8(langDir, fileName);
+        const filePath = join9(langDir, fileName);
         try {
-          const content = await readFile10(filePath, "utf-8");
+          const content = await readFile12(filePath, "utf-8");
           fields[field] = content.trimEnd();
         } catch {
         }
@@ -6116,9 +6383,9 @@ var metadataScanner = {
       let totalScreenshots = 0;
       let phoneScreenshots = 0;
       for (const ssDir of SCREENSHOT_DIRS) {
-        const ssPath = join8(langDir, "images", ssDir);
+        const ssPath = join9(langDir, "images", ssDir);
         try {
-          const ssEntries = await readdir4(ssPath);
+          const ssEntries = await readdir5(ssPath);
           const imageFiles = ssEntries.filter((f) => /\.(png|jpe?g|webp)$/i.test(f));
           totalScreenshots += imageFiles.length;
           if (ssDir === "phoneScreenshots") {
@@ -6148,9 +6415,9 @@ var metadataScanner = {
       }
     }
     const defaultLang = locales.includes("en-US") ? "en-US" : locales[0];
-    const privacyPath = join8(dir, defaultLang, "privacy_policy_url.txt");
+    const privacyPath = join9(dir, defaultLang, "privacy_policy_url.txt");
     try {
-      const url = await readFile10(privacyPath, "utf-8");
+      const url = await readFile12(privacyPath, "utf-8");
       if (!url.trim()) throw new Error("empty");
     } catch {
       findings.push({
@@ -6175,11 +6442,11 @@ var metadataScanner = {
 };
 
 // src/preflight/scanners/secrets-scanner.ts
-import { readFile as readFile11 } from "fs/promises";
+import { readFile as readFile13 } from "fs/promises";
 
 // src/preflight/scan-files.ts
-import { readdir as readdir5, stat as stat7 } from "fs/promises";
-import { join as join9, extname as extname2 } from "path";
+import { readdir as readdir6, stat as stat7 } from "fs/promises";
+import { join as join10, extname as extname3 } from "path";
 var DEFAULT_SKIP_DIRS = /* @__PURE__ */ new Set([
   ".git",
   "node_modules",
@@ -6196,20 +6463,20 @@ async function collectSourceFiles(dir, extensions, skipDirs = DEFAULT_SKIP_DIRS,
   const files = [];
   let entries;
   try {
-    entries = await readdir5(dir);
+    entries = await readdir6(dir);
   } catch {
     return files;
   }
   for (const entry of entries) {
     if (skipDirs.has(entry)) continue;
-    const fullPath = join9(dir, entry);
+    const fullPath = join10(dir, entry);
     const s = await stat7(fullPath).catch(() => null);
     if (!s) continue;
     if (s.isDirectory()) {
       const sub = await collectSourceFiles(fullPath, extensions, skipDirs, maxDepth - 1);
       files.push(...sub);
     } else if (s.isFile()) {
-      const ext = extname2(entry).toLowerCase();
+      const ext = extname3(entry).toLowerCase();
       if (extensions.has(ext) || entry.endsWith(".gradle.kts")) {
         files.push(fullPath);
       }
@@ -6295,7 +6562,7 @@ var secretsScanner = {
     for (const filePath of files) {
       let content;
       try {
-        content = await readFile11(filePath, "utf-8");
+        content = await readFile13(filePath, "utf-8");
       } catch {
         continue;
       }
@@ -6323,7 +6590,7 @@ var secretsScanner = {
 };
 
 // src/preflight/scanners/billing-scanner.ts
-import { readFile as readFile12 } from "fs/promises";
+import { readFile as readFile14 } from "fs/promises";
 var BILLING_PATTERNS = [
   {
     ruleId: "billing-stripe-sdk",
@@ -6384,7 +6651,7 @@ var billingScanner = {
     for (const filePath of files) {
       let content;
       try {
-        content = await readFile12(filePath, "utf-8");
+        content = await readFile14(filePath, "utf-8");
       } catch {
         continue;
       }
@@ -6410,7 +6677,7 @@ var billingScanner = {
 };
 
 // src/preflight/scanners/privacy-scanner.ts
-import { readFile as readFile13 } from "fs/promises";
+import { readFile as readFile15 } from "fs/promises";
 var TRACKING_SDKS = [
   {
     name: "Facebook SDK",
@@ -6450,7 +6717,7 @@ var privacyScanner = {
     for (const filePath of files) {
       let content;
       try {
-        content = await readFile13(filePath, "utf-8");
+        content = await readFile15(filePath, "utf-8");
       } catch {
         continue;
       }
@@ -6591,6 +6858,15 @@ var policyScanner = {
         policyUrl: "https://support.google.com/googleplay/android-developer/answer/9876937"
       });
     }
+    findings.push({
+      scanner: "policy",
+      ruleId: "policy-developer-verification",
+      severity: "info",
+      title: "Developer verification enforcement (Sep 30, 2026)",
+      message: "Google begins enforcing developer verification on September 30, 2026, first in Brazil, Indonesia, Singapore, and Thailand. Apps distributed in those markets need a verified developer identity and a registered package name. Apps using Play App Signing are auto-registered.",
+      suggestion: "Run `gpc verify checklist` to review readiness. This is a distribution-market reminder, not an AAB/APK defect.",
+      policyUrl: "https://developer.android.com/developer-verification"
+    });
     if (perms.has("android.permission.SYSTEM_ALERT_WINDOW")) {
       findings.push({
         scanner: "policy",
@@ -6801,57 +7077,17 @@ async function runPreflight(options) {
   };
 }
 
-// src/utils/sort.ts
-function getNestedValue(obj, path) {
-  const parts = path.split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current === null || current === void 0 || typeof current !== "object") {
-      return void 0;
-    }
-    current = current[part];
-  }
-  return current;
-}
-function compare(a, b) {
-  if (a === void 0 && b === void 0) return 0;
-  if (a === void 0) return 1;
-  if (b === void 0) return -1;
-  if (typeof a === "number" && typeof b === "number") {
-    return a - b;
-  }
-  return String(a).localeCompare(String(b));
-}
-function sortResults(items, sortSpec) {
-  if (!sortSpec || items.length === 0) {
-    return items;
-  }
-  const descending = sortSpec.startsWith("-");
-  const field = descending ? sortSpec.slice(1) : sortSpec;
-  const hasField = items.some((item) => getNestedValue(item, field) !== void 0);
-  if (!hasField) {
-    return items;
-  }
-  const sorted = [...items].sort((a, b) => {
-    const aVal = getNestedValue(a, field);
-    const bVal = getNestedValue(b, field);
-    const result = compare(aVal, bVal);
-    return descending ? -result : result;
-  });
-  return sorted;
-}
-
 // src/commands/plugin-scaffold.ts
-import { mkdir as mkdir7, writeFile as writeFile7 } from "fs/promises";
-import { join as join10 } from "path";
+import { mkdir as mkdir8, writeFile as writeFile8 } from "fs/promises";
+import { join as join11 } from "path";
 async function scaffoldPlugin(options) {
   const { name, dir, description = `GPC plugin: ${name}` } = options;
   const pluginName = name.startsWith("gpc-plugin-") ? name : `gpc-plugin-${name}`;
   const shortName = pluginName.replace(/^gpc-plugin-/, "");
-  const srcDir = join10(dir, "src");
-  const testDir = join10(dir, "tests");
-  await mkdir7(srcDir, { recursive: true });
-  await mkdir7(testDir, { recursive: true });
+  const srcDir = join11(dir, "src");
+  const testDir = join11(dir, "tests");
+  await mkdir8(srcDir, { recursive: true });
+  await mkdir8(testDir, { recursive: true });
   const files = [];
   const pkg = {
     name: pluginName,
@@ -6885,7 +7121,7 @@ async function scaffoldPlugin(options) {
       vitest: "^3.0.0"
     }
   };
-  await writeFile7(join10(dir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
+  await writeFile8(join11(dir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
   files.push("package.json");
   const tsconfig = {
     compilerOptions: {
@@ -6901,7 +7137,7 @@ async function scaffoldPlugin(options) {
     },
     include: ["src"]
   };
-  await writeFile7(join10(dir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n");
+  await writeFile8(join11(dir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n");
   files.push("tsconfig.json");
   const srcContent = `import { definePlugin } from "@gpc-cli/plugin-sdk";
 import type { CommandEvent, CommandResult } from "@gpc-cli/plugin-sdk";
@@ -6934,7 +7170,7 @@ export const plugin = definePlugin({
   },
 });
 `;
-  await writeFile7(join10(srcDir, "index.ts"), srcContent);
+  await writeFile8(join11(srcDir, "index.ts"), srcContent);
   files.push("src/index.ts");
   const testContent = `import { describe, it, expect, vi } from "vitest";
 import { plugin } from "../src/index";
@@ -6959,7 +7195,7 @@ describe("${pluginName}", () => {
   });
 });
 `;
-  await writeFile7(join10(testDir, "plugin.test.ts"), testContent);
+  await writeFile8(join11(testDir, "plugin.test.ts"), testContent);
   files.push("tests/plugin.test.ts");
   return { dir, files };
 }
@@ -7075,7 +7311,7 @@ async function sendWebhook(config, payload, target) {
 }
 
 // src/commands/internal-sharing.ts
-import { extname as extname3 } from "path";
+import { extname as extname4 } from "path";
 async function uploadInternalSharing(client, packageName, filePath, fileType) {
   const resolvedType = fileType ?? detectFileType(filePath);
   const validation = await validateUploadFile(filePath);
@@ -7102,7 +7338,7 @@ ${validation.errors.join("\n")}`,
   };
 }
 function detectFileType(filePath) {
-  const ext = extname3(filePath).toLowerCase();
+  const ext = extname4(filePath).toLowerCase();
   if (ext === ".aab") return "bundle";
   if (ext === ".apk") return "apk";
   throw new GpcError(
@@ -7114,7 +7350,7 @@ function detectFileType(filePath) {
 }
 
 // src/commands/generated-apks.ts
-import { writeFile as writeFile8 } from "fs/promises";
+import { writeFile as writeFile9 } from "fs/promises";
 async function listGeneratedApks(client, packageName, versionCode) {
   if (!Number.isInteger(versionCode) || versionCode <= 0) {
     throw new GpcError(
@@ -7145,12 +7381,12 @@ async function downloadGeneratedApk(client, packageName, versionCode, apkId, out
   }
   const buffer = await client.generatedApks.download(packageName, versionCode, apkId);
   const bytes = new Uint8Array(buffer);
-  await writeFile8(outputPath, bytes);
+  await writeFile9(outputPath, bytes);
   return { path: outputPath, sizeBytes: bytes.byteLength };
 }
 
 // src/commands/bundle-analysis.ts
-import { readFile as readFile14, stat as stat8 } from "fs/promises";
+import { readFile as readFile16, stat as stat8 } from "fs/promises";
 var EOCD_SIGNATURE = 101010256;
 var CD_SIGNATURE = 33639248;
 var MODULE_SUBDIRS = /* @__PURE__ */ new Set(["dex", "manifest", "res", "assets", "lib", "resources.pb", "root"]);
@@ -7230,7 +7466,7 @@ async function analyzeBundle(filePath) {
   if (!fileInfo || !fileInfo.isFile()) {
     throw new Error(`File not found: ${filePath}`);
   }
-  const buf = await readFile14(filePath);
+  const buf = await readFile16(filePath);
   const cdEntries = parseCentralDirectory(buf);
   const fileType = detectFileType2(filePath);
   const isAab = fileType === "aab";
@@ -7316,7 +7552,7 @@ function topFiles(analysis, n = 20) {
 async function checkBundleSize(analysis, configPath = ".bundlesize.json") {
   let config;
   try {
-    const raw = await readFile14(configPath, "utf-8");
+    const raw = await readFile16(configPath, "utf-8");
     config = JSON.parse(raw);
   } catch {
     return { passed: true, violations: [] };
@@ -8677,8 +8913,8 @@ async function sha256File(filePath) {
 }
 
 // src/commands/image-sync.ts
-import { readdir as readdir6 } from "fs/promises";
-import { join as join11, extname as extname4 } from "path";
+import { readdir as readdir7 } from "fs/promises";
+import { join as join12, extname as extname5 } from "path";
 import { PlayApiError } from "@gpc-cli/api";
 var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg"]);
 var ALL_IMAGE_TYPES2 = [
@@ -8693,15 +8929,15 @@ var ALL_IMAGE_TYPES2 = [
 ];
 async function scanLocalImages(dir) {
   try {
-    const entries = await readdir6(dir, { withFileTypes: true });
-    return entries.filter((e) => e.isFile() && IMAGE_EXTENSIONS.has(extname4(e.name).toLowerCase())).map((e) => e.name).sort();
+    const entries = await readdir7(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && IMAGE_EXTENSIONS.has(extname5(e.name).toLowerCase())).map((e) => e.name).sort();
   } catch {
     return [];
   }
 }
 async function scanLanguages(dir) {
   try {
-    const entries = await readdir6(dir, { withFileTypes: true });
+    const entries = await readdir7(dir, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
   } catch {
     return [];
@@ -8726,7 +8962,7 @@ async function syncImages(client, packageName, dir, options) {
   try {
     for (const language of languages) {
       for (const imageType of imageTypes) {
-        const localDir = join11(dir, language, imageType);
+        const localDir = join12(dir, language, imageType);
         const localFiles = await scanLocalImages(localDir);
         let remoteImages;
         try {
@@ -8741,7 +8977,7 @@ async function syncImages(client, packageName, dir, options) {
         const remoteSha256Set = new Set(remoteImages.map((img) => img.sha256.toLowerCase()));
         const localHashes = /* @__PURE__ */ new Map();
         for (const file of localFiles) {
-          const hash = await sha256File(join11(localDir, file));
+          const hash = await sha256File(join12(localDir, file));
           localHashes.set(file, hash);
         }
         const localSha256Set = new Set(localHashes.values());
@@ -8769,7 +9005,7 @@ async function syncImages(client, packageName, dir, options) {
             details.push({ language, imageType, file, action: "skip", reason: "sha256 match" });
           } else {
             if (!options?.dryRun) {
-              const filePath = join11(localDir, file);
+              const filePath = join12(localDir, file);
               const check = await validateImage(filePath, imageType);
               if (!check.valid) {
                 throw new GpcError(
@@ -8928,6 +9164,15 @@ function buildChecklist(input) {
       answers
     )
   );
+  items.push(
+    resolveManualStep(
+      "enforcement-markets",
+      "Verification enforcement timeline reviewed",
+      "Enforcement begins September 30, 2026, first in Brazil, Indonesia, Singapore, and Thailand. Apps distributed there need a verified developer identity and a registered package name. Apps using Play App Signing are auto-registered.",
+      VERIFICATION_PAGE,
+      answers
+    )
+  );
   items.push(
     resolveManualStep(
       "auto-registration-reviewed",
@@ -9004,6 +9249,77 @@ function renderChecklistMarkdown(result, accountEmail) {
   lines.push("");
   return lines.join("\n");
 }
+
+// src/commands/readiness.ts
+var STATUS_FRACTION = {
+  pass: 1,
+  warn: 0.5,
+  fail: 0
+};
+function gradeFromPercent(percent) {
+  if (percent >= 90) return "A";
+  if (percent >= 80) return "B";
+  if (percent >= 70) return "C";
+  if (percent >= 60) return "D";
+  return "F";
+}
+function scoreReadiness(signals) {
+  let earned = 0;
+  let possible = 0;
+  const breakdown = [];
+  const suggestions = [];
+  for (const signal of signals) {
+    if (signal.status === "na") {
+      breakdown.push({
+        key: signal.key,
+        label: signal.label,
+        weight: signal.weight,
+        status: "na",
+        points: 0,
+        detail: signal.detail
+      });
+      continue;
+    }
+    const points = signal.weight * STATUS_FRACTION[signal.status];
+    earned += points;
+    possible += signal.weight;
+    breakdown.push({
+      key: signal.key,
+      label: signal.label,
+      weight: signal.weight,
+      status: signal.status,
+      points,
+      detail: signal.detail
+    });
+    if (signal.status !== "pass" && signal.suggestion) {
+      suggestions.push(signal.suggestion);
+    }
+  }
+  const evaluated = possible > 0;
+  const percent = evaluated ? Math.round(earned / possible * 100) : 0;
+  const grade = evaluated ? gradeFromPercent(percent) : "F";
+  return { grade, percent, evaluated, earned, possible, breakdown, suggestions };
+}
+var GRADE_COLOR = {
+  A: "brightgreen",
+  B: "green",
+  C: "yellow",
+  D: "orange",
+  F: "red"
+};
+function readinessBadgeColor(grade) {
+  return GRADE_COLOR[grade];
+}
+function readinessBadgeUrl(score) {
+  const label = "GPC readiness";
+  const message = score.evaluated ? `${score.grade} (${score.percent}%)` : "not evaluated";
+  const color = score.evaluated ? readinessBadgeColor(score.grade) : "lightgrey";
+  const enc = (segment) => encodeURIComponent(segment.replace(/-/g, "--").replace(/_/g, "__"));
+  return `https://img.shields.io/badge/${enc(label)}-${enc(message)}-${color}`;
+}
+function readinessBadgeMarkdown(score) {
+  return `![GPC readiness](${readinessBadgeUrl(score)})`;
+}
 export {
   ApiError,
   ConfigError,
@@ -9020,6 +9336,7 @@ export {
   PROVIDER_WHITELIST,
   PluginManager,
   RENDERERS,
+  REVIEW_SORT_PRESETS,
   SECTION_ORDER,
   SENSITIVE_ARG_KEYS,
   SENSITIVE_KEYS,
@@ -9166,6 +9483,7 @@ export {
   getVitalsOverview,
   getVitalsRendering,
   getVitalsStartup,
+  gradeFromPercent,
   handleBreach,
   importDataSafety,
   importTestersFromCsv,
@@ -9220,11 +9538,18 @@ export {
   promoteRelease,
   publish,
   publishEnterpriseApp,
+  pullAchievementConfigs,
+  pullLeaderboardConfigs,
   pullListings,
+  pushAchievementConfigs,
+  pushLeaderboardConfigs,
   pushListings,
   readListingsFromDir,
   readReleaseNotesForVersion,
   readReleaseNotesFromDir,
+  readinessBadgeColor,
+  readinessBadgeMarkdown,
+  readinessBadgeUrl,
   redactAuditArgs,
   redactSensitive,
   refundExternalTransaction,
@@ -9252,12 +9577,16 @@ export {
   safePathWithin,
   saveStatusCache,
   scaffoldPlugin,
+  scoreReadiness,
   searchAuditEvents,
   searchVitalsErrors,
   sendNotification,
   sendWebhook,
+  setAchievementIcon,
+  setLeaderboardIcon,
   sha256File,
   sortResults,
+  sortReviews,
   startTrain,
   statusHasBreach,
   syncImages,