@gpc-cli/api 1.0.19 → 1.0.21

package/dist/index.js

@@ -1,11 +1,11 @@
 // src/errors.ts
-var ApiError = class extends Error {
+var PlayApiError = class extends Error {
   constructor(message, code, statusCode, suggestion) {
     super(message);
     this.code = code;
     this.statusCode = statusCode;
     this.suggestion = suggestion;
-    this.name = "ApiError";
+    this.name = "PlayApiError";
   }
   exitCode = 4;
   toJSON() {
@@ -21,8 +21,269 @@ var ApiError = class extends Error {
 };
 
 // src/http.ts
-import { readFile } from "fs/promises";
+import { readFile, stat as stat2 } from "fs/promises";
 import { resolve, isAbsolute } from "path";
+
+// src/resumable-upload.ts
+import { open, stat } from "fs/promises";
+var CHUNK_ALIGNMENT = 256 * 1024;
+var DEFAULT_CHUNK_SIZE = 8 * 1024 * 1024;
+var RESUMABLE_THRESHOLD = 5 * 1024 * 1024;
+function envInt(name) {
+  const val = process.env[name];
+  if (val === void 0) return void 0;
+  const n = Number(val);
+  return Number.isFinite(n) ? n : void 0;
+}
+function resolveChunkSize(explicit) {
+  const size = explicit ?? envInt("GPC_UPLOAD_CHUNK_SIZE") ?? DEFAULT_CHUNK_SIZE;
+  if (size < CHUNK_ALIGNMENT || size % CHUNK_ALIGNMENT !== 0) {
+    throw new PlayApiError(
+      `Chunk size must be a multiple of 256 KB (got ${size} bytes)`,
+      "UPLOAD_INVALID_CHUNK_SIZE",
+      void 0,
+      `Use a multiple of 262144 (256 KB). Common values: 1048576 (1 MB), 8388608 (8 MB), 16777216 (16 MB).`
+    );
+  }
+  return size;
+}
+function jitteredDelay(base, attempt, max) {
+  const exponential = base * 2 ** attempt;
+  const capped = Math.min(exponential, max);
+  return capped * (0.5 + Math.random() * 0.5);
+}
+async function resumableUpload(uploadUrl, filePath, contentType, ctx, options) {
+  const chunkSize = resolveChunkSize(options?.chunkSize);
+  const maxResumeAttempts = options?.maxResumeAttempts ?? 5;
+  const onProgress = options?.onProgress;
+  const fileStats = await stat(filePath);
+  const totalBytes = fileStats.size;
+  let sessionUri = options?.resumeSessionUri;
+  if (!sessionUri) {
+    sessionUri = await initiateSession(uploadUrl, contentType, totalBytes, ctx);
+  }
+  const startTime = Date.now();
+  let offset = 0;
+  if (options?.resumeSessionUri) {
+    offset = await queryProgress(sessionUri, totalBytes, ctx);
+  }
+  let fh;
+  try {
+    fh = await open(filePath, "r");
+    const chunkBuffer = Buffer.alloc(chunkSize);
+    while (offset < totalBytes) {
+      const remaining = totalBytes - offset;
+      const bytesToRead = Math.min(chunkSize, remaining);
+      const { bytesRead } = await fh.read(chunkBuffer, 0, bytesToRead, offset);
+      if (bytesRead === 0) break;
+      const chunk = Buffer.from(chunkBuffer.buffer, chunkBuffer.byteOffset, bytesRead);
+      const rangeEnd = offset + bytesRead - 1;
+      const contentRange = `bytes ${offset}-${rangeEnd}/${totalBytes}`;
+      let result;
+      for (let attempt = 0; attempt <= maxResumeAttempts; attempt++) {
+        if (attempt > 0) {
+          const delay = jitteredDelay(1e3, attempt - 1, 3e4);
+          await new Promise((r) => setTimeout(r, delay));
+          try {
+            const serverOffset = await queryProgress(sessionUri, totalBytes, ctx);
+            if (serverOffset >= offset + bytesRead) {
+              result = { complete: false };
+              break;
+            }
+            if (serverOffset > offset) {
+            }
+          } catch {
+          }
+          ctx.onRetry?.({
+            attempt,
+            method: "PUT",
+            path: sessionUri,
+            error: `Chunk upload failed at offset ${offset}, retrying`,
+            delayMs: Math.round(delay),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        result = await sendChunk(sessionUri, chunk, contentRange, ctx);
+        if (result) break;
+      }
+      if (!result) {
+        throw new PlayApiError(
+          `Upload failed: chunk at offset ${offset} could not be sent after ${maxResumeAttempts + 1} attempts`,
+          "UPLOAD_CHUNK_FAILED",
+          void 0,
+          `The upload session is still valid for up to 1 week. Resume with: --resume-uri "${sessionUri}"`
+        );
+      }
+      offset += bytesRead;
+      if (onProgress) {
+        const elapsed = (Date.now() - startTime) / 1e3;
+        const bytesPerSecond = elapsed > 0 ? offset / elapsed : 0;
+        const remainingBytes = totalBytes - offset;
+        const etaSeconds = bytesPerSecond > 0 ? remainingBytes / bytesPerSecond : 0;
+        onProgress({
+          bytesUploaded: offset,
+          totalBytes,
+          percent: Math.round(offset / totalBytes * 100),
+          bytesPerSecond: Math.round(bytesPerSecond),
+          etaSeconds: Math.round(etaSeconds)
+        });
+      }
+      if (result.complete && result.response) {
+        return result.response;
+      }
+    }
+    throw new PlayApiError(
+      "Upload finished sending all bytes but did not receive a completion response",
+      "UPLOAD_NO_COMPLETION",
+      void 0,
+      "This is unexpected. Try uploading again."
+    );
+  } finally {
+    await fh?.close();
+  }
+}
+async function initiateSession(uploadUrl, contentType, totalBytes, ctx) {
+  const token = await ctx.getAccessToken();
+  const url = uploadUrl.includes("?") ? `${uploadUrl}&uploadType=resumable` : `${uploadUrl}?uploadType=resumable`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 6e4);
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "X-Upload-Content-Type": contentType,
+        "X-Upload-Content-Length": String(totalBytes),
+        "Content-Length": "0"
+      },
+      signal: controller.signal
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!response.ok) {
+    const body = await response.text();
+    throw new PlayApiError(
+      `Failed to initiate resumable upload: ${response.status} ${body.slice(0, 200)}`,
+      "UPLOAD_INITIATE_FAILED",
+      response.status,
+      "Check that the package name, edit ID, and credentials are correct."
+    );
+  }
+  const location = response.headers.get("Location");
+  if (!location) {
+    throw new PlayApiError(
+      "Resumable upload initiation did not return a session URI (Location header missing)",
+      "UPLOAD_NO_SESSION_URI",
+      response.status,
+      "This is a Google API issue. Try again."
+    );
+  }
+  return location;
+}
+async function sendChunk(sessionUri, chunk, contentRange, ctx) {
+  const token = await ctx.getAccessToken();
+  const chunkTimeoutMs = 3e4 + Math.ceil(chunk.byteLength / (1024 * 1024)) * 1e3;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), chunkTimeoutMs);
+  let response;
+  try {
+    response = await fetch(sessionUri, {
+      method: "PUT",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Length": String(chunk.byteLength),
+        "Content-Range": contentRange
+      },
+      body: chunk,
+      signal: controller.signal
+    });
+  } catch {
+    return void 0;
+  } finally {
+    clearTimeout(timer);
+  }
+  if (response.status === 200 || response.status === 201) {
+    const text = await response.text();
+    const data = text ? JSON.parse(text) : {};
+    return { complete: true, response: { data, status: response.status } };
+  }
+  if (response.status === 308) {
+    await response.body?.cancel();
+    return { complete: false };
+  }
+  if (response.status === 404) {
+    throw new PlayApiError(
+      "Upload session not found. The session may have expired.",
+      "UPLOAD_SESSION_NOT_FOUND",
+      404,
+      "Start a new upload. Resumable upload sessions are valid for up to 1 week."
+    );
+  }
+  if (response.status === 410) {
+    throw new PlayApiError(
+      "Upload session has expired.",
+      "UPLOAD_SESSION_EXPIRED",
+      410,
+      "Start a new upload from the beginning."
+    );
+  }
+  if (response.status === 401) {
+    await response.body?.cancel();
+    return void 0;
+  }
+  if (response.status === 429 || response.status >= 500) {
+    await response.body?.cancel();
+    return void 0;
+  }
+  const body = await response.text();
+  throw new PlayApiError(
+    `Upload chunk failed with status ${response.status}: ${body.slice(0, 200)}`,
+    `UPLOAD_HTTP_${response.status}`,
+    response.status,
+    "The upload encountered an unexpected error."
+  );
+}
+async function queryProgress(sessionUri, totalBytes, ctx) {
+  const token = await ctx.getAccessToken();
+  const response = await fetch(sessionUri, {
+    method: "PUT",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Length": "0",
+      "Content-Range": `bytes */${totalBytes}`
+    }
+  });
+  if (response.status === 308) {
+    await response.body?.cancel();
+    const range = response.headers.get("Range");
+    if (range) {
+      const match = range.match(/bytes=0-(\d+)/);
+      if (match) {
+        return Number(match[1]) + 1;
+      }
+    }
+    return 0;
+  }
+  if (response.status === 200 || response.status === 201) {
+    await response.body?.cancel();
+    return totalBytes;
+  }
+  if (response.status === 404 || response.status === 410) {
+    await response.body?.cancel();
+    throw new PlayApiError(
+      "Upload session has expired while querying progress.",
+      "UPLOAD_SESSION_EXPIRED",
+      response.status,
+      "Start a new upload from the beginning."
+    );
+  }
+  await response.body?.cancel();
+  return 0;
+}
+
+// src/http.ts
 function stripHtml(text) {
   return text.replace(/<[^>]*>/g, " ").replace(/&[a-z]+;/gi, " ").replace(/\s+/g, " ").trim();
 }
