@gpc-cli/core 0.10.4 → 0.10.6

package/dist/index.js

@@ -2315,28 +2315,18 @@ function reviewsToCsv(reviews) {
     const uc = r.comments?.[0]?.userComment;
     const fields = [
       r.reviewId,
-      csvEscape(r.authorName),
+      escapeCsvField(r.authorName),
       uc?.starRating ?? "",
-      csvEscape(uc?.text ?? ""),
+      escapeCsvField(uc?.text ?? ""),
       uc?.reviewerLanguage ?? "",
       uc ? new Date(Number(uc.lastModified.seconds) * 1e3).toISOString() : "",
-      csvEscape(uc?.device ?? ""),
-      csvEscape(uc?.appVersionName ?? "")
+      escapeCsvField(uc?.device ?? ""),
+      escapeCsvField(uc?.appVersionName ?? "")
     ];
     return fields.join(",");
   });
   return [header, ...rows].join("\n");
 }
-function csvEscape(value) {
-  let safe = value;
-  if (/^[=+\-@\t\r]/.test(safe)) {
-    safe = `'${safe}`;
-  }
-  if (safe.includes(",") || safe.includes('"') || safe.includes("\n")) {
-    return `"${safe.replace(/"/g, '""')}"`;
-  }
-  return safe;
-}
 async function analyzeReviews2(client, packageName, options) {
   const { reviews } = await listReviews(client, packageName, options);
   const items = reviews.map((r) => {
@@ -4151,6 +4141,7 @@ function reportObjectNotFoundError(opts) {
 var GCS_API_BASE = "https://storage.googleapis.com/storage/v1/b";
 var LIST_TIMEOUT_MS = 6e4;
 var DOWNLOAD_TIMEOUT_MS = 12e4;
+var MAX_DOWNLOAD_BYTES = 512 * 1024 * 1024;
 function networkError(bucket, cause) {
   const detail = cause instanceof Error ? cause.message : String(cause);
   return new GpcError(
@@ -4160,6 +4151,14 @@ function networkError(bucket, cause) {
     "Check your internet connection and retry. Google Cloud Storage may also be briefly unavailable."
   );
 }
+function tooLargeError(objectName, maxBytes) {
+  return new GpcError(
+    `Report object "${objectName}" is larger than the ${maxBytes}-byte download limit.`,
+    "REPORT_DOWNLOAD_FAILED",
+    4,
+    "Play bulk reports are far smaller than this; confirm the bucket and object name, then download the file from Play Console -> Download reports if you really need it."
+  );
+}
 function maxRetries() {
   const parsed = Number(process.env["GPC_MAX_RETRIES"]);
   return Number.isInteger(parsed) && parsed >= 0 && parsed <= 10 ? parsed : 3;
@@ -4226,7 +4225,8 @@ async function listReportObjects(auth, bucket, options) {
   }));
   return { objects, nextPageToken: body.nextPageToken };
 }
-async function downloadReportObject(auth, bucket, objectName) {
+async function downloadReportObject(auth, bucket, objectName, options = {}) {
+  const maxBytes = options.maxBytes ?? MAX_DOWNLOAD_BYTES;
   const url = `${GCS_API_BASE}/${encodeURIComponent(bucket)}/o/${encodeURIComponent(objectName)}?alt=media`;
   const res = await gcsFetch(auth, bucket, url, DOWNLOAD_TIMEOUT_MS);
   if (res.status === 404) {
@@ -4245,11 +4245,25 @@ async function downloadReportObject(auth, bucket, objectName) {
       "Retry in a moment. If the error persists, list the reports to confirm the object still exists."
     );
   }
+  const declared = Number(res.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > maxBytes) {
+    throw tooLargeError(objectName, maxBytes);
+  }
+  const body = res.body;
+  if (!body) return Buffer.alloc(0);
+  const chunks = [];
+  let read = 0;
   try {
-    return Buffer.from(await res.arrayBuffer());
+    for await (const chunk of body) {
+      read += chunk.length;
+      if (read > maxBytes) throw tooLargeError(objectName, maxBytes);
+      chunks.push(Buffer.from(chunk));
+    }
   } catch (err) {
+    if (err instanceof GpcError) throw err;
     throw networkError(bucket, err);
   }
+  return Buffer.concat(chunks);
 }
 
 // src/reports/decode.ts
@@ -4285,13 +4299,15 @@ function decodeStatsCsv(buf) {
   return decodeCsvText(gunzipIfNeeded(buf));
 }
 var ZIP_READ_TIMEOUT_MS = 3e4;
-function extractCsvEntriesFromZip(buffer) {
+var MAX_CSV_ENTRIES = 64;
+function extractCsvEntriesFromZip(buffer, options = {}) {
+  const maxEntryBytes = options.maxEntryBytes ?? MAX_INFLATED_BYTES;
+  const maxTotalBytes = options.maxTotalBytes ?? MAX_INFLATED_BYTES;
   return new Promise((resolve2, reject) => {
     let settled = false;
     const timer = setTimeout(() => {
       settleReject(new Error("Timed out reading report archive"));
     }, ZIP_READ_TIMEOUT_MS);
-    timer.unref?.();
     function settleResolve(v) {
       if (settled) return;
       settled = true;
@@ -4314,6 +4330,8 @@ function extractCsvEntriesFromZip(buffer) {
         const entries = [];
         let pending = 0;
         let entriesDone = false;
+        let csvEntries = 0;
+        let totalBytes = 0;
         function fail(e) {
           try {
             zipfile.close();
@@ -4329,6 +4347,10 @@ function extractCsvEntriesFromZip(buffer) {
             zipfile.readEntry();
             return;
           }
+          if (++csvEntries > MAX_CSV_ENTRIES) {
+            fail(new Error(`Report archive holds more than ${MAX_CSV_ENTRIES} CSV entries`));
+            return;
+          }
           pending++;
           zipfile.openReadStream(entry, (streamErr, stream) => {
             if (streamErr || !stream) {
@@ -4336,10 +4358,35 @@ function extractCsvEntriesFromZip(buffer) {
               return;
             }
             const chunks = [];
-            stream.on("data", (c) => chunks.push(c));
+            let read = 0;
+            stream.on("data", (c) => {
+              read += c.length;
+              if (read > maxEntryBytes) {
+                stream.destroy();
+                fail(
+                  new Error(
+                    `Entry "${entry.fileName}" exceeds the ${maxEntryBytes}-byte limit for a report CSV`
+                  )
+                );
+                return;
+              }
+              chunks.push(c);
+            });
             stream.on("error", fail);
             stream.on("end", () => {
-              entries.push({ name: entry.fileName, text: decodeStatsCsv(Buffer.concat(chunks)) });
+              let text;
+              try {
+                text = decodeStatsCsv(Buffer.concat(chunks));
+              } catch (e) {
+                fail(e instanceof Error ? e : new Error(String(e)));
+                return;
+              }
+              totalBytes += text.length;
+              if (totalBytes > maxTotalBytes) {
+                fail(new Error(`Report archive exceeds the ${maxTotalBytes}-byte total limit`));
+                return;
+              }
+              entries.push({ name: entry.fileName, text });
               pending--;
               zipfile.readEntry();
               maybeResolve();
@@ -4880,6 +4927,88 @@ async function getExternalTransaction(client, packageName, transactionId) {
 async function refundExternalTransaction(client, packageName, transactionId, refundData) {
   return client.externalTransactions.refund(packageName, transactionId, refundData);
 }
+var RFC3339_RE = /^(\d{4}-\d{2}-\d{2})T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/i;
+var MAX_INT64 = 2n ** 63n - 1n;
+var FUTURE_SKEW_MS = 5 * 60 * 1e3;
+function refundUsageError(message, suggestion) {
+  return new GpcError(message, "EXT_TXN_REFUND_INVALID", 2, suggestion);
+}
+function buildExternalTransactionRefund(options, now = /* @__PURE__ */ new Date()) {
+  const partialAmount = options.partialAmount?.trim();
+  const currency = options.currency?.trim();
+  const refundId = options.refundId?.trim();
+  if (options.full && partialAmount) {
+    throw refundUsageError(
+      "Use --full or --partial-amount, not both",
+      "Pass --full to refund the whole transaction, or --partial-amount for part of it."
+    );
+  }
+  if (!options.full && !partialAmount) {
+    throw refundUsageError(
+      "Choose the refund type with --full or --partial-amount",
+      "Pass --full, or --partial-amount <micros> --currency <code> --refund-id <id>."
+    );
+  }
+  let refundTime = now.toISOString();
+  if (options.refundTime !== void 0) {
+    const raw = options.refundTime.trim();
+    const match = RFC3339_RE.exec(raw);
+    const parsed = new Date(raw);
+    const offsetMs = parsed.getTime() - Date.parse(raw.replace(/(?:Z|[+-]\d{2}:\d{2})$/i, "Z"));
+    const calendarDate = match ? new Date(parsed.getTime() - offsetMs).toISOString().slice(0, 10) : void 0;
+    if (!match || Number.isNaN(parsed.getTime()) || calendarDate !== match[1]) {
+      throw refundUsageError(
+        `Invalid --refund-time "${options.refundTime}"`,
+        "Use an RFC 3339 timestamp with a timezone, for example 2026-09-25T12:00:00Z or 2026-09-25T14:00:00+02:00."
+      );
+    }
+    if (parsed.getTime() > now.getTime() + FUTURE_SKEW_MS) {
+      throw refundUsageError(
+        `--refund-time "${options.refundTime}" is in the future`,
+        "Give the time the refund actually happened, or omit --refund-time to use now."
+      );
+    }
+    refundTime = parsed.toISOString();
+  }
+  if (options.full) {
+    if (currency || refundId) {
+      throw refundUsageError(
+        "--currency and --refund-id only apply to --partial-amount",
+        "Remove them for a full refund, or use --partial-amount instead of --full."
+      );
+    }
+    return { refundTime, fullRefund: {} };
+  }
+  if (!partialAmount || !/^\d{1,19}$/.test(partialAmount) || BigInt(partialAmount) <= 0n || BigInt(partialAmount) > MAX_INT64) {
+    throw refundUsageError(
+      `Invalid --partial-amount "${options.partialAmount}"`,
+      "Give the pre-tax amount in micros as a positive whole number, for example 1990000 for 1.99."
+    );
+  }
+  if (!currency || !/^[A-Za-z]{3}$/.test(currency)) {
+    throw refundUsageError(
+      currency ? `Invalid --currency "${currency}"` : "--currency is required with --partial-amount",
+      "Use the transaction's ISO 4217 currency code, for example USD."
+    );
+  }
+  if (!refundId) {
+    throw refundUsageError(
+      "--refund-id is required with --partial-amount",
+      "Give each partial refund a unique ID; Google rejects a second refund with the same ID."
+    );
+  }
+  return {
+    refundTime,
+    partialRefund: {
+      refundId,
+      // Normalized, so "007" is sent as "7".
+      refundPreTaxAmount: {
+        priceMicros: BigInt(partialAmount).toString(),
+        currency: currency.toUpperCase()
+      }
+    }
+  };
+}
 
 // src/commands/device-tiers.ts
 async function listDeviceTiers(client, packageName) {
@@ -5376,11 +5505,11 @@ async function getAchievementConfig(client, achievementId) {
 }
 async function createAchievementConfig(client, applicationId, data) {
   validateApplicationId(applicationId);
-  return client.achievements.insert(applicationId, data);
+  return client.achievements.insert(applicationId, withoutRedactedToken(data));
 }
 async function updateAchievementConfig(client, achievementId, data) {
   validateResourceId(achievementId, "achievement");
-  return client.achievements.update(achievementId, data);
+  return client.achievements.update(achievementId, withoutRedactedToken(data));
 }
 async function deleteAchievementConfig(client, achievementId) {
   validateResourceId(achievementId, "achievement");
@@ -5412,11 +5541,11 @@ async function getLeaderboardConfig(client, leaderboardId) {
 }
 async function createLeaderboardConfig(client, applicationId, data) {
   validateApplicationId(applicationId);
-  return client.leaderboards.insert(applicationId, data);
+  return client.leaderboards.insert(applicationId, withoutRedactedToken(data));
 }
 async function updateLeaderboardConfig(client, leaderboardId, data) {
   validateResourceId(leaderboardId, "leaderboard");
-  return client.leaderboards.update(leaderboardId, data);
+  return client.leaderboards.update(leaderboardId, withoutRedactedToken(data));
 }
 async function deleteLeaderboardConfig(client, leaderboardId) {
   validateResourceId(leaderboardId, "leaderboard");
@@ -5474,6 +5603,11 @@ async function setLeaderboardIcon(client, leaderboardId, filePath) {
     iconContentType(filePath)
   );
 }
+function withoutRedactedToken(config) {
+  if (config.token !== REDACTED) return config;
+  const { token: _token, ...rest } = config;
+  return rest;
+}
 function safeConfigFilename(id) {
   return `${id.replace(/[^a-zA-Z0-9_-]/g, "_")}.json`;
 }
@@ -5501,7 +5635,7 @@ async function readConfigDir(dir) {
         "Each file must contain a single achievement or leaderboard config object."
       );
     }
-    out.push({ file, config: parsed });
+    out.push({ file, config: withoutRedactedToken(parsed) });
   }
   return out;
 }
@@ -5832,7 +5966,7 @@ async function initProject(options) {
     {
       failOn: "error",
       targetSdkMinimum: 36,
-      maxDownloadSizeMb: 150,
+      maxDownloadSizeMb: 200,
       allowedPermissions: [],
       disabledRules: [],
       severityOverrides: {}
@@ -5950,7 +6084,7 @@ var SEVERITY_ORDER = {
 var DEFAULT_PREFLIGHT_CONFIG = {
   failOn: "error",
   targetSdkMinimum: 36,
-  maxDownloadSizeMb: 150,
+  maxDownloadSizeMb: 200,
   allowedPermissions: [],
   disabledRules: [],
   severityOverrides: {}
@@ -6083,13 +6217,23 @@ function getSchema() {
   return cachedSchema;
 }
 function decodeManifest(buf) {
+  return extractManifestData(decodeManifestElement(buf));
+}
+function isInstallTimeModule(buf) {
+  const module = getChildren(decodeManifestElement(buf), "module")[0];
+  if (!module) return true;
+  const delivery = getChildren(module, "delivery")[0];
+  if (delivery) return getChildren(delivery, "install-time").length > 0;
+  return !getBoolByName(module.attribute || [], "onDemand", false);
+}
+function decodeManifestElement(buf) {
   const root = getSchema();
   const XmlNode = root.lookupType("aapt.pb.XmlNode");
   const decoded = XmlNode.decode(buf);
   if (!decoded.element || decoded.element.name !== "manifest") {
     throw new Error("Invalid AAB manifest: root element is not <manifest>");
   }
-  return extractManifestData(decoded.element);
+  return decoded.element;
 }
 function getAttrByName(attrs, name) {
   const attr = attrs.find((a) => a.name === name || RESOURCE_IDS[a.resourceId] === name);
@@ -6198,6 +6342,10 @@ 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 MODULE_MANIFEST_RE = /^([^/]+)\/manifest\/AndroidManifest\.xml$/;
+var MAX_MODULE_MANIFEST_BYTES = 1024 * 1024;
+var MAX_MODULE_MANIFESTS = 256;
+var MAX_SO_HEADER_READS = 512;
 var SCAN_TIMEOUT_MS = 6e4;
 function detectManifestPath(filePath) {
   return filePath.toLowerCase().endsWith(".apk") ? APK_MANIFEST_PATH : AAB_MANIFEST_PATH;
@@ -6211,7 +6359,10 @@ async function readAab(aabPath) {
     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);
+  const { zipfile, entries, manifestBuf, soHeaders, moduleManifests } = await openAndScan(
+    buffer,
+    manifestPath
+  );
   zipfile.close();
   if (!manifestBuf) {
     const fileType = aabPath.toLowerCase().endsWith(".apk") ? "APK" : "AAB";
@@ -6227,7 +6378,20 @@ async function readAab(aabPath) {
     manifest = createFallbackManifest();
     manifest._parseError = `Manifest could not be fully parsed: ${errMsg}. Manifest-dependent checks will be skipped.`;
   }
-  return { manifest, entries, nativeLibHeaders: soHeaders };
+  const deferredModules = [...moduleManifests].filter(([, buf]) => {
+    try {
+      return !isInstallTimeModule(buf);
+    } catch {
+      return false;
+    }
+  }).map(([name]) => name);
+  return {
+    manifest,
+    entries,
+    nativeLibHeaders: soHeaders,
+    isAppBundle: manifestPath === AAB_MANIFEST_PATH,
+    deferredModules
+  };
 }
 function createFallbackManifest() {
   return {
@@ -6277,6 +6441,9 @@ function openAndScan(buffer, manifestPath = AAB_MANIFEST_PATH) {
         }
         const entries = [];
         const soHeaders = /* @__PURE__ */ new Map();
+        const moduleManifests = /* @__PURE__ */ new Map();
+        let moduleManifestReads = 0;
+        let soHeaderReads = 0;
         let manifestBuf = null;
         let pendingStreams = 0;
         let entrysDone = false;
@@ -6290,19 +6457,34 @@ function openAndScan(buffer, manifestPath = AAB_MANIFEST_PATH) {
         }
         function maybeResolve() {
           if (!settled && entrysDone && pendingStreams === 0) {
-            settleResolve({ zipfile, entries, manifestBuf, soHeaders });
+            settleResolve({ zipfile, entries, manifestBuf, soHeaders, moduleManifests });
           }
         }
-        function readEntryStream(entry, onData, maxBytes) {
+        function advance() {
+          if (settled) return;
+          zipfile.readEntry();
+        }
+        function readEntryStream(entry, onData, maxBytes, optional = false) {
           pendingStreams++;
+          let done = false;
+          const onError = (e) => {
+            if (!optional) {
+              fail(e);
+              return;
+            }
+            if (done) return;
+            done = true;
+            pendingStreams--;
+            advance();
+            maybeResolve();
+          };
           zipfile.openReadStream(entry, (streamErr, stream) => {
             if (streamErr || !stream) {
-              fail(streamErr ?? new Error(`Failed to read ${entry.fileName}`));
+              onError(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;
@@ -6312,7 +6494,7 @@ function openAndScan(buffer, manifestPath = AAB_MANIFEST_PATH) {
             });
             stream.on("error", (e) => {
               if (maxBytes && totalBytes >= maxBytes) return;
-              fail(e);
+              onError(e);
             });
             const finish = () => {
               if (done) return;
@@ -6320,6 +6502,7 @@ function openAndScan(buffer, manifestPath = AAB_MANIFEST_PATH) {
               const buf = Buffer.concat(chunks);
               onData(maxBytes ? buf.subarray(0, maxBytes) : buf);
               pendingStreams--;
+              advance();
               maybeResolve();
             };
             stream.on("end", finish);
@@ -6340,11 +6523,24 @@ function openAndScan(buffer, manifestPath = AAB_MANIFEST_PATH) {
                 uncompressedSize: entry.uncompressedSize
               });
             }
+            const moduleName = manifestPath === AAB_MANIFEST_PATH ? MODULE_MANIFEST_RE.exec(path)?.[1] : void 0;
+            const readModuleManifest = moduleName !== void 0 && entry.uncompressedSize <= MAX_MODULE_MANIFEST_BYTES && moduleManifestReads < MAX_MODULE_MANIFESTS;
             if (path === manifestPath) {
               readEntryStream(entry, (buf) => {
                 manifestBuf = buf;
               });
-            } else if (SO_PATH_RE.test(path)) {
+            } else if (moduleName !== void 0 && readModuleManifest) {
+              moduleManifestReads++;
+              readEntryStream(
+                entry,
+                (buf) => {
+                  moduleManifests.set(moduleName, buf);
+                },
+                MAX_MODULE_MANIFEST_BYTES,
+                true
+              );
+            } else if (SO_PATH_RE.test(path) && soHeaderReads < MAX_SO_HEADER_READS) {
+              soHeaderReads++;
               readEntryStream(
                 entry,
                 (buf) => {
@@ -6352,8 +6548,9 @@ function openAndScan(buffer, manifestPath = AAB_MANIFEST_PATH) {
                 },
                 SO_HEADER_BYTES
               );
+            } else {
+              advance();
             }
-            zipfile.readEntry();
           } catch (e) {
             fail(e instanceof Error ? e : new Error(String(e)));
           }
@@ -6457,20 +6654,18 @@ var manifestScanner = {
     }
     if (manifest.targetSdk >= 34) {
       const hasFgsPerm = manifest.permissions.includes("android.permission.FOREGROUND_SERVICE");
-      if (hasFgsPerm) {
-        for (const service of manifest.services) {
-          if (!service.foregroundServiceType) {
-            findings.push({
-              scanner: "manifest",
-              ruleId: "foreground-service-type-missing",
-              severity: "error",
-              title: `Missing foregroundServiceType on ${service.name}`,
-              message: `Service "${service.name}" does not declare android:foregroundServiceType. This is required for apps targeting API 34+.`,
-              suggestion: `Add android:foregroundServiceType to the <service> declaration. Valid types: camera, connectedDevice, dataSync, health, location, mediaPlayback, mediaProcessing, mediaProjection, microphone, phoneCall, remoteMessaging, shortService, specialUse, systemExempted.`,
-              policyUrl: "https://developer.android.com/about/versions/14/changes/fgs-types-required"
-            });
-          }
-        }
+      const anyTyped = manifest.services.some((s) => s.foregroundServiceType);
+      if (hasFgsPerm && !anyTyped && manifest.services.length > 0) {
+        const typedPerms = manifest.permissions.filter((p) => p.startsWith("android.permission.FOREGROUND_SERVICE_")).map((p) => p.replace("android.permission.", ""));
+        findings.push({
+          scanner: "manifest",
+          ruleId: "foreground-service-type-missing",
+          severity: "warning",
+          title: "No service declares a foregroundServiceType",
+          message: `The app requests FOREGROUND_SERVICE${typedPerms.length > 0 ? ` (and ${typedPerms.join(", ")})` : ""} but none of its ${manifest.services.length} services declares android:foregroundServiceType. On API 34+, any service that calls startForeground() must declare a type or it crashes at runtime. Services that never run in the foreground do not need one.`,
+          suggestion: 'Add android:foregroundServiceType to each service you start in the foreground (for example dataSync, mediaPlayback, location). If none do, remove the FOREGROUND_SERVICE permission or add this rule to "disabledRules".',
+          policyUrl: "https://developer.android.com/about/versions/14/changes/fgs-types-required"
+        });
       }
     }
     const hasBackgroundLocation = manifest.permissions.includes(
@@ -6788,9 +6983,36 @@ var permissionsScanner = {
   }
 };
 
+// src/preflight/bundle-layout.ts
+var LIB_PATH_RE = /^(?:[^/]+\/)?lib\/([^/]+)\/[^/]+\.so$/;
+function isBundleMetadata(path) {
+  return path.startsWith("BUNDLE-METADATA/") || path.startsWith("META-INF/") || path === "BundleConfig.pb";
+}
+function nativeLibAbi(path) {
+  return LIB_PATH_RE.exec(path)?.[1];
+}
+function firstInstallEntries(entries, isAppBundle, deferredModules = []) {
+  if (!isAppBundle) return [...entries];
+  const deferred = new Set(deferredModules);
+  return entries.filter(
+    (e) => !isBundleMetadata(e.path) && !deferred.has(e.path.split("/", 1)[0] ?? "")
+  );
+}
+function largestAbi(entries, size) {
+  const perAbi = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const abi = nativeLibAbi(entry.path);
+    if (abi) perAbi.set(abi, (perAbi.get(abi) ?? 0) + size(entry));
+  }
+  let largest;
+  for (const [abi, bytes] of perAbi) {
+    if (!largest || bytes > largest.bytes) largest = { abi, bytes };
+  }
+  return largest;
+}
+
 // src/preflight/scanners/native-libs-scanner.ts
 var KNOWN_ABIS = ["arm64-v8a", "armeabi-v7a", "x86", "x86_64"];
-var LIB_PATH_RE = /^(?:[^/]+\/)?lib\/([^/]+)\/[^/]+\.so$/;
 var ELF_MAGIC = 2135247942;
 var PT_LOAD = 1;
 var PAGE_16KB = 16384;
@@ -6848,7 +7070,7 @@ var nativeLibsScanner = {
     const abisFound = /* @__PURE__ */ new Set();
     let totalNativeSize = 0;
     for (const entry of entries) {
-      const abi = LIB_PATH_RE.exec(entry.path)?.[1];
+      const abi = nativeLibAbi(entry.path);
       if (abi) {
         abisFound.add(abi);
         totalNativeSize += entry.uncompressedSize;
@@ -6884,6 +7106,20 @@ var nativeLibsScanner = {
       });
     }
     check16KBAlignment(ctx.nativeLibHeaders, ctx.manifest, findings);
+    if (ctx.nativeLibHeaders) {
+      const soCount = entries.filter((e) => nativeLibAbi(e.path) && e.path.endsWith(".so")).length;
+      const unchecked = soCount - ctx.nativeLibHeaders.size;
+      if (unchecked > 0) {
+        findings.push({
+          scanner: "native-libs",
+          ruleId: "native-libs-16kb-unchecked",
+          severity: "warning",
+          title: `${unchecked} of ${soCount} native libraries not checked for 16KB alignment`,
+          message: `Preflight checked the first ${ctx.nativeLibHeaders.size} native libraries in this bundle; the remaining ${unchecked} were not inspected, so a misaligned library among them would not be reported.`,
+          suggestion: "Verify alignment of the full bundle with Android Studio's APK Analyzer or `zipalign -c -P 16 -v 4 app.apk` on a universal APK."
+        });
+      }
+    }
     const detectedAbis = KNOWN_ABIS.filter((abi) => abisFound.has(abi));
     const unknownAbis = [...abisFound].filter(
       (abi) => !KNOWN_ABIS.includes(abi)
@@ -6897,14 +7133,21 @@ var nativeLibsScanner = {
       title: `Native libraries: ${abiList}`,
       message: `Found native libraries for ${abisFound.size} architecture(s): ${abiList}. Total uncompressed size: ${sizeMb} MB.`
     });
-    if (totalNativeSize > 150 * 1024 * 1024) {
+    const bundle = ctx.isAppBundle ?? false;
+    const perDevice = bundle ? largestAbi(
+      firstInstallEntries(entries, true, ctx.deferredModules),
+      (e) => e.uncompressedSize
+    ) : void 0;
+    const perDeviceSize = bundle ? perDevice?.bytes ?? 0 : totalNativeSize;
+    if (perDeviceSize > 150 * 1024 * 1024) {
+      const perDeviceMb = (perDeviceSize / (1024 * 1024)).toFixed(1);
       findings.push({
         scanner: "native-libs",
         ruleId: "native-libs-large",
         severity: "warning",
         title: "Large native libraries",
-        message: `Native libraries total ${sizeMb} MB (uncompressed). This significantly increases download size.`,
-        suggestion: "Consider using Android App Bundles to deliver only the required ABI per device. Review if all native libraries are necessary."
+        message: perDevice ? `Native libraries for ${perDevice.abi} total ${perDeviceMb} MB (uncompressed). Each device on that ABI downloads all of them.` : `Native libraries total ${sizeMb} MB (uncompressed). This significantly increases download size.`,
+        suggestion: perDevice ? "Review whether all native libraries are necessary, and move optional native code into on-demand feature modules." : "Consider using Android App Bundles to deliver only the required ABI per device. Review if all native libraries are necessary."
       });
     }
     return findings;
@@ -7559,6 +7802,9 @@ var policyScanner = {
 };
 
 // src/preflight/scanners/size-scanner.ts
+var MB = 1024 * 1024;
+var PLAY_MOBILE_DATA_DIALOG_MB = 200;
+var mb = (bytes) => (bytes / MB).toFixed(1);
 var sizeScanner = {
   name: "size",
   description: "Analyzes app bundle size and warns on large downloads",
@@ -7572,21 +7818,28 @@ var sizeScanner = {
     const maxMb = ctx.config.maxDownloadSizeMb;
     const totalCompressed = entries.reduce((sum, e) => sum + e.compressedSize, 0);
     const totalUncompressed = entries.reduce((sum, e) => sum + e.uncompressedSize, 0);
-    const compressedMb = totalCompressed / (1024 * 1024);
-    const uncompressedMb = totalUncompressed / (1024 * 1024);
-    if (compressedMb > maxMb) {
+    const bundle = ctx.isAppBundle ?? false;
+    const installed = firstInstallEntries(entries, bundle, ctx.deferredModules);
+    const nativeAbi = bundle ? largestAbi(installed, (e) => e.compressedSize) : void 0;
+    const delivered = bundle ? installed.filter((e) => {
+      const abi = nativeLibAbi(e.path);
+      return !abi || abi === nativeAbi?.abi;
+    }) : installed;
+    const downloadBytes = delivered.reduce((sum, e) => sum + e.compressedSize, 0);
+    if (downloadBytes / MB > maxMb) {
+      const size = bundle ? `Estimated download for one device is ${mb(downloadBytes)} MB${nativeAbi ? ` (with ${nativeAbi.abi} native libraries)` : ""}` : `The APK is ${mb(downloadBytes)} MB compressed`;
       findings.push({
         scanner: "size",
         ruleId: "size-over-limit",
         severity: "warning",
         title: `Download size exceeds ${maxMb} MB`,
-        message: `Compressed size is ${compressedMb.toFixed(1)} MB. Downloads over ${maxMb} MB show a mobile data warning to users, which reduces install rates.`,
-        suggestion: "Use Android App Bundles for split APKs, remove unused resources, enable R8/ProGuard, and compress assets.",
-        policyUrl: "https://developer.android.com/topic/performance/reduce-apk-size"
+        message: `${size}, above your ${maxMb} MB threshold.` + (downloadBytes > PLAY_MOBILE_DATA_DIALOG_MB * MB ? ` Google Play shows users on mobile data a large-download dialog for apps over ${PLAY_MOBILE_DATA_DIALOG_MB} MB, which can reduce install rates.` : ""),
+        suggestion: bundle ? "Remove unused resources, enable R8, and move large or optional content into fast-follow or on-demand asset packs or feature modules." : "Publish an Android App Bundle so each device downloads only its own ABI and screen density, remove unused resources, and enable R8.",
+        policyUrl: "https://support.google.com/googleplay/android-developer/answer/9859372"
       });
     }
     const categories = /* @__PURE__ */ new Map();
-    for (const entry of entries) {
+    for (const entry of delivered) {
       const cat = detectCategory(entry.path);
       const existing = categories.get(cat) ?? { compressed: 0, uncompressed: 0, count: 0 };
       existing.compressed += entry.compressedSize;
@@ -7595,13 +7848,13 @@ var sizeScanner = {
       categories.set(cat, existing);
     }
     const nativeLibs = categories.get("native-libs");
-    if (nativeLibs && nativeLibs.compressed > 50 * 1024 * 1024) {
+    if (nativeLibs && nativeLibs.compressed > 50 * MB) {
       findings.push({
         scanner: "size",
         ruleId: "size-large-native",
         severity: "warning",
         title: "Large native libraries",
-        message: `Native libraries are ${(nativeLibs.compressed / (1024 * 1024)).toFixed(1)} MB (compressed). This is the largest contributor to download size.`,
+        message: nativeAbi ? `Native libraries for ${nativeAbi.abi} are ${mb(nativeLibs.compressed)} MB (compressed), and each device on that ABI downloads all of them.` : `Native libraries are ${mb(nativeLibs.compressed)} MB (compressed) across every ABI in the APK.`,
         suggestion: "Review which native libraries are bundled. Consider using dynamic feature modules for optional native code."
       });
     }
@@ -7612,18 +7865,18 @@ var sizeScanner = {
         ruleId: "size-large-assets",
         severity: "info",
         title: "Large assets directory",
-        message: `Assets are ${(assets.compressed / (1024 * 1024)).toFixed(1)} MB (compressed). Consider using Play Asset Delivery for large assets.`,
+        message: `Assets are ${mb(assets.compressed)} MB (compressed). Consider using Play Asset Delivery for large assets.`,
         suggestion: "Move large assets to Play Asset Delivery (install-time, fast-follow, or on-demand packs).",
         policyUrl: "https://developer.android.com/guide/playcore/asset-delivery"
       });
     }
-    const breakdown = [...categories.entries()].sort((a, b) => b[1].compressed - a[1].compressed).map(([cat, data]) => `${cat}: ${(data.compressed / (1024 * 1024)).toFixed(1)} MB`).join(", ");
+    const breakdown = [...categories.entries()].sort((a, b) => b[1].compressed - a[1].compressed).map(([cat, data]) => `${cat}: ${mb(data.compressed)} MB`).join(", ");
     findings.push({
       scanner: "size",
       ruleId: "size-summary",
       severity: "info",
-      title: `Total size: ${compressedMb.toFixed(1)} MB compressed, ${uncompressedMb.toFixed(1)} MB uncompressed`,
-      message: `${entries.length} files. Breakdown: ${breakdown}`
+      title: bundle ? `Estimated download: ${mb(downloadBytes)} MB per device (bundle file ${mb(totalCompressed)} MB compressed, ${mb(totalUncompressed)} MB uncompressed)` : `Total size: ${mb(totalCompressed)} MB compressed, ${mb(totalUncompressed)} MB uncompressed`,
+      message: bundle ? `${delivered.length} of ${entries.length} files reach one device. Breakdown: ${breakdown}` : `${entries.length} files. Breakdown: ${breakdown}`
     });
     return findings;
   }
@@ -7631,10 +7884,10 @@ var sizeScanner = {
 function detectCategory(path) {
   const lower = path.toLowerCase();
   if (lower.endsWith(".dex") || /\/dex\//.test(lower)) return "dex";
-  if (/\/lib\/[^/]+\/[^/]+\.so$/.test(lower)) return "native-libs";
-  if (/\/res\//.test(lower) || lower.endsWith("/resources.pb") || lower.endsWith("/resources.arsc"))
+  if (nativeLibAbi(path)) return "native-libs";
+  if (/(?:^|\/)res\//.test(lower) || /(?:^|\/)resources\.(?:pb|arsc)$/.test(lower))
     return "resources";
-  if (/\/assets\//.test(lower)) return "assets";
+  if (/(?:^|\/)assets\//.test(lower)) return "assets";
   if (lower.includes("androidmanifest.xml") || /\/manifest\//.test(lower)) return "manifest";
   if (lower.startsWith("meta-inf/")) return "signing";
   return "other";
@@ -7670,6 +7923,8 @@ async function runPreflight(options) {
     ctx.manifest = aab.manifest;
     ctx.zipEntries = aab.entries;
     ctx.nativeLibHeaders = aab.nativeLibHeaders;
+    ctx.isAppBundle = aab.isAppBundle;
+    ctx.deferredModules = aab.deferredModules;
     if (aab.manifest._parseError) {
       earlyFindings.push({
         scanner: "manifest-parser",
@@ -9628,7 +9883,7 @@ async function sha256File(filePath) {
 }
 
 // src/commands/image-sync.ts
-import { readdir as readdir7, stat as stat10 } from "fs/promises";
+import { readdir as readdir7 } from "fs/promises";
 import { join as join13, extname as extname5 } from "path";
 import { PlayApiError } from "@gpc-cli/api";
 var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg"]);
@@ -9643,12 +9898,20 @@ var ALL_IMAGE_TYPES2 = [
   "wearScreenshots"
 ];
 async function scanLocalImages(dir) {
+  let entries;
   try {
-    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 [];
+    entries = await readdir7(dir, { withFileTypes: true });
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT" || code === "ENOTDIR") return null;
+    throw new GpcError(
+      `Cannot read image directory "${dir}": ${code ?? String(error)}`,
+      "IMAGE_SYNC_DIR_UNREADABLE",
+      1,
+      "Check the directory's permissions (and container volume ownership in CI). Nothing was changed on Google Play."
+    );
   }
+  return entries.filter((e) => e.isFile() && IMAGE_EXTENSIONS.has(extname5(e.name).toLowerCase())).map((e) => e.name).sort();
 }
 async function scanLanguages(dir) {
   try {
@@ -9658,13 +9921,6 @@ async function scanLanguages(dir) {
     return [];
   }
 }
-async function dirExists(path) {
-  try {
-    return (await stat10(path)).isDirectory();
-  } catch {
-    return false;
-  }
-}
 async function syncImages(client, packageName, dir, options) {
   const details = [];
   let uploaded = 0;
@@ -9685,7 +9941,8 @@ async function syncImages(client, packageName, dir, options) {
     for (const language of languages) {
       for (const imageType of imageTypes) {
         const localDir = join13(dir, language, imageType);
-        const localFiles = await scanLocalImages(localDir);
+        const scanned = await scanLocalImages(localDir);
+        const localFiles = scanned ?? [];
         let remoteImages;
         try {
           remoteImages = await client.images.list(packageName, edit.id, language, imageType);
@@ -9727,7 +9984,7 @@ async function syncImages(client, packageName, dir, options) {
           details.push({ language, imageType, file, action: "upload", reason });
         };
         if (options?.delete) {
-          if (localFiles.length === 0 && remoteImages.length > 0 && !await dirExists(localDir)) {
+          if (scanned === null && remoteImages.length > 0) {
             for (const img of remoteImages) {
               details.push({
                 language,
@@ -10151,6 +10408,7 @@ export {
   batchGetOrders,
   batchSyncInAppProducts,
   buildChecklist,
+  buildExternalTransactionRefund,
   buildLocaleBundle,
   bundleToReleaseNotes,
   cancelRecoveryAction,