@gpc-cli/core 0.9.28 → 0.9.29

package/dist/index.js

@@ -40,6 +40,21 @@ var NetworkError = class extends GpcError {
 
 // src/output.ts
 import process2 from "process";
+function isColorEnabled() {
+  if (process2.env["NO_COLOR"] !== void 0 && process2.env["NO_COLOR"] !== "") return false;
+  const fc = process2.env["FORCE_COLOR"];
+  if (fc === "1" || fc === "2" || fc === "3") return true;
+  return process2.stdout.isTTY ?? false;
+}
+function ansi(code, s) {
+  return isColorEnabled() ? `\x1B[${code}m${s}\x1B[0m` : s;
+}
+function bold(s) {
+  return ansi(1, s);
+}
+function dim(s) {
+  return ansi(2, s);
+}
 function detectOutputFormat() {
   return process2.stdout.isTTY ? "table" : "json";
 }
@@ -150,10 +165,20 @@ ${formatYaml(value, indent + 1)}`;
   }
   return String(data);
 }
-var MAX_CELL_WIDTH = 60;
-function truncateCell(value) {
-  if (value.length <= MAX_CELL_WIDTH) return value;
-  return value.slice(0, MAX_CELL_WIDTH - 3) + "...";
+var DEFAULT_CELL_WIDTH = 60;
+function computeMaxCellWidth(colCount) {
+  const cols = process2.stdout.columns;
+  if (cols && colCount > 0) {
+    return Math.max(20, Math.floor(cols / colCount) - 2);
+  }
+  return DEFAULT_CELL_WIDTH;
+}
+function truncateCell(value, maxWidth = DEFAULT_CELL_WIDTH) {
+  if (value.length <= maxWidth) return value;
+  return value.slice(0, maxWidth - 3) + "...";
+}
+function isNumericCell(value) {
+  return /^-?\d[\d,]*(\.\d+)?%?$/.test(value.trim());
 }
 function cellValue(val) {
   if (val === null || val === void 0) return "";
@@ -170,12 +195,26 @@ function formatTable(data) {
   if (!firstRow) return "";
   const keys = Object.keys(firstRow);
   if (keys.length === 0) return "";
+  const colCount = keys.length;
+  const maxCellWidth = computeMaxCellWidth(colCount);
   const widths = keys.map(
-    (key) => Math.max(key.length, ...rows.map((row) => truncateCell(cellValue(row[key])).length))
+    (key) => Math.max(key.length, ...rows.map((row) => truncateCell(cellValue(row[key]), maxCellWidth).length))
   );
-  const header = keys.map((key, i) => key.padEnd(widths[i] ?? 0)).join("  ");
-  const separator = widths.map((w) => "-".repeat(w)).join("  ");
-  const body = rows.map((row) => keys.map((key, i) => truncateCell(cellValue(row[key])).padEnd(widths[i] ?? 0)).join("  ")).join("\n");
+  const isNumeric = keys.map(
+    (key) => rows.every((row) => {
+      const v = cellValue(row[key]);
+      return v === "" || isNumericCell(v);
+    })
+  );
+  const header = keys.map((key, i) => bold(key.padEnd(widths[i] ?? 0))).join("  ");
+  const separator = widths.map((w) => dim("\u2500".repeat(w))).join("  ");
+  const body = rows.map(
+    (row) => keys.map((key, i) => {
+      const cell = truncateCell(cellValue(row[key]), maxCellWidth);
+      const w = widths[i] ?? 0;
+      return isNumeric[i] ? cell.padStart(w) : cell.padEnd(w);
+    }).join("  ")
+  ).join("\n");
   return `${header}
 ${separator}
 ${body}`;
@@ -284,6 +323,28 @@ function buildTestCase(item, commandName, index = 0) {
     failed: false
   };
 }
+async function maybePaginate(output) {
+  const isTTY = process2.stdout.isTTY;
+  const termHeight = process2.stdout.rows ?? 24;
+  const lineCount = output.split("\n").length;
+  if (!isTTY || lineCount <= termHeight) {
+    console.log(output);
+    return;
+  }
+  const pager = process2.env["GPC_PAGER"] ?? process2.env["PAGER"] ?? "less";
+  try {
+    const { spawn } = await import("child_process");
+    const child = spawn(pager, [], {
+      stdio: ["pipe", "inherit", "inherit"],
+      env: { ...process2.env, LESS: process2.env["LESS"] ?? "-FRX" }
+    });
+    child.stdin.write(output);
+    child.stdin.end();
+    await new Promise((resolve2) => child.on("close", resolve2));
+  } catch {
+    console.log(output);
+  }
+}
 function formatJunit(data, commandName = "command") {
   const { cases, failures } = toTestCases(data, commandName);
   const tests = cases.length;
@@ -496,6 +557,7 @@ async function getAppInfo(client, packageName) {
 
 // src/commands/releases.ts
 import { stat as stat2 } from "fs/promises";
+import { ApiError as ApiError2 } from "@gpc-cli/api";
 
 // src/utils/file-validation.ts
 import { readFile, stat } from "fs/promises";
@@ -1161,6 +1223,70 @@ function diffListings(local, remote) {
   return diffs;
 }
 
+// src/utils/listing-text.ts
+var DEFAULT_LIMITS = {
+  title: 30,
+  shortDescription: 80,
+  fullDescription: 4e3,
+  video: 256
+};
+function lintListing(language, fields, limits = DEFAULT_LIMITS) {
+  const fieldResults = [];
+  for (const [field, limit] of Object.entries(limits)) {
+    const value = fields[field] ?? "";
+    const chars = [...value].length;
+    const pct = Math.round(chars / limit * 100);
+    let status = "ok";
+    if (chars > limit) status = "over";
+    else if (pct >= 80) status = "warn";
+    fieldResults.push({ field, chars, limit, pct, status });
+  }
+  const valid = fieldResults.every((r) => r.status !== "over");
+  return { language, fields: fieldResults, valid };
+}
+function lintListings(listings, limits) {
+  return listings.map((l) => lintListing(l.language, l.fields, limits));
+}
+function tokenize(text) {
+  return text.split(/(\s+)/);
+}
+function wordDiff(before, after) {
+  const aTokens = tokenize(before);
+  const bTokens = tokenize(after);
+  const m = aTokens.length;
+  const n = bTokens.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  const cell = (r, c) => dp[r]?.[c] ?? 0;
+  for (let i2 = 1; i2 <= m; i2++) {
+    for (let j2 = 1; j2 <= n; j2++) {
+      dp[i2][j2] = aTokens[i2 - 1] === bTokens[j2 - 1] ? cell(i2 - 1, j2 - 1) + 1 : Math.max(cell(i2 - 1, j2), cell(i2, j2 - 1));
+    }
+  }
+  const result = [];
+  let i = m, j = n;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && aTokens[i - 1] === bTokens[j - 1]) {
+      result.unshift({ text: aTokens[i - 1] ?? "", type: "equal" });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || cell(i, j - 1) >= cell(i - 1, j))) {
+      result.unshift({ text: bTokens[j - 1] ?? "", type: "insert" });
+      j--;
+    } else {
+      result.unshift({ text: aTokens[i - 1] ?? "", type: "delete" });
+      i--;
+    }
+  }
+  return result;
+}
+function formatWordDiff(diff) {
+  return diff.map((t) => {
+    if (t.type === "equal") return t.text;
+    if (t.type === "insert") return `[+${t.text}]`;
+    return `[-${t.text}]`;
+  }).join("");
+}
+
 // src/commands/listings.ts
 function validateLanguage(lang) {
   if (!isValidBcp47(lang)) {
@@ -1231,6 +1357,57 @@ async function pullListings(client, packageName, dir) {
     throw error;
   }
 }
+async function lintLocalListings(dir) {
+  const localListings = await readListingsFromDir(dir);
+  return lintListings(
+    localListings.map((l) => ({
+      language: l.language,
+      fields: {
+        title: l.title,
+        shortDescription: l.shortDescription,
+        fullDescription: l.fullDescription,
+        video: l.video
+      }
+    }))
+  );
+}
+async function analyzeRemoteListings(client, packageName, options) {
+  const listings = await getListings(client, packageName);
+  const results = lintListings(
+    listings.map((l) => ({
+      language: l.language,
+      fields: {
+        title: l.title,
+        shortDescription: l.shortDescription,
+        fullDescription: l.fullDescription,
+        video: l["video"]
+      }
+    }))
+  );
+  let missingLocales;
+  if (options?.expectedLocales) {
+    const present = new Set(listings.map((l) => l.language));
+    missingLocales = options.expectedLocales.filter((loc) => !present.has(loc));
+  }
+  return { results, missingLocales };
+}
+async function diffListingsEnhanced(client, packageName, dir, options) {
+  const allDiffs = await diffListingsCommand(client, packageName, dir);
+  let result = allDiffs;
+  if (options?.lang) {
+    result = allDiffs.filter((d) => d.language === options.lang);
+  }
+  if (options?.wordLevel) {
+    return result.map((d) => {
+      if (d.field === "fullDescription" && d.local && d.remote) {
+        const diff = wordDiff(d.remote, d.local);
+        return { ...d, diffSummary: formatWordDiff(diff) };
+      }
+      return d;
+    });
+  }
+  return result;
+}
 async function pushListings(client, packageName, dir, options) {
   const localListings = await readListingsFromDir(dir);
   if (localListings.length === 0) {
@@ -1244,6 +1421,33 @@ async function pushListings(client, packageName, dir, options) {
   for (const listing of localListings) {
     validateLanguage(listing.language);
   }
+  if (!options?.force) {
+    const lintResults = lintListings(
+      localListings.map((l) => ({
+        language: l.language,
+        fields: {
+          title: l.title,
+          shortDescription: l.shortDescription,
+          fullDescription: l.fullDescription,
+          video: l["video"]
+        }
+      }))
+    );
+    const overLimit = lintResults.filter((r) => !r.valid);
+    if (overLimit.length > 0) {
+      const details = overLimit.map((r) => {
+        const over = r.fields.filter((f) => f.status === "over");
+        return `${r.language}: ${over.map((f) => `${f.field} (${f.chars}/${f.limit})`).join(", ")}`;
+      }).join("\n");
+      throw new GpcError(
+        `Listing push blocked: field(s) exceed character limits:
+${details}`,
+        "LISTING_CHAR_LIMIT_EXCEEDED",
+        1,
+        "Fix the character limit violations listed above, or use --force to push anyway."
+      );
+    }
+  }
   const edit = await client.edits.insert(packageName);
   try {
     if (options?.dryRun) {
@@ -1358,8 +1562,8 @@ var ALL_IMAGE_TYPES = [
   "tvBanner"
 ];
 async function exportImages(client, packageName, dir, options) {
-  const { mkdir: mkdir6, writeFile: writeFile8 } = await import("fs/promises");
-  const { join: join8 } = await import("path");
+  const { mkdir: mkdir7, writeFile: writeFile9 } = await import("fs/promises");
+  const { join: join9 } = await import("path");
   const edit = await client.edits.insert(packageName);
   try {
     let languages;
@@ -1390,12 +1594,12 @@ 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 = join8(dir, task.language, task.imageType);
-          await mkdir6(dirPath, { recursive: true });
+          const dirPath = join9(dir, task.language, task.imageType);
+          await mkdir7(dirPath, { recursive: true });
           const response = await fetch(task.url);
           const buffer = Buffer.from(await response.arrayBuffer());
-          const filePath = join8(dirPath, `${task.index}.png`);
-          await writeFile8(filePath, buffer);
+          const filePath = join9(dirPath, `${task.index}.png`);
+          await writeFile9(filePath, buffer);
           return buffer.length;
         })
       );
@@ -1898,6 +2102,234 @@ async function publish(client, packageName, filePath, options) {
 
 // src/commands/reviews.ts
 import { paginateAll } from "@gpc-cli/api";
+
+// src/utils/sentiment.ts
+var POSITIVE_WORDS = /* @__PURE__ */ new Set([
+  "great",
+  "excellent",
+  "amazing",
+  "awesome",
+  "fantastic",
+  "love",
+  "good",
+  "best",
+  "perfect",
+  "wonderful",
+  "helpful",
+  "easy",
+  "fast",
+  "smooth",
+  "reliable",
+  "clean",
+  "beautiful",
+  "intuitive",
+  "works",
+  "recommend",
+  "useful",
+  "thank",
+  "thanks",
+  "brilliant",
+  "superb",
+  "flawless",
+  "outstanding",
+  "delightful",
+  "nice"
+]);
+var NEGATIVE_WORDS = /* @__PURE__ */ new Set([
+  "bad",
+  "terrible",
+  "awful",
+  "horrible",
+  "worst",
+  "hate",
+  "broken",
+  "crash",
+  "crashes",
+  "bug",
+  "bugs",
+  "slow",
+  "laggy",
+  "freeze",
+  "freezes",
+  "error",
+  "errors",
+  "fail",
+  "fails",
+  "useless",
+  "disappointing",
+  "disappointed",
+  "frustrating",
+  "frustration",
+  "annoying",
+  "problem",
+  "problems",
+  "issue",
+  "issues",
+  "fix",
+  "please",
+  "not working",
+  "doesn't work",
+  "stopped",
+  "uninstall",
+  "deleted",
+  "waste",
+  "rubbish",
+  "garbage",
+  "terrible"
+]);
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "is",
+  "it",
+  "this",
+  "that",
+  "was",
+  "are",
+  "be",
+  "been",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "i",
+  "me",
+  "my",
+  "we",
+  "you",
+  "he",
+  "she",
+  "they",
+  "them",
+  "their",
+  "its",
+  "not",
+  "no",
+  "very",
+  "so",
+  "just",
+  "really",
+  "app",
+  "application",
+  "update"
+]);
+function analyzeSentiment(text) {
+  const lower = text.toLowerCase();
+  const words = lower.split(/\W+/).filter(Boolean);
+  let posScore = 0;
+  let negScore = 0;
+  for (const word of words) {
+    if (POSITIVE_WORDS.has(word)) posScore++;
+    if (NEGATIVE_WORDS.has(word)) negScore++;
+  }
+  const total = posScore + negScore;
+  if (total === 0) return { score: 0, label: "neutral", magnitude: 0 };
+  const score = (posScore - negScore) / total;
+  const magnitude = Math.min(1, total / 10);
+  const label = score > 0.1 ? "positive" : score < -0.1 ? "negative" : "neutral";
+  return { score, label, magnitude };
+}
+function clusterTopics(texts) {
+  const TOPIC_KEYWORDS = {
+    "performance": ["slow", "lag", "laggy", "freeze", "fast", "speed", "quick", "smooth"],
+    "crashes": ["crash", "crashes", "crash", "crashing", "force close", "stops", "stopped"],
+    "ui/ux": ["ui", "design", "interface", "layout", "button", "screen", "menu", "navigation"],
+    "battery": ["battery", "drain", "power", "charging", "drain"],
+    "updates": ["update", "updated", "version", "new version", "after update"],
+    "notifications": ["notification", "notifications", "alert", "alerts", "push"],
+    "login/auth": ["login", "sign in", "logout", "password", "account", "auth"],
+    "feature requests": ["please add", "would be nice", "missing", "need", "wish", "want"],
+    "bugs": ["bug", "bugs", "issue", "error", "problem", "glitch", "broken"],
+    "pricing": ["price", "pricing", "expensive", "cheap", "subscription", "pay", "cost", "free"]
+  };
+  const clusterMap = /* @__PURE__ */ new Map();
+  for (const text of texts) {
+    const lower = text.toLowerCase();
+    const sentiment = analyzeSentiment(text);
+    for (const [topic, keywords] of Object.entries(TOPIC_KEYWORDS)) {
+      if (keywords.some((kw) => lower.includes(kw))) {
+        const existing = clusterMap.get(topic) ?? { count: 0, totalScore: 0 };
+        clusterMap.set(topic, {
+          count: existing.count + 1,
+          totalScore: existing.totalScore + sentiment.score
+        });
+      }
+    }
+  }
+  return Array.from(clusterMap.entries()).map(([topic, { count, totalScore }]) => ({
+    topic,
+    count,
+    avgScore: count > 0 ? Math.round(totalScore / count * 100) / 100 : 0
+  })).filter((c) => c.count > 0).sort((a, b) => b.count - a.count);
+}
+function keywordFrequency(texts, topN = 20) {
+  const freq = /* @__PURE__ */ new Map();
+  for (const text of texts) {
+    const words = text.toLowerCase().split(/\W+/).filter((w) => w.length > 3 && !STOP_WORDS.has(w));
+    for (const word of words) {
+      freq.set(word, (freq.get(word) ?? 0) + 1);
+    }
+  }
+  return Array.from(freq.entries()).map(([word, count]) => ({ word, count })).sort((a, b) => b.count - a.count).slice(0, topN);
+}
+function analyzeReviews(reviews) {
+  if (reviews.length === 0) {
+    return {
+      totalReviews: 0,
+      avgRating: 0,
+      sentiment: { positive: 0, negative: 0, neutral: 0, avgScore: 0 },
+      topics: [],
+      keywords: [],
+      ratingDistribution: {}
+    };
+  }
+  const texts = reviews.map((r) => r.text);
+  const sentiments = texts.map((t) => analyzeSentiment(t));
+  const positive = sentiments.filter((s) => s.label === "positive").length;
+  const negative = sentiments.filter((s) => s.label === "negative").length;
+  const neutral = sentiments.filter((s) => s.label === "neutral").length;
+  const avgScore = sentiments.reduce((sum, s) => sum + s.score, 0) / sentiments.length;
+  const ratings = reviews.map((r) => r.rating).filter((r) => r !== void 0);
+  const avgRating = ratings.length > 0 ? ratings.reduce((a, b) => a + b, 0) / ratings.length : 0;
+  const ratingDistribution = {};
+  for (const r of ratings) {
+    ratingDistribution[r] = (ratingDistribution[r] ?? 0) + 1;
+  }
+  return {
+    totalReviews: reviews.length,
+    avgRating: Math.round(avgRating * 100) / 100,
+    sentiment: {
+      positive,
+      negative,
+      neutral,
+      avgScore: Math.round(avgScore * 100) / 100
+    },
+    topics: clusterTopics(texts),
+    keywords: keywordFrequency(texts),
+    ratingDistribution
+  };
+}
+
+// src/commands/reviews.ts
 async function listReviews(client, packageName, options) {
   const apiOptions = {};
   if (options?.translationLanguage) apiOptions.translationLanguage = options.translationLanguage;
@@ -2007,163 +2439,16 @@ function csvEscape(value) {
   }
   return value;
 }
-
-// src/commands/vitals.ts
-var METRIC_SET_METRICS = {
-  crashRateMetricSet: ["crashRate", "userPerceivedCrashRate", "distinctUsers"],
-  anrRateMetricSet: ["anrRate", "userPerceivedAnrRate", "distinctUsers"],
-  slowStartRateMetricSet: ["slowStartRate", "distinctUsers"],
-  slowRenderingRateMetricSet: ["slowRenderingRate", "distinctUsers"],
-  excessiveWakeupRateMetricSet: ["excessiveWakeupRate", "distinctUsers"],
-  stuckBackgroundWakelockRateMetricSet: ["stuckBackgroundWakelockRate", "distinctUsers"],
-  errorCountMetricSet: ["errorReportCount", "distinctUsers"]
-};
-function buildQuery(metricSet, options) {
-  const metrics = METRIC_SET_METRICS[metricSet] ?? ["errorReportCount", "distinctUsers"];
-  const days = options?.days ?? 30;
-  const DAY_MS = 24 * 60 * 60 * 1e3;
-  const end = new Date(Date.now() - DAY_MS);
-  const start = new Date(Date.now() - DAY_MS - days * DAY_MS);
-  const query = {
-    metrics,
-    timelineSpec: {
-      aggregationPeriod: options?.aggregation ?? "DAILY",
-      startTime: {
-        year: start.getUTCFullYear(),
-        month: start.getUTCMonth() + 1,
-        day: start.getUTCDate()
-      },
-      endTime: {
-        year: end.getUTCFullYear(),
-        month: end.getUTCMonth() + 1,
-        day: end.getUTCDate()
-      }
-    }
-  };
-  if (options?.dimension) {
-    query.dimensions = [options.dimension];
-  }
-  return query;
-}
-async function queryMetric(reporting, packageName, metricSet, options) {
-  const query = buildQuery(metricSet, options);
-  return reporting.queryMetricSet(packageName, metricSet, query);
-}
-async function getVitalsOverview(reporting, packageName) {
-  const metricSets = [
-    ["crashRateMetricSet", "crashRate"],
-    ["anrRateMetricSet", "anrRate"],
-    ["slowStartRateMetricSet", "slowStartRate"],
-    ["slowRenderingRateMetricSet", "slowRenderingRate"],
-    ["excessiveWakeupRateMetricSet", "excessiveWakeupRate"],
-    ["stuckBackgroundWakelockRateMetricSet", "stuckWakelockRate"]
-  ];
-  const results = await Promise.allSettled(
-    metricSets.map(
-      ([metric]) => reporting.queryMetricSet(packageName, metric, buildQuery(metric))
-    )
-  );
-  const overview = {};
-  for (let i = 0; i < metricSets.length; i++) {
-    const entry = metricSets[i];
-    if (!entry) continue;
-    const key = entry[1];
-    const result = results[i];
-    if (!result) continue;
-    if (result.status === "fulfilled") {
-      overview[key] = result.value.rows || [];
-    }
-  }
-  return overview;
-}
-async function getVitalsCrashes(reporting, packageName, options) {
-  return queryMetric(reporting, packageName, "crashRateMetricSet", options);
-}
-async function getVitalsAnr(reporting, packageName, options) {
-  return queryMetric(reporting, packageName, "anrRateMetricSet", options);
-}
-async function getVitalsStartup(reporting, packageName, options) {
-  return queryMetric(reporting, packageName, "slowStartRateMetricSet", options);
-}
-async function getVitalsRendering(reporting, packageName, options) {
-  return queryMetric(reporting, packageName, "slowRenderingRateMetricSet", options);
-}
-async function getVitalsBattery(reporting, packageName, options) {
-  return queryMetric(reporting, packageName, "excessiveWakeupRateMetricSet", options);
-}
-async function getVitalsMemory(reporting, packageName, options) {
-  return queryMetric(reporting, packageName, "stuckBackgroundWakelockRateMetricSet", options);
-}
-async function getVitalsAnomalies(reporting, packageName) {
-  return reporting.getAnomalies(packageName);
-}
-async function searchVitalsErrors(reporting, packageName, options) {
-  return reporting.searchErrorIssues(packageName, options?.filter, options?.maxResults);
-}
-async function compareVitalsTrend(reporting, packageName, metricSet, days = 7) {
-  const DAY_MS = 24 * 60 * 60 * 1e3;
-  const nowMs = Date.now();
-  const baseMs = nowMs - 2 * DAY_MS;
-  const currentEnd = new Date(baseMs);
-  const currentStart = new Date(baseMs - days * DAY_MS);
-  const previousEnd = new Date(baseMs - days * DAY_MS - DAY_MS);
-  const previousStart = new Date(baseMs - days * DAY_MS - DAY_MS - days * DAY_MS);
-  const metrics = METRIC_SET_METRICS[metricSet] ?? ["errorReportCount", "distinctUsers"];
-  const toApiDate2 = (d) => ({
-    year: d.getUTCFullYear(),
-    month: d.getUTCMonth() + 1,
-    day: d.getUTCDate()
-  });
-  const makeQuery = (start, end) => ({
-    metrics,
-    timelineSpec: {
-      aggregationPeriod: "DAILY",
-      startTime: toApiDate2(start),
-      endTime: toApiDate2(end)
-    }
+async function analyzeReviews2(client, packageName, options) {
+  const reviews = await listReviews(client, packageName, options);
+  const items = reviews.map((r) => {
+    const uc = r.comments?.[0]?.userComment;
+    return {
+      text: uc?.text ?? "",
+      rating: uc?.starRating
+    };
   });
-  const [currentResult, previousResult] = await Promise.all([
-    reporting.queryMetricSet(packageName, metricSet, makeQuery(currentStart, currentEnd)),
-    reporting.queryMetricSet(packageName, metricSet, makeQuery(previousStart, previousEnd))
-  ]);
-  const extractAvg = (rows) => {
-    if (!rows || rows.length === 0) return void 0;
-    const values = rows.map((r) => {
-      const keys = Object.keys(r.metrics);
-      const first = keys[0];
-      return first ? Number(r.metrics[first]?.decimalValue?.value) : NaN;
-    }).filter((v) => !isNaN(v));
-    if (values.length === 0) return void 0;
-    return values.reduce((a, b) => a + b, 0) / values.length;
-  };
-  const current = extractAvg(currentResult.rows);
-  const previous = extractAvg(previousResult.rows);
-  let changePercent;
-  let direction = "unknown";
-  if (current !== void 0 && previous !== void 0 && previous !== 0) {
-    changePercent = (current - previous) / previous * 100;
-    if (Math.abs(changePercent) < 1) {
-      direction = "unchanged";
-    } else if (changePercent < 0) {
-      direction = "improved";
-    } else {
-      direction = "degraded";
-    }
-  }
-  return {
-    metric: metricSet,
-    current,
-    previous,
-    changePercent: changePercent !== void 0 ? Math.round(changePercent * 10) / 10 : void 0,
-    direction
-  };
-}
-function checkThreshold(value, threshold) {
-  return {
-    breached: value !== void 0 && value > threshold,
-    value,
-    threshold
-  };
+  return analyzeReviews(items);
 }
 
 // src/commands/subscriptions.ts
@@ -2180,7 +2465,9 @@ function sanitizeSubscription(data) {
   delete cleaned["archived"];
   if (cleaned.basePlans) {
     cleaned.basePlans = cleaned.basePlans.map((bp) => {
-      const { state: _s, archived: _a, ...cleanBp } = bp;
+      const { state: _state, archived: _archived, ...cleanBp } = bp;
+      void _state;
+      void _archived;
       if (cleanBp.regionalConfigs) {
         cleanBp.regionalConfigs = cleanBp.regionalConfigs.map((rc) => ({
           ...rc,
@@ -2193,7 +2480,8 @@ function sanitizeSubscription(data) {
   return cleaned;
 }
 function sanitizeOffer(data) {
-  const { state: _s, ...cleaned } = data;
+  const { state: _state2, ...cleaned } = data;
+  void _state2;
   delete cleaned["archived"];
   return cleaned;
 }
@@ -2211,7 +2499,7 @@ function autoFixProrationMode(data) {
   for (const bp of data.basePlans) {
     const mode = bp.autoRenewingBasePlanType?.prorationMode;
     if (mode && !mode.startsWith(PRORATION_MODE_PREFIX)) {
-      bp.autoRenewingBasePlanType.prorationMode = `${PRORATION_MODE_PREFIX}${mode}`;
+      if (bp.autoRenewingBasePlanType) bp.autoRenewingBasePlanType.prorationMode = `${PRORATION_MODE_PREFIX}${mode}`;
     }
     if (bp.autoRenewingBasePlanType?.prorationMode) {
       const fullMode = bp.autoRenewingBasePlanType.prorationMode;
@@ -2399,19 +2687,323 @@ async function deactivateOffer(client, packageName, productId, basePlanId, offer
   validateSku(productId);
   return client.subscriptions.deactivateOffer(packageName, productId, basePlanId, offerId);
 }
+async function getSubscriptionAnalytics(client, packageName) {
+  validatePackageName(packageName);
+  const { items: subs } = await paginateAll2(async (pageToken) => {
+    const response = await client.subscriptions.list(packageName, {
+      pageToken,
+      pageSize: 100
+    });
+    return {
+      items: response.subscriptions || [],
+      nextPageToken: response.nextPageToken
+    };
+  });
+  let activeCount = 0;
+  let activeBasePlans = 0;
+  let trialBasePlans = 0;
+  let pausedBasePlans = 0;
+  let canceledBasePlans = 0;
+  let totalOffers = 0;
+  const byProductId = [];
+  for (const sub of subs) {
+    const state = sub["state"];
+    if (state === "ACTIVE") activeCount++;
+    const basePlans = sub.basePlans ?? [];
+    let subOfferCount = 0;
+    for (const bp of basePlans) {
+      const bpState = bp["state"];
+      if (bpState === "ACTIVE") activeBasePlans++;
+      else if (bpState === "DRAFT") trialBasePlans++;
+      else if (bpState === "INACTIVE") pausedBasePlans++;
+      else if (bpState === "PREPUBLISHED") canceledBasePlans++;
+    }
+    for (const bp of basePlans) {
+      try {
+        const offersResp = await client.subscriptions.listOffers(packageName, sub.productId, bp.basePlanId);
+        const offers = offersResp.subscriptionOffers ?? [];
+        subOfferCount += offers.length;
+        totalOffers += offers.length;
+      } catch {
+      }
+    }
+    byProductId.push({
+      productId: sub.productId,
+      state: sub["state"] ?? "UNKNOWN",
+      basePlanCount: basePlans.length,
+      offerCount: subOfferCount
+    });
+  }
+  return {
+    totalSubscriptions: subs.length,
+    activeCount,
+    activeBasePlans,
+    trialBasePlans,
+    pausedBasePlans,
+    canceledBasePlans,
+    offerCount: totalOffers,
+    byProductId
+  };
+}
 
-// src/commands/iap.ts
-import { readdir as readdir4, readFile as readFile5 } from "fs/promises";
-import { join as join4 } from "path";
-import { paginateAll as paginateAll3 } from "@gpc-cli/api";
-async function listInAppProducts(client, packageName, options) {
-  if (options?.limit || options?.nextPage) {
-    const result = await paginateAll3(
-      async (pageToken) => {
-        const resp = await client.inappproducts.list(packageName, {
-          token: pageToken,
-          maxResults: options?.maxResults
-        });
+// src/commands/vitals.ts
+var METRIC_SET_METRICS = {
+  crashRateMetricSet: ["crashRate", "userPerceivedCrashRate", "distinctUsers"],
+  anrRateMetricSet: ["anrRate", "userPerceivedAnrRate", "distinctUsers"],
+  slowStartRateMetricSet: ["slowStartRate", "distinctUsers"],
+  slowRenderingRateMetricSet: ["slowRenderingRate", "distinctUsers"],
+  excessiveWakeupRateMetricSet: ["excessiveWakeupRate", "distinctUsers"],
+  stuckBackgroundWakelockRateMetricSet: ["stuckBackgroundWakelockRate", "distinctUsers"],
+  errorCountMetricSet: ["errorReportCount", "distinctUsers"]
+};
+function buildQuery(metricSet, options) {
+  const metrics = METRIC_SET_METRICS[metricSet] ?? ["errorReportCount", "distinctUsers"];
+  const days = options?.days ?? 30;
+  const DAY_MS = 24 * 60 * 60 * 1e3;
+  const end = new Date(Date.now() - DAY_MS);
+  const start = new Date(Date.now() - DAY_MS - days * DAY_MS);
+  const query = {
+    metrics,
+    timelineSpec: {
+      aggregationPeriod: options?.aggregation ?? "DAILY",
+      startTime: {
+        year: start.getUTCFullYear(),
+        month: start.getUTCMonth() + 1,
+        day: start.getUTCDate()
+      },
+      endTime: {
+        year: end.getUTCFullYear(),
+        month: end.getUTCMonth() + 1,
+        day: end.getUTCDate()
+      }
+    }
+  };
+  if (options?.dimension) {
+    query.dimensions = [options.dimension];
+  }
+  return query;
+}
+async function queryMetric(reporting, packageName, metricSet, options) {
+  const query = buildQuery(metricSet, options);
+  return reporting.queryMetricSet(packageName, metricSet, query);
+}
+async function getVitalsOverview(reporting, packageName) {
+  const metricSets = [
+    ["crashRateMetricSet", "crashRate"],
+    ["anrRateMetricSet", "anrRate"],
+    ["slowStartRateMetricSet", "slowStartRate"],
+    ["slowRenderingRateMetricSet", "slowRenderingRate"],
+    ["excessiveWakeupRateMetricSet", "excessiveWakeupRate"],
+    ["stuckBackgroundWakelockRateMetricSet", "stuckWakelockRate"]
+  ];
+  const results = await Promise.allSettled(
+    metricSets.map(
+      ([metric]) => reporting.queryMetricSet(packageName, metric, buildQuery(metric))
+    )
+  );
+  const overview = {};
+  for (let i = 0; i < metricSets.length; i++) {
+    const entry = metricSets[i];
+    if (!entry) continue;
+    const key = entry[1];
+    const result = results[i];
+    if (!result) continue;
+    if (result.status === "fulfilled") {
+      overview[key] = result.value.rows || [];
+    }
+  }
+  return overview;
+}
+async function getVitalsCrashes(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "crashRateMetricSet", options);
+}
+async function getVitalsAnr(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "anrRateMetricSet", options);
+}
+async function getVitalsStartup(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "slowStartRateMetricSet", options);
+}
+async function getVitalsRendering(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "slowRenderingRateMetricSet", options);
+}
+async function getVitalsBattery(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "excessiveWakeupRateMetricSet", options);
+}
+async function getVitalsMemory(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "stuckBackgroundWakelockRateMetricSet", options);
+}
+async function getVitalsLmk(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "stuckBackgroundWakelockRateMetricSet", {
+    ...options,
+    aggregation: "DAILY"
+  });
+}
+async function getVitalsAnomalies(reporting, packageName) {
+  return reporting.getAnomalies(packageName);
+}
+async function searchVitalsErrors(reporting, packageName, options) {
+  return reporting.searchErrorIssues(packageName, options?.filter, options?.maxResults);
+}
+async function compareVitalsTrend(reporting, packageName, metricSet, days = 7) {
+  const DAY_MS = 24 * 60 * 60 * 1e3;
+  const nowMs = Date.now();
+  const baseMs = nowMs - 2 * DAY_MS;
+  const currentEnd = new Date(baseMs);
+  const currentStart = new Date(baseMs - days * DAY_MS);
+  const previousEnd = new Date(baseMs - days * DAY_MS - DAY_MS);
+  const previousStart = new Date(baseMs - days * DAY_MS - DAY_MS - days * DAY_MS);
+  const metrics = METRIC_SET_METRICS[metricSet] ?? ["errorReportCount", "distinctUsers"];
+  const toApiDate2 = (d) => ({
+    year: d.getUTCFullYear(),
+    month: d.getUTCMonth() + 1,
+    day: d.getUTCDate()
+  });
+  const makeQuery = (start, end) => ({
+    metrics,
+    timelineSpec: {
+      aggregationPeriod: "DAILY",
+      startTime: toApiDate2(start),
+      endTime: toApiDate2(end)
+    }
+  });
+  const [currentResult, previousResult] = await Promise.all([
+    reporting.queryMetricSet(packageName, metricSet, makeQuery(currentStart, currentEnd)),
+    reporting.queryMetricSet(packageName, metricSet, makeQuery(previousStart, previousEnd))
+  ]);
+  const extractAvg = (rows) => {
+    if (!rows || rows.length === 0) return void 0;
+    const values = rows.map((r) => {
+      const keys = Object.keys(r.metrics);
+      const first = keys[0];
+      return first ? Number(r.metrics[first]?.decimalValue?.value) : NaN;
+    }).filter((v) => !isNaN(v));
+    if (values.length === 0) return void 0;
+    return values.reduce((a, b) => a + b, 0) / values.length;
+  };
+  const current = extractAvg(currentResult.rows);
+  const previous = extractAvg(previousResult.rows);
+  let changePercent;
+  let direction = "unknown";
+  if (current !== void 0 && previous !== void 0 && previous !== 0) {
+    changePercent = (current - previous) / previous * 100;
+    if (Math.abs(changePercent) < 1) {
+      direction = "unchanged";
+    } else if (changePercent < 0) {
+      direction = "improved";
+    } else {
+      direction = "degraded";
+    }
+  }
+  return {
+    metric: metricSet,
+    current,
+    previous,
+    changePercent: changePercent !== void 0 ? Math.round(changePercent * 10) / 10 : void 0,
+    direction
+  };
+}
+function checkThreshold(value, threshold) {
+  return {
+    breached: value !== void 0 && value > threshold,
+    value,
+    threshold
+  };
+}
+async function compareVersionVitals(reporting, packageName, v1, v2, options) {
+  const days = options?.days ?? 30;
+  const metricSets = [
+    ["crashRateMetricSet", "crashRate"],
+    ["anrRateMetricSet", "anrRate"],
+    ["slowStartRateMetricSet", "slowStartRate"],
+    ["slowRenderingRateMetricSet", "slowRenderingRate"]
+  ];
+  const results = await Promise.allSettled(
+    metricSets.map(
+      ([ms]) => queryMetric(reporting, packageName, ms, { dimension: "versionCode", days })
+    )
+  );
+  const row1 = { versionCode: v1 };
+  const row2 = { versionCode: v2 };
+  for (let i = 0; i < metricSets.length; i++) {
+    const entry = metricSets[i];
+    const result = results[i];
+    if (!entry || !result || result.status !== "fulfilled") continue;
+    const key = entry[1];
+    const rows = result.value.rows ?? [];
+    const extractAvgForVersion = (vc) => {
+      const matching = rows.filter((r) => {
+        const dims = r.dimensions;
+        return dims?.some((d) => d["stringValue"] === vc) ?? false;
+      });
+      if (matching.length === 0) return void 0;
+      const values = matching.map((r) => {
+        const firstKey = Object.keys(r.metrics)[0];
+        return firstKey ? Number(r.metrics[firstKey]?.decimalValue?.value) : NaN;
+      }).filter((v) => !isNaN(v));
+      if (values.length === 0) return void 0;
+      return values.reduce((a, b) => a + b, 0) / values.length;
+    };
+    row1[key] = extractAvgForVersion(v1);
+    row2[key] = extractAvgForVersion(v2);
+  }
+  const regressions = [];
+  for (const [, key] of metricSets) {
+    const val1 = row1[key];
+    const val2 = row2[key];
+    if (val1 !== void 0 && val2 !== void 0 && val2 > val1 * 1.05) {
+      regressions.push(key);
+    }
+  }
+  return { v1: row1, v2: row2, regressions };
+}
+function watchVitalsWithAutoHalt(reporting, packageName, options) {
+  const {
+    intervalMs = 5 * 60 * 1e3,
+    threshold,
+    metricSet = "crashRateMetricSet",
+    onHalt,
+    onPoll
+  } = options;
+  let stopped = false;
+  let haltTriggered = false;
+  const poll = async () => {
+    if (stopped) return;
+    try {
+      const result = await queryMetric(reporting, packageName, metricSet, { days: 1 });
+      const latestRow = result.rows?.[result.rows.length - 1];
+      const firstMetric = latestRow?.metrics ? Object.keys(latestRow.metrics)[0] : void 0;
+      const value = firstMetric ? Number(latestRow?.metrics[firstMetric]?.decimalValue?.value) : void 0;
+      const breached = value !== void 0 && value > threshold;
+      onPoll?.(value, breached);
+      if (breached && !haltTriggered && onHalt) {
+        haltTriggered = true;
+        await onHalt(value);
+      }
+    } catch {
+    }
+    if (!stopped) {
+      timerId = setTimeout(poll, intervalMs);
+    }
+  };
+  let timerId = setTimeout(poll, 0);
+  return () => {
+    stopped = true;
+    clearTimeout(timerId);
+  };
+}
+
+// src/commands/iap.ts
+import { readdir as readdir4, readFile as readFile5 } from "fs/promises";
+import { join as join4 } from "path";
+import { paginateAll as paginateAll3 } from "@gpc-cli/api";
+async function listInAppProducts(client, packageName, options) {
+  if (options?.limit || options?.nextPage) {
+    const result = await paginateAll3(
+      async (pageToken) => {
+        const resp = await client.inappproducts.list(packageName, {
+          token: pageToken,
+          maxResults: options?.maxResults
+        });
         return {
           items: resp.inappproduct || [],
           nextPageToken: resp.tokenPagination?.nextPageToken
@@ -2592,6 +3184,10 @@ async function revokeSubscriptionPurchase(client, packageName, token) {
   validatePackageName(packageName);
   return client.purchases.revokeSubscriptionV2(packageName, token);
 }
+async function refundSubscriptionV2(client, packageName, token) {
+  validatePackageName(packageName);
+  return client.purchases.refundSubscriptionV2(packageName, token);
+}
 async function listVoidedPurchases(client, packageName, options) {
   validatePackageName(packageName);
   if (options?.limit || options?.nextPage) {
@@ -2666,8 +3262,8 @@ function isStatsReportType(type) {
 function isValidReportType(type) {
   return FINANCIAL_REPORT_TYPES.has(type) || STATS_REPORT_TYPES.has(type);
 }
-function isValidStatsDimension(dim) {
-  return VALID_DIMENSIONS.has(dim);
+function isValidStatsDimension(dim2) {
+  return VALID_DIMENSIONS.has(dim2);
 }
 function parseMonth(monthStr) {
   const match = /^(\d{4})-(\d{2})$/.exec(monthStr);
@@ -2766,6 +3362,26 @@ function parseGrantArg(grantStr) {
   return { packageName, appLevelPermissions: perms };
 }
 
+// src/commands/grants.ts
+async function listGrants(client, developerId, email) {
+  const result = await client.grants.list(developerId, email);
+  return result.grants || [];
+}
+async function createGrant(client, developerId, email, packageName, permissions) {
+  return client.grants.create(developerId, email, {
+    packageName,
+    appLevelPermissions: permissions
+  });
+}
+async function updateGrant(client, developerId, email, packageName, permissions) {
+  return client.grants.patch(developerId, email, packageName, {
+    appLevelPermissions: permissions
+  }, "appLevelPermissions");
+}
+async function deleteGrant(client, developerId, email, packageName) {
+  return client.grants.delete(developerId, email, packageName);
+}
+
 // src/commands/testers.ts
 import { readFile as readFile6 } from "fs/promises";
 async function listTesters(client, packageName, track) {
@@ -2843,7 +3459,7 @@ var DEFAULT_MAX_LENGTH = 500;
 function parseConventionalCommit(subject) {
   const match = subject.match(/^(\w+)(?:\([^)]*\))?:\s*(.+)$/);
   if (match) {
-    return { type: match[1], message: match[2].trim() };
+    return { type: match[1] ?? "other", message: (match[2] ?? "").trim() };
   }
   return { type: "other", message: subject.trim() };
 }
@@ -2854,7 +3470,7 @@ function formatNotes(commits, maxLength) {
     if (!groups.has(header)) {
       groups.set(header, []);
     }
-    groups.get(header).push(commit.message);
+    groups.get(header)?.push(commit.message);
   }
   const order = ["New", "Fixed", "Improved", "Changes"];
   const sections = [];
@@ -3266,190 +3882,182 @@ function createSpinner(message) {
   };
 }
 
-// src/utils/safe-path.ts
-import { resolve, normalize } from "path";
-function safePath(userPath) {
-  return resolve(normalize(userPath));
+// src/utils/train-state.ts
+import { mkdir as mkdir3, readFile as readFile8, writeFile as writeFile4 } from "fs/promises";
+import { join as join5 } from "path";
+import { getCacheDir } from "@gpc-cli/config";
+function stateFile(packageName) {
+  return join5(getCacheDir(), `train-${packageName}.json`);
 }
-function safePathWithin(userPath, baseDir) {
-  const resolved = safePath(userPath);
-  const base = safePath(baseDir);
-  if (!resolved.startsWith(base + "/") && resolved !== base) {
-    throw new GpcError(
-      `Path "${userPath}" resolves outside the expected directory "${baseDir}"`,
-      "PATH_TRAVERSAL",
-      2,
-      "The path must stay within the target directory. Remove any ../ segments or use an absolute path within the expected directory."
-    );
+async function readTrainState(packageName) {
+  const path = stateFile(packageName);
+  try {
+    const raw = await readFile8(path, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeTrainState(packageName, state) {
+  const path = stateFile(packageName);
+  const dir = path.substring(0, path.lastIndexOf("/"));
+  await mkdir3(dir, { recursive: true });
+  await writeFile4(path, JSON.stringify(state, null, 2), "utf-8");
+}
+async function clearTrainState(packageName) {
+  const { unlink } = await import("fs/promises");
+  const path = stateFile(packageName);
+  await unlink(path).catch(() => {
+  });
+}
+function parseDuration2(s) {
+  const match = /^(\d+)(d|h|m)$/.exec(s.trim());
+  if (!match) return 0;
+  const n = parseInt(match[1] ?? "0", 10);
+  switch (match[2]) {
+    case "d":
+      return n * 24 * 60 * 60 * 1e3;
+    case "h":
+      return n * 60 * 60 * 1e3;
+    case "m":
+      return n * 60 * 1e3;
+    default:
+      return 0;
   }
-  return resolved;
 }
 
-// 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;
+// src/commands/train.ts
+async function startTrain(apiClient, packageName, config, options) {
+  const existing = await readTrainState(packageName);
+  if (existing && existing.status === "running" && !options?.force) {
+    return existing;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const state = {
+    packageName,
+    status: "running",
+    currentStage: 0,
+    startedAt: now,
+    updatedAt: now,
+    stages: config.stages.map((s, i) => ({
+      ...s,
+      scheduledAt: i === 0 ? now : void 0
+    })),
+    gates: config.gates
+  };
+  await writeTrainState(packageName, state);
+  await executeStage(apiClient, packageName, state, 0);
+  return state;
+}
+async function getTrainStatus(packageName) {
+  return readTrainState(packageName);
+}
+async function pauseTrain(packageName) {
+  const state = await readTrainState(packageName);
+  if (!state || state.status !== "running") return state;
+  state.status = "paused";
+  state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeTrainState(packageName, state);
+  return state;
+}
+async function abortTrain(packageName) {
+  await clearTrainState(packageName);
+}
+async function advanceTrain(apiClient, reportingClient, packageName) {
+  const state = await readTrainState(packageName);
+  if (!state || state.status !== "running") return state;
+  const nextStage = state.currentStage + 1;
+  if (nextStage >= state.stages.length) {
+    state.status = "completed";
+    state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await writeTrainState(packageName, state);
+    return state;
+  }
+  const nextStageConfig = state.stages[nextStage];
+  if (!nextStageConfig) return state;
+  if (nextStageConfig.after) {
+    const delayMs = parseDuration2(nextStageConfig.after);
+    const currentStageConfig = state.stages[state.currentStage];
+    const executedAt = currentStageConfig?.executedAt;
+    if (executedAt && delayMs > 0) {
+      const elapsed = Date.now() - new Date(executedAt).getTime();
+      if (elapsed < delayMs) {
+        const readyAt = new Date(new Date(executedAt).getTime() + delayMs).toISOString();
+        nextStageConfig.scheduledAt = readyAt;
+        await writeTrainState(packageName, state);
+        return state;
+      }
     }
-    current = current[part];
   }
-  return current;
+  if (state.gates) {
+    if (state.gates.crashes?.max !== void 0) {
+      const result = await getVitalsCrashes(reportingClient, packageName, { days: 1 });
+      const latestRow = result.rows?.[result.rows.length - 1];
+      const firstMetric = latestRow?.metrics ? Object.keys(latestRow.metrics)[0] : void 0;
+      const value = firstMetric ? Number(latestRow?.metrics[firstMetric]?.decimalValue?.value) : void 0;
+      if (value !== void 0 && value > state.gates.crashes.max / 100) {
+        state.status = "paused";
+        state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        await writeTrainState(packageName, state);
+        throw new Error(
+          `Crash gate failed: ${(value * 100).toFixed(3)}% > max ${state.gates.crashes.max}%. Train paused.`
+        );
+      }
+    }
+    if (state.gates.anr?.max !== void 0) {
+      const result = await getVitalsAnr(reportingClient, packageName, { days: 1 });
+      const latestRow = result.rows?.[result.rows.length - 1];
+      const firstMetric = latestRow?.metrics ? Object.keys(latestRow.metrics)[0] : void 0;
+      const value = firstMetric ? Number(latestRow?.metrics[firstMetric]?.decimalValue?.value) : void 0;
+      if (value !== void 0 && value > state.gates.anr.max / 100) {
+        state.status = "paused";
+        state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        await writeTrainState(packageName, state);
+        throw new Error(
+          `ANR gate failed: ${(value * 100).toFixed(3)}% > max ${state.gates.anr.max}%. Train paused.`
+        );
+      }
+    }
+  }
+  await executeStage(apiClient, packageName, state, nextStage);
+  return state;
 }
-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;
+async function executeStage(apiClient, packageName, state, stageIndex) {
+  const stage = state.stages[stageIndex];
+  if (!stage) throw new Error(`Stage ${stageIndex} not found`);
+  const rolloutFraction = stage.rollout / 100;
+  await updateRollout(apiClient, packageName, stage.track, "increase", rolloutFraction);
+  stage.executedAt = (/* @__PURE__ */ new Date()).toISOString();
+  state.currentStage = stageIndex;
+  state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeTrainState(packageName, state);
 }
 
-// src/commands/plugin-scaffold.ts
-import { mkdir as mkdir3, writeFile as writeFile4 } from "fs/promises";
-import { join as join5 } 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 = join5(dir, "src");
-  const testDir = join5(dir, "tests");
-  await mkdir3(srcDir, { recursive: true });
-  await mkdir3(testDir, { recursive: true });
-  const files = [];
-  const pkg = {
-    name: pluginName,
-    version: "0.1.0",
-    description,
-    type: "module",
-    main: "./dist/index.js",
-    types: "./dist/index.d.ts",
-    exports: {
-      ".": {
-        import: "./dist/index.js",
-        types: "./dist/index.d.ts"
-      }
-    },
-    files: ["dist"],
-    scripts: {
-      build: "tsup src/index.ts --format esm --dts",
-      dev: "tsup src/index.ts --format esm --dts --watch",
-      test: "vitest run",
-      "test:watch": "vitest"
-    },
-    keywords: ["gpc", "gpc-plugin", "google-play"],
-    license: "MIT",
-    peerDependencies: {
-      "@gpc-cli/plugin-sdk": ">=0.8.0"
-    },
-    devDependencies: {
-      "@gpc-cli/plugin-sdk": "^0.8.0",
-      tsup: "^8.0.0",
-      typescript: "^5.0.0",
-      vitest: "^3.0.0"
-    }
-  };
-  await writeFile4(join5(dir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
-  files.push("package.json");
-  const tsconfig = {
-    compilerOptions: {
-      target: "ES2022",
-      module: "ESNext",
-      moduleResolution: "bundler",
-      declaration: true,
-      strict: true,
-      esModuleInterop: true,
-      skipLibCheck: true,
-      outDir: "./dist",
-      rootDir: "./src"
-    },
-    include: ["src"]
-  };
-  await writeFile4(join5(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";
-
-export const plugin = definePlugin({
-  name: "${pluginName}",
-  version: "0.1.0",
-
-  register(hooks) {
-    hooks.beforeCommand(async (event: CommandEvent) => {
-      // Called before every gpc command
-      // Example: log command usage, validate prerequisites, etc.
-    });
-
-    hooks.afterCommand(async (event: CommandEvent, result: CommandResult) => {
-      // Called after every successful gpc command
-      // Example: send notifications, update dashboards, etc.
-    });
-
-    // Uncomment to add custom commands:
-    // hooks.registerCommands((registry) => {
-    //   registry.add({
-    //     name: "${shortName}",
-    //     description: "${description}",
-    //     action: async (args, opts) => {
-    //       console.log("Hello from ${pluginName}!");
-    //     },
-    //   });
-    // });
-  },
-});
-`;
-  await writeFile4(join5(srcDir, "index.ts"), srcContent);
-  files.push("src/index.ts");
-  const testContent = `import { describe, it, expect, vi } from "vitest";
-import { plugin } from "../src/index";
-
-describe("${pluginName}", () => {
-  it("has correct name and version", () => {
-    expect(plugin.name).toBe("${pluginName}");
-    expect(plugin.version).toBe("0.1.0");
-  });
-
-  it("registers without errors", () => {
-    const hooks = {
-      beforeCommand: vi.fn(),
-      afterCommand: vi.fn(),
-      onError: vi.fn(),
-      beforeRequest: vi.fn(),
-      afterResponse: vi.fn(),
-      registerCommands: vi.fn(),
-    };
+// src/commands/games.ts
+async function listLeaderboards(client, packageName) {
+  const result = await client.leaderboards.list(packageName);
+  return result.items ?? [];
+}
+async function listAchievements(client, packageName) {
+  const result = await client.achievements.list(packageName);
+  return result.items ?? [];
+}
+async function listEvents(client, packageName) {
+  const result = await client.events.list(packageName);
+  return result.items ?? [];
+}
 
-    expect(() => plugin.register(hooks)).not.toThrow();
-  });
-});
-`;
-  await writeFile4(join5(testDir, "plugin.test.ts"), testContent);
-  files.push("tests/plugin.test.ts");
-  return { dir, files };
+// src/commands/enterprise.ts
+async function listEnterpriseApps(client, organizationId) {
+  const result = await client.apps.list(organizationId);
+  return result.customApps ?? [];
+}
+async function createEnterpriseApp(client, organizationId, app) {
+  return client.apps.create(organizationId, app);
 }
 
 // src/audit.ts
-import { appendFile, chmod, mkdir as mkdir4, readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
+import { appendFile, chmod, mkdir as mkdir4, readFile as readFile9, writeFile as writeFile5 } from "fs/promises";
 import { join as join6 } from "path";
 var auditDir = null;
 function initAudit(configDir) {
@@ -3517,7 +4125,7 @@ async function listAuditEvents(options) {
   const logPath = join6(auditDir, "audit.log");
   let content;
   try {
-    content = await readFile8(logPath, "utf-8");
+    content = await readFile9(logPath, "utf-8");
   } catch {
     return [];
   }
@@ -3555,7 +4163,7 @@ async function clearAuditLog(options) {
   const logPath = join6(auditDir, "audit.log");
   let content;
   try {
-    content = await readFile8(logPath, "utf-8");
+    content = await readFile9(logPath, "utf-8");
   } catch {
     return { deleted: 0, remaining: 0 };
   }
@@ -3591,6 +4199,220 @@ async function clearAuditLog(options) {
   return { deleted: remove.length, remaining: keep.length };
 }
 
+// src/commands/quota.ts
+var DAILY_LIMIT = 2e5;
+var MINUTE_LIMIT = 3e3;
+async function getQuotaUsage() {
+  const now = Date.now();
+  const startOfDay = new Date(now);
+  startOfDay.setUTCHours(0, 0, 0, 0);
+  const startOfMinute = new Date(now - 60 * 1e3);
+  const todayEntries = await listAuditEvents({
+    since: startOfDay.toISOString()
+  });
+  const minuteEntries = todayEntries.filter(
+    (e) => new Date(e.timestamp).getTime() >= startOfMinute.getTime()
+  );
+  const commandCounts = /* @__PURE__ */ new Map();
+  for (const entry of todayEntries) {
+    commandCounts.set(entry.command, (commandCounts.get(entry.command) ?? 0) + 1);
+  }
+  const topCommands = Array.from(commandCounts.entries()).map(([command, count]) => ({ command, count })).sort((a, b) => b.count - a.count).slice(0, 10);
+  const dailyCallsUsed = todayEntries.length;
+  const minuteCallsUsed = minuteEntries.length;
+  return {
+    dailyCallsUsed,
+    dailyCallsLimit: DAILY_LIMIT,
+    dailyCallsRemaining: Math.max(0, DAILY_LIMIT - dailyCallsUsed),
+    minuteCallsUsed,
+    minuteCallsLimit: MINUTE_LIMIT,
+    minuteCallsRemaining: Math.max(0, MINUTE_LIMIT - minuteCallsUsed),
+    topCommands
+  };
+}
+
+// src/utils/safe-path.ts
+import { resolve, normalize } from "path";
+function safePath(userPath) {
+  return resolve(normalize(userPath));
+}
+function safePathWithin(userPath, baseDir) {
+  const resolved = safePath(userPath);
+  const base = safePath(baseDir);
+  if (!resolved.startsWith(base + "/") && resolved !== base) {
+    throw new GpcError(
+      `Path "${userPath}" resolves outside the expected directory "${baseDir}"`,
+      "PATH_TRAVERSAL",
+      2,
+      "The path must stay within the target directory. Remove any ../ segments or use an absolute path within the expected directory."
+    );
+  }
+  return resolved;
+}
+
+// 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 mkdir5, writeFile as writeFile6 } from "fs/promises";
+import { join as join7 } 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 = join7(dir, "src");
+  const testDir = join7(dir, "tests");
+  await mkdir5(srcDir, { recursive: true });
+  await mkdir5(testDir, { recursive: true });
+  const files = [];
+  const pkg = {
+    name: pluginName,
+    version: "0.1.0",
+    description,
+    type: "module",
+    main: "./dist/index.js",
+    types: "./dist/index.d.ts",
+    exports: {
+      ".": {
+        import: "./dist/index.js",
+        types: "./dist/index.d.ts"
+      }
+    },
+    files: ["dist"],
+    scripts: {
+      build: "tsup src/index.ts --format esm --dts",
+      dev: "tsup src/index.ts --format esm --dts --watch",
+      test: "vitest run",
+      "test:watch": "vitest"
+    },
+    keywords: ["gpc", "gpc-plugin", "google-play"],
+    license: "MIT",
+    peerDependencies: {
+      "@gpc-cli/plugin-sdk": ">=0.8.0"
+    },
+    devDependencies: {
+      "@gpc-cli/plugin-sdk": "^0.8.0",
+      tsup: "^8.0.0",
+      typescript: "^5.0.0",
+      vitest: "^3.0.0"
+    }
+  };
+  await writeFile6(join7(dir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
+  files.push("package.json");
+  const tsconfig = {
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      declaration: true,
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      outDir: "./dist",
+      rootDir: "./src"
+    },
+    include: ["src"]
+  };
+  await writeFile6(join7(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";
+
+export const plugin = definePlugin({
+  name: "${pluginName}",
+  version: "0.1.0",
+
+  register(hooks) {
+    hooks.beforeCommand(async (event: CommandEvent) => {
+      // Called before every gpc command
+      // Example: log command usage, validate prerequisites, etc.
+    });
+
+    hooks.afterCommand(async (event: CommandEvent, result: CommandResult) => {
+      // Called after every successful gpc command
+      // Example: send notifications, update dashboards, etc.
+    });
+
+    // Uncomment to add custom commands:
+    // hooks.registerCommands((registry) => {
+    //   registry.add({
+    //     name: "${shortName}",
+    //     description: "${description}",
+    //     action: async (args, opts) => {
+    //       console.log("Hello from ${pluginName}!");
+    //     },
+    //   });
+    // });
+  },
+});
+`;
+  await writeFile6(join7(srcDir, "index.ts"), srcContent);
+  files.push("src/index.ts");
+  const testContent = `import { describe, it, expect, vi } from "vitest";
+import { plugin } from "../src/index";
+
+describe("${pluginName}", () => {
+  it("has correct name and version", () => {
+    expect(plugin.name).toBe("${pluginName}");
+    expect(plugin.version).toBe("0.1.0");
+  });
+
+  it("registers without errors", () => {
+    const hooks = {
+      beforeCommand: vi.fn(),
+      afterCommand: vi.fn(),
+      onError: vi.fn(),
+      beforeRequest: vi.fn(),
+      afterResponse: vi.fn(),
+      registerCommands: vi.fn(),
+    };
+
+    expect(() => plugin.register(hooks)).not.toThrow();
+  });
+});
+`;
+  await writeFile6(join7(testDir, "plugin.test.ts"), testContent);
+  files.push("tests/plugin.test.ts");
+  return { dir, files };
+}
+
 // src/utils/webhooks.ts
 function formatSlackPayload(payload) {
   const status = payload.success ? "\u2713" : "\u2717";
@@ -3736,7 +4558,7 @@ function detectFileType(filePath) {
 }
 
 // src/commands/generated-apks.ts
-import { writeFile as writeFile6 } from "fs/promises";
+import { writeFile as writeFile7 } from "fs/promises";
 async function listGeneratedApks(client, packageName, versionCode) {
   if (!Number.isInteger(versionCode) || versionCode <= 0) {
     throw new GpcError(
@@ -3767,7 +4589,7 @@ async function downloadGeneratedApk(client, packageName, versionCode, apkId, out
   }
   const buffer = await client.generatedApks.download(packageName, versionCode, apkId);
   const bytes = new Uint8Array(buffer);
-  await writeFile6(outputPath, bytes);
+  await writeFile7(outputPath, bytes);
   return { path: outputPath, sizeBytes: bytes.byteLength };
 }
 
@@ -3834,7 +4656,7 @@ async function deactivatePurchaseOption(client, packageName, purchaseOptionId) {
 }
 
 // src/commands/bundle-analysis.ts
-import { readFile as readFile9, stat as stat7 } from "fs/promises";
+import { readFile as readFile10, stat as stat7 } 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"]);
@@ -3912,7 +4734,7 @@ async function analyzeBundle(filePath) {
   if (!fileInfo || !fileInfo.isFile()) {
     throw new Error(`File not found: ${filePath}`);
   }
-  const buf = await readFile9(filePath);
+  const buf = await readFile10(filePath);
   const cdEntries = parseCentralDirectory(buf);
   const fileType = detectFileType2(filePath);
   const isAab = fileType === "aab";
@@ -3984,19 +4806,52 @@ function compareBundles(before, after) {
     categoryDeltas
   };
 }
+function topFiles(analysis, n = 20) {
+  return [...analysis.entries].sort((a, b) => b.compressedSize - a.compressedSize).slice(0, n);
+}
+async function checkBundleSize(analysis, configPath = ".bundlesize.json") {
+  let config;
+  try {
+    const raw = await readFile10(configPath, "utf-8");
+    config = JSON.parse(raw);
+  } catch {
+    return { passed: true, violations: [] };
+  }
+  const violations = [];
+  if (config.maxTotalCompressed !== void 0 && analysis.totalCompressed > config.maxTotalCompressed) {
+    violations.push({
+      subject: "total",
+      actual: analysis.totalCompressed,
+      max: config.maxTotalCompressed
+    });
+  }
+  if (config.modules) {
+    for (const [moduleName, threshold] of Object.entries(config.modules)) {
+      const mod = analysis.modules.find((m) => m.name === moduleName);
+      if (mod && mod.compressedSize > threshold.maxCompressed) {
+        violations.push({
+          subject: `module:${moduleName}`,
+          actual: mod.compressedSize,
+          max: threshold.maxCompressed
+        });
+      }
+    }
+  }
+  return { passed: violations.length === 0, violations };
+}
 
 // src/commands/status.ts
-import { mkdir as mkdir5, readFile as readFile10, writeFile as writeFile7 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile11, writeFile as writeFile8 } from "fs/promises";
 import { execSync } from "child_process";
-import { join as join7 } from "path";
-import { getCacheDir } from "@gpc-cli/config";
+import { join as join8 } from "path";
+import { getCacheDir as getCacheDir2 } from "@gpc-cli/config";
 var DEFAULT_TTL_SECONDS = 3600;
 function cacheFilePath(packageName) {
-  return join7(getCacheDir(), `status-${packageName}.json`);
+  return join8(getCacheDir2(), `status-${packageName}.json`);
 }
 async function loadStatusCache(packageName, ttlSeconds = DEFAULT_TTL_SECONDS) {
   try {
-    const raw = await readFile10(cacheFilePath(packageName), "utf-8");
+    const raw = await readFile11(cacheFilePath(packageName), "utf-8");
     const entry = JSON.parse(raw);
     const age = (Date.now() - new Date(entry.fetchedAt).getTime()) / 1e3;
     if (age > (entry.ttl ?? ttlSeconds)) return null;
@@ -4012,10 +4867,10 @@ async function loadStatusCache(packageName, ttlSeconds = DEFAULT_TTL_SECONDS) {
 }
 async function saveStatusCache(packageName, data, ttlSeconds = DEFAULT_TTL_SECONDS) {
   try {
-    const dir = getCacheDir();
-    await mkdir5(dir, { recursive: true });
+    const dir = getCacheDir2();
+    await mkdir6(dir, { recursive: true });
     const entry = { fetchedAt: data.fetchedAt, ttl: ttlSeconds, data };
-    await writeFile7(cacheFilePath(packageName), JSON.stringify(entry, null, 2), {
+    await writeFile8(cacheFilePath(packageName), JSON.stringify(entry, null, 2), {
       encoding: "utf-8",
       mode: 384
     });
@@ -4380,20 +5235,20 @@ async function runWatchLoop(opts) {
   }
 }
 function breachStateFilePath(packageName) {
-  return join7(getCacheDir(), `breach-state-${packageName}.json`);
+  return join8(getCacheDir2(), `breach-state-${packageName}.json`);
 }
 async function trackBreachState(packageName, isBreaching) {
   const filePath = breachStateFilePath(packageName);
   let prevBreaching = false;
   try {
-    const raw = await readFile10(filePath, "utf-8");
+    const raw = await readFile11(filePath, "utf-8");
     prevBreaching = JSON.parse(raw).breaching;
   } catch {
   }
   if (prevBreaching !== isBreaching) {
     try {
-      await mkdir5(getCacheDir(), { recursive: true });
-      await writeFile7(
+      await mkdir6(getCacheDir2(), { recursive: true });
+      await writeFile8(
         filePath,
         JSON.stringify({ breaching: isBreaching, since: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
         { encoding: "utf-8", mode: 384 }
@@ -4433,6 +5288,7 @@ function statusHasBreach(status) {
 export {
   ApiError,
   ConfigError,
+  DEFAULT_LIMITS,
   GOOGLE_PLAY_LANGUAGES,
   GpcError,
   NetworkError,
@@ -4440,26 +5296,34 @@ export {
   PluginManager,
   SENSITIVE_ARG_KEYS,
   SENSITIVE_KEYS,
+  abortTrain,
   acknowledgeProductPurchase,
   activateBasePlan,
   activateOffer,
   activatePurchaseOption,
   addRecoveryTargeting,
   addTesters,
+  advanceTrain,
   analyzeBundle,
+  analyzeRemoteListings,
+  analyzeReviews2 as analyzeReviews,
   batchSyncInAppProducts,
   cancelRecoveryAction,
   cancelSubscriptionPurchase,
+  checkBundleSize,
   checkThreshold,
   clearAuditLog,
   compareBundles,
+  compareVersionVitals,
   compareVitalsTrend,
   computeStatusDiff,
   consumeProductPurchase,
   convertRegionPrices,
   createAuditEntry,
   createDeviceTier,
+  createEnterpriseApp,
   createExternalTransaction,
+  createGrant,
   createInAppProduct,
   createOffer,
   createOneTimeOffer,
@@ -4474,6 +5338,7 @@ export {
   deactivatePurchaseOption,
   deferSubscriptionPurchase,
   deleteBasePlan,
+  deleteGrant,
   deleteImage,
   deleteInAppProduct,
   deleteListing,
@@ -4486,6 +5351,7 @@ export {
   detectOutputFormat,
   diffListings,
   diffListingsCommand,
+  diffListingsEnhanced,
   diffOneTimeProduct,
   diffReleases,
   diffSubscription,
@@ -4503,6 +5369,7 @@ export {
   formatStatusDiff,
   formatStatusSummary,
   formatStatusTable,
+  formatWordDiff,
   generateMigrationPlan,
   generateNotesFromGit,
   getAppInfo,
@@ -4518,15 +5385,19 @@ export {
   getOneTimeProduct,
   getProductPurchase,
   getPurchaseOption,
+  getQuotaUsage,
   getReleasesStatus,
   getReview,
   getSubscription,
+  getSubscriptionAnalytics,
   getSubscriptionPurchase,
+  getTrainStatus,
   getUser,
   getVitalsAnomalies,
   getVitalsAnr,
   getVitalsBattery,
   getVitalsCrashes,
+  getVitalsLmk,
   getVitalsMemory,
   getVitalsOverview,
   getVitalsRendering,
@@ -4540,11 +5411,19 @@ export {
   isValidBcp47,
   isValidReportType,
   isValidStatsDimension,
+  lintListing,
+  lintListings,
+  lintLocalListings,
+  listAchievements,
   listAuditEvents,
   listDeviceTiers,
+  listEnterpriseApps,
+  listEvents,
   listGeneratedApks,
+  listGrants,
   listImages,
   listInAppProducts,
+  listLeaderboards,
   listOffers,
   listOneTimeOffers,
   listOneTimeProducts,
@@ -4558,11 +5437,13 @@ export {
   listUsers,
   listVoidedPurchases,
   loadStatusCache,
+  maybePaginate,
   migratePrices,
   parseAppfile,
   parseFastfile,
   parseGrantArg,
   parseMonth,
+  pauseTrain,
   promoteRelease,
   publish,
   pullListings,
@@ -4573,6 +5454,7 @@ export {
   redactSensitive,
   refundExternalTransaction,
   refundOrder,
+  refundSubscriptionV2,
   removeTesters,
   removeUser,
   replyToReview,
@@ -4587,11 +5469,14 @@ export {
   sendNotification,
   sendWebhook,
   sortResults,
+  startTrain,
   statusHasBreach,
   syncInAppProducts,
+  topFiles,
   trackBreachState,
   updateAppDetails,
   updateDataSafety,
+  updateGrant,
   updateInAppProduct,
   updateListing,
   updateOffer,
@@ -4614,6 +5499,8 @@ export {
   validateTrackName,
   validateUploadFile,
   validateVersionCode,
+  watchVitalsWithAutoHalt,
+  wordDiff,
   writeAuditLog,
   writeListingsToDir,
   writeMigrationOutput