@@ -40,7 +301,7 @@ function sanitizeErrorBody(body) {
 function validateFilePath(filePath) {
   const resolved = resolve(filePath);
   if (!isAbsolute(resolved)) {
-    throw new ApiError(
+    throw new PlayApiError(
       "Invalid file path",
       "API_INVALID_PATH",
       void 0,
@@ -48,21 +309,26 @@ function validateFilePath(filePath) {
     );
   }
   if (filePath.includes("\0")) {
-    throw new ApiError("Invalid file path: null bytes not allowed", "API_INVALID_PATH", void 0, "Provide a valid file path without null bytes.");
+    throw new PlayApiError(
+      "Invalid file path: null bytes not allowed",
+      "API_INVALID_PATH",
+      void 0,
+      "Provide a valid file path without null bytes."
+    );
   }
   return resolved;
 }
 var BASE_URL = "https://androidpublisher.googleapis.com/androidpublisher/v3/applications";
 var UPLOAD_BASE_URL = "https://androidpublisher.googleapis.com/upload/androidpublisher/v3/applications";
 var INTERNAL_SHARING_UPLOAD_BASE_URL = "https://androidpublisher.googleapis.com/upload/internalappsharing/v3/applications";
-function envInt(name) {
+function envInt2(name) {
   const val = process.env[name];
   if (val === void 0) return void 0;
   const n = Number(val);
   return Number.isFinite(n) ? n : void 0;
 }
 function resolveOption(explicit, envName, fallback) {
-  return explicit ?? envInt(envName) ?? fallback;
+  return explicit ?? envInt2(envName) ?? fallback;
 }
 function mapStatusToError(status, body) {
   switch (status) {
@@ -115,17 +381,17 @@ function mapStatusToError(status, body) {
   }
 }
 function isRetryable(status) {
-  return status === 429 || status >= 500;
+  return status === 408 || status === 429 || status >= 500;
 }
-function jitteredDelay(base, attempt, max) {
+function jitteredDelay2(base, attempt, max) {
   const exponential = base * 2 ** attempt;
   const capped = Math.min(exponential, max);
   return capped * (0.5 + Math.random() * 0.5);
 }
 function createHttpClient(options) {
-  const maxRetries = resolveOption(options.maxRetries, "GPC_MAX_RETRIES", 3);
+  const maxRetries = resolveOption(options.maxRetries, "GPC_MAX_RETRIES", 5);
   const timeout = resolveOption(options.timeout, "GPC_TIMEOUT", 3e4);
-  const uploadTimeoutExplicit = options.uploadTimeout ?? envInt("GPC_UPLOAD_TIMEOUT");
+  const uploadTimeoutExplicit = options.uploadTimeout ?? envInt2("GPC_UPLOAD_TIMEOUT");
   const baseDelay = resolveOption(options.baseDelay, "GPC_BASE_DELAY", 1e3);
   const maxDelay = resolveOption(options.maxDelay, "GPC_MAX_DELAY", 6e4);
   const onRetry = options.onRetry;
@@ -139,7 +405,7 @@ function createHttpClient(options) {
     let lastError;
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
       if (attempt > 0) {
-        const delay = jitteredDelay(baseDelay, attempt - 1, maxDelay);
+        const delay = jitteredDelay2(baseDelay, attempt - 1, maxDelay);
         await new Promise((r) => setTimeout(r, delay));
       }
       const controller = new AbortController();
@@ -168,7 +434,7 @@ function createHttpClient(options) {
         }
         const errorBody = await response.text();
         const { code, suggestion } = mapStatusToError(response.status, errorBody);
-        const err = new ApiError(
+        const err = new PlayApiError(
           `${method} ${path} failed with status ${response.status}: ${sanitizeErrorBody(errorBody)}`,
           code,
           response.status,
@@ -176,7 +442,7 @@ function createHttpClient(options) {
         );
         if (isRetryable(response.status) && attempt < maxRetries) {
           lastError = err;
-          const delay = jitteredDelay(baseDelay, attempt, maxDelay);
+          const delay = jitteredDelay2(baseDelay, attempt, maxDelay);
           onRetry?.({
             attempt: attempt + 1,
             method,
@@ -195,11 +461,11 @@ function createHttpClient(options) {
         }
         throw err;
       } catch (error) {
-        if (error instanceof ApiError) {
+        if (error instanceof PlayApiError) {
           throw error;
         }
         if (error instanceof DOMException && error.name === "AbortError") {
-          const timeoutErr = new ApiError(
+          const timeoutErr = new PlayApiError(
             `${method} ${path} timed out after ${timeout}ms`,
             "API_TIMEOUT",
             void 0,
@@ -212,14 +478,14 @@ function createHttpClient(options) {
               method,
               path,
               error: timeoutErr.message,
-              delayMs: Math.round(jitteredDelay(baseDelay, attempt, maxDelay)),
+              delayMs: Math.round(jitteredDelay2(baseDelay, attempt, maxDelay)),
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
             continue;
           }
           throw timeoutErr;
         }
-        const networkErr = new ApiError(
+        const networkErr = new PlayApiError(
           `${method} ${path} failed: ${error instanceof Error ? error.message : String(error)}`,
           "API_NETWORK_ERROR",
           void 0,
@@ -232,7 +498,7 @@ function createHttpClient(options) {
             method,
             path,
             error: networkErr.message,
-            delayMs: Math.round(jitteredDelay(baseDelay, attempt, maxDelay)),
+            delayMs: Math.round(jitteredDelay2(baseDelay, attempt, maxDelay)),
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
           continue;
@@ -242,7 +508,12 @@ function createHttpClient(options) {
         clearTimeout(timer);
       }
     }
-    throw lastError ?? new ApiError("Request failed", "API_NETWORK_ERROR", void 0, "Check your network connection and try again. Use --verbose for details.");
+    throw lastError ?? new PlayApiError(
+      "Request failed",
+      "API_NETWORK_ERROR",
+      void 0,
+      "Check your network connection and try again. Use --verbose for details."
+    );
   }
   function computeUploadTimeout(fileSizeBytes) {
     if (uploadTimeoutExplicit !== void 0) return uploadTimeoutExplicit;
@@ -258,7 +529,7 @@ function createHttpClient(options) {
     let lastError;
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
       if (attempt > 0) {
-        const delay = jitteredDelay(baseDelay, attempt - 1, maxDelay);
+        const delay = jitteredDelay2(baseDelay, attempt - 1, maxDelay);
         await new Promise((r) => setTimeout(r, delay));
       }
       const controller = new AbortController();
@@ -284,7 +555,7 @@ function createHttpClient(options) {
         }
         const errorBody = await response.text();
         const { code, suggestion } = mapStatusToError(response.status, errorBody);
-        const err = new ApiError(
+        const err = new PlayApiError(
           `POST upload ${path} failed with status ${response.status}: ${sanitizeErrorBody(errorBody)}`,
           code,
           response.status,
@@ -292,7 +563,7 @@ function createHttpClient(options) {
         );
         if (isRetryable(response.status) && attempt < maxRetries) {
           lastError = err;
-          const delay = jitteredDelay(baseDelay, attempt, maxDelay);
+          const delay = jitteredDelay2(baseDelay, attempt, maxDelay);
           onRetry?.({
             attempt: attempt + 1,
             method: "POST",
@@ -311,12 +582,12 @@ function createHttpClient(options) {
         }
         throw err;
       } catch (error) {
-        if (error instanceof ApiError) {
+        if (error instanceof PlayApiError) {
           throw error;
         }
         if (error instanceof DOMException && error.name === "AbortError") {
           const sizeMb = Math.round(fileBuffer.byteLength / (1024 * 1024));
-          const timeoutErr = new ApiError(
+          const timeoutErr = new PlayApiError(
             `POST upload ${path} timed out after ${effectiveTimeout}ms (file: ${sizeMb} MB)`,
             "API_TIMEOUT",
             void 0,
@@ -329,14 +600,14 @@ function createHttpClient(options) {
               method: "POST",
               path: `upload ${path}`,
               error: timeoutErr.message,
-              delayMs: Math.round(jitteredDelay(baseDelay, attempt, maxDelay)),
+              delayMs: Math.round(jitteredDelay2(baseDelay, attempt, maxDelay)),
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
             continue;
           }
           throw timeoutErr;
         }
-        const networkErr = new ApiError(
+        const networkErr = new PlayApiError(
           `POST upload ${path} failed: ${error instanceof Error ? error.message : String(error)}`,
           "API_NETWORK_ERROR",
           void 0,
@@ -349,7 +620,7 @@ function createHttpClient(options) {
             method: "POST",
             path: `upload ${path}`,
             error: networkErr.message,
-            delayMs: Math.round(jitteredDelay(baseDelay, attempt, maxDelay)),
+            delayMs: Math.round(jitteredDelay2(baseDelay, attempt, maxDelay)),
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
           continue;
@@ -359,7 +630,12 @@ function createHttpClient(options) {
         clearTimeout(timer);
       }
     }
-    throw lastError ?? new ApiError("Upload request failed", "API_NETWORK_ERROR", void 0, "Check your network connection and try again. Use --verbose for details.");
+    throw lastError ?? new PlayApiError(
+      "Upload request failed",
+      "API_NETWORK_ERROR",
+      void 0,
+      "Check your network connection and try again. Use --verbose for details."
+    );
   }
   return {
     get(path, params) {
@@ -380,6 +656,25 @@ function createHttpClient(options) {
     upload(path, filePath, contentType) {
       return uploadRequest(path, filePath, contentType);
     },
+    async uploadResumable(path, filePath, contentType, uploadOptions) {
+      const safeFilePath = validateFilePath(filePath);
+      const fileStats = await stat2(safeFilePath);
+      const threshold = envInt2("GPC_UPLOAD_RESUMABLE_THRESHOLD") ?? RESUMABLE_THRESHOLD;
+      if (fileStats.size < threshold && !uploadOptions?.resumeSessionUri) {
+        uploadOptions?.onProgress?.({ bytesUploaded: 0, totalBytes: fileStats.size, percent: 0, bytesPerSecond: 0, etaSeconds: 0 });
+        const result = await uploadRequest(path, safeFilePath, contentType);
+        uploadOptions?.onProgress?.({ bytesUploaded: fileStats.size, totalBytes: fileStats.size, percent: 100, bytesPerSecond: 0, etaSeconds: 0 });
+        return result;
+      }
+      const uploadUrl = `${UPLOAD_BASE_URL}${path}`;
+      return resumableUpload(uploadUrl, safeFilePath, contentType, {
+        getAccessToken: () => options.auth.getAccessToken(),
+        maxRetries,
+        baseDelay,
+        maxDelay,
+        onRetry
+      }, uploadOptions);
+    },
     uploadInternal(path, filePath, contentType) {
       return uploadRequest(path, filePath, contentType, INTERNAL_SHARING_UPLOAD_BASE_URL);
     },
@@ -402,7 +697,7 @@ function createHttpClient(options) {
         if (!response.ok) {
           const errorBody = await response.text();
           const { code, suggestion } = mapStatusToError(response.status, errorBody);
-          throw new ApiError(
+          throw new PlayApiError(
             `GET ${path} failed with status ${response.status}: ${sanitizeErrorBody(errorBody)}`,
             code,
             response.status,
@@ -473,14 +768,15 @@ function createApiClient(options) {
         );
         return data.bundles;
       },
-      async upload(packageName, editId, filePath) {
-        const { data } = await http.upload(
+      async upload(packageName, editId, filePath, uploadOptions) {
+        const { data } = await http.uploadResumable(
           `/${packageName}/edits/${editId}/bundles`,
           filePath,
-          "application/octet-stream"
+          "application/octet-stream",
+          uploadOptions
         );
         if (!data || !data.versionCode) {
-          throw new ApiError(
+          throw new PlayApiError(
             "Upload succeeded but no bundle data returned",
             "API_EMPTY_RESPONSE",
             200,
@@ -572,7 +868,7 @@ function createApiClient(options) {
           filePath.endsWith(".png") ? "image/png" : "image/jpeg"
         );
         if (!data.image) {
-          throw new ApiError(
+          throw new PlayApiError(
             "Upload succeeded but no image data returned",
             "API_EMPTY_RESPONSE",
             200,
@@ -603,16 +899,11 @@ function createApiClient(options) {
     },
     dataSafety: {
       async get(packageName) {
-        const { data } = await http.get(
-          `/${packageName}/dataSafety`
-        );
+        const { data } = await http.get(`/${packageName}/dataSafety`);
         return data;
       },
       async update(packageName, body) {
-        const { data } = await http.put(
-          `/${packageName}/dataSafety`,
-          body
-        );
+        const { data } = await http.put(`/${packageName}/dataSafety`, body);
         return data;
       }
     },
@@ -665,9 +956,7 @@ function createApiClient(options) {
         return data;
       },
       async get(packageName, productId) {
-        const { data } = await http.get(
-          `/${packageName}/subscriptions/${productId}`
-        );
+        const { data } = await http.get(`/${packageName}/subscriptions/${productId}`);
         return data;
       },
       async create(packageName, body, productId) {
@@ -702,9 +991,7 @@ function createApiClient(options) {
         return data;
       },
       async deleteBasePlan(packageName, productId, basePlanId) {
-        await http.delete(
-          `/${packageName}/subscriptions/${productId}/basePlans/${basePlanId}`
-        );
+        await http.delete(`/${packageName}/subscriptions/${productId}/basePlans/${basePlanId}`);
       },
       async migratePrices(packageName, productId, basePlanId, body) {
         const { data } = await http.post(
@@ -763,7 +1050,6 @@ function createApiClient(options) {
       async list(packageName, options2) {
         const params = {};
         if (options2?.token) params["token"] = options2.token;
-        if (options2?.maxResults) params["maxResults"] = String(options2.maxResults);
         const hasParams = Object.keys(params).length > 0;
         const { data } = await http.get(
           `/${packageName}/inappproducts`,
@@ -837,6 +1123,12 @@ function createApiClient(options) {
         return data;
       },
       async getSubscriptionV1(packageName, subscriptionId, token) {
+        if (typeof process !== "undefined" && process.emitWarning) {
+          process.emitWarning(
+            "purchases.subscriptions.get (v1) is deprecated by Google (shutdown Aug 2027). Use getSubscriptionV2() instead.",
+            "DeprecationWarning"
+          );
+        }
         const { data } = await http.get(
           `/${packageName}/purchases/subscriptions/${subscriptionId}/tokens/${token}`
         );
@@ -922,7 +1214,7 @@ function createApiClient(options) {
           "application/octet-stream"
         );
         if (!data.deobfuscationFile) {
-          throw new ApiError(
+          throw new PlayApiError(
             "Upload succeeded but no deobfuscation file data returned",
             "API_EMPTY_RESPONSE",
             200,
@@ -1084,10 +1376,7 @@ function createApiClient(options) {
         return data;
       },
       async create(packageName, body) {
-        const { data } = await http.post(
-          `/${packageName}/purchaseOptions`,
-          body
-        );
+        const { data } = await http.post(`/${packageName}/purchaseOptions`, body);
         return data;
       },
       async activate(packageName, purchaseOptionId) {
@@ -1129,10 +1418,71 @@ function createApiClient(options) {
         return data.generatedApks || [];
       },
       async download(packageName, versionCode, id) {
-        return http.download(
-          `/${packageName}/generatedApks/${versionCode}/download/${id}`
-        );
+        return http.download(`/${packageName}/generatedApks/${versionCode}/download/${id}`);
+      }
+    }
+  };
+}
+
+// src/rate-limiter.ts
+var RATE_LIMIT_BUCKETS = {
+  default: { name: "default", maxTokens: 200, refillRate: 200, refillIntervalMs: 1e3 },
+  reviewsGet: { name: "reviewsGet", maxTokens: 200, refillRate: 200, refillIntervalMs: 36e5 },
+  reviewsPost: {
+    name: "reviewsPost",
+    maxTokens: 2e3,
+    refillRate: 2e3,
+    refillIntervalMs: 864e5
+  },
+  voidedBurst: { name: "voidedBurst", maxTokens: 30, refillRate: 30, refillIntervalMs: 3e4 },
+  voidedDaily: {
+    name: "voidedDaily",
+    maxTokens: 6e3,
+    refillRate: 6e3,
+    refillIntervalMs: 864e5
+  },
+  reporting: { name: "reporting", maxTokens: 10, refillRate: 10, refillIntervalMs: 1e3 }
+};
+function createRateLimiter(buckets) {
+  const states = /* @__PURE__ */ new Map();
+  if (buckets) {
+    for (const bucket of buckets) {
+      states.set(bucket.name, {
+        tokens: bucket.maxTokens,
+        lastRefillTime: Date.now(),
+        config: bucket
+      });
+    }
+  }
+  return {
+    async acquire(bucket) {
+      const state = states.get(bucket);
+      if (!state) return;
+      const now = Date.now();
+      const elapsed = now - state.lastRefillTime;
+      const refill = Math.floor(
+        elapsed / state.config.refillIntervalMs * state.config.refillRate
+      );
+      if (refill > 0) {
+        state.tokens = Math.min(state.config.maxTokens, state.tokens + refill);
+        state.lastRefillTime = now;
       }
+      if (state.tokens > 0) {
+        state.tokens--;
+        return;
+      }
+      const tokensNeeded = 1;
+      const waitMs = Math.ceil(
+        tokensNeeded / state.config.refillRate * state.config.refillIntervalMs
+      );
+      await new Promise((r) => setTimeout(r, waitMs));
+      const afterWait = Date.now();
+      const totalElapsed = afterWait - state.lastRefillTime;
+      const newTokens = Math.floor(
+        totalElapsed / state.config.refillIntervalMs * state.config.refillRate
+      );
+      state.tokens = Math.min(state.config.maxTokens, newTokens) - 1;
+      state.lastRefillTime = afterWait;
     }
   };
 }
@@ -1141,8 +1491,10 @@ function createApiClient(options) {
 var REPORTING_BASE_URL = "https://playdeveloperreporting.googleapis.com/v1beta1";
 function createReportingClient(options) {
   const http = createHttpClient({ ...options, baseUrl: REPORTING_BASE_URL });
+  const limiter = options.rateLimiter ?? createRateLimiter([RATE_LIMIT_BUCKETS["reporting"]]);
   return {
     async queryMetricSet(packageName, metricSet, query) {
+      await limiter.acquire("reporting");
       const { data } = await http.post(
         `/apps/${packageName}/${metricSet}:query`,
         query
@@ -1150,10 +1502,12 @@ function createReportingClient(options) {
       return data;
     },
     async getAnomalies(packageName) {
+      await limiter.acquire("reporting");
       const { data } = await http.get(`/apps/${packageName}/anomalies`);
       return data;
     },
     async searchErrorIssues(packageName, filter, pageSize, pageToken) {
+      await limiter.acquire("reporting");
       const params = {};
       if (filter) params["filter"] = filter;
       if (pageSize) params["pageSize"] = String(pageSize);
@@ -1165,6 +1519,7 @@ function createReportingClient(options) {
       return data;
     },
     async searchErrorReports(packageName, issueName, pageSize, pageToken) {
+      await limiter.acquire("reporting");
       const params = {};
       if (pageSize) params["pageSize"] = String(pageSize);
       if (pageToken) params["pageToken"] = pageToken;
@@ -1301,84 +1656,17 @@ function createEnterpriseClient(options) {
   return {
     apps: {
       async create(organizationId, app) {
-        const { data } = await http.post(
-          `/${organizationId}/apps`,
-          app
-        );
+        const { data } = await http.post(`/${organizationId}/apps`, app);
         return data;
       },
       async list(organizationId) {
-        const { data } = await http.get(
-          `/${organizationId}/apps`
-        );
+        const { data } = await http.get(`/${organizationId}/apps`);
         return data;
       }
     }
   };
 }
 
-// src/rate-limiter.ts
-var RATE_LIMIT_BUCKETS = {
-  default: { name: "default", maxTokens: 200, refillRate: 200, refillIntervalMs: 1e3 },
-  reviewsGet: { name: "reviewsGet", maxTokens: 200, refillRate: 200, refillIntervalMs: 36e5 },
-  reviewsPost: {
-    name: "reviewsPost",
-    maxTokens: 2e3,
-    refillRate: 2e3,
-    refillIntervalMs: 864e5
-  },
-  voidedBurst: { name: "voidedBurst", maxTokens: 30, refillRate: 30, refillIntervalMs: 3e4 },
-  voidedDaily: {
-    name: "voidedDaily",
-    maxTokens: 6e3,
-    refillRate: 6e3,
-    refillIntervalMs: 864e5
-  }
-};
-function createRateLimiter(buckets) {
-  const states = /* @__PURE__ */ new Map();
-  if (buckets) {
-    for (const bucket of buckets) {
-      states.set(bucket.name, {
-        tokens: bucket.maxTokens,
-        lastRefillTime: Date.now(),
-        config: bucket
-      });
-    }
-  }
-  return {
-    async acquire(bucket) {
-      const state = states.get(bucket);
-      if (!state) return;
-      const now = Date.now();
-      const elapsed = now - state.lastRefillTime;
-      const refill = Math.floor(
-        elapsed / state.config.refillIntervalMs * state.config.refillRate
-      );
-      if (refill > 0) {
-        state.tokens = Math.min(state.config.maxTokens, state.tokens + refill);
-        state.lastRefillTime = now;
-      }
-      if (state.tokens > 0) {
-        state.tokens--;
-        return;
-      }
-      const tokensNeeded = 1;
-      const waitMs = Math.ceil(
-        tokensNeeded / state.config.refillRate * state.config.refillIntervalMs
-      );
-      await new Promise((r) => setTimeout(r, waitMs));
-      const afterWait = Date.now();
-      const totalElapsed = afterWait - state.lastRefillTime;
-      const newTokens = Math.floor(
-        totalElapsed / state.config.refillIntervalMs * state.config.refillRate
-      );
-      state.tokens = Math.min(state.config.maxTokens, newTokens) - 1;
-      state.lastRefillTime = afterWait;
-    }
-  };
-}
-
 // src/paginate.ts
 async function* paginate(fetchPage, options) {
   let pageToken = options?.startPageToken;
@@ -1431,8 +1719,9 @@ async function paginateParallel(fetchPage, pageTokens, concurrency = 4) {
   return { items: allItems, nextPageToken: lastNextPageToken };
 }
 export {
-  ApiError,
+  PlayApiError,
   RATE_LIMIT_BUCKETS,
+  RESUMABLE_THRESHOLD,
   createApiClient,
   createEnterpriseClient,
   createGamesClient,