@gpc-cli/api 1.0.20 → 1.0.22

package/dist/index.js

@@ -21,8 +21,334 @@ var PlayApiError = 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 >= totalBytes) {
+              const completionResult = await fetchCompletionResponse(sessionUri, totalBytes, ctx);
+              if (completionResult) {
+                result = completionResult;
+                break;
+              }
+              result = { complete: true, response: { data: {}, status: 200 } };
+              break;
+            }
+            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;
+      }
+    }
+    try {
+      const serverOffset = await queryProgress(sessionUri, totalBytes, ctx);
+      if (serverOffset >= totalBytes) {
+        const completionResult = await fetchCompletionResponse(sessionUri, totalBytes, ctx);
+        if (completionResult?.response) {
+          return completionResult.response;
+        }
+        return { data: {}, status: 200 };
+      }
+    } catch {
+    }
+    throw new PlayApiError(
+      "Upload finished sending all bytes but did not receive a completion response",
+      "UPLOAD_NO_COMPLETION",
+      void 0,
+      `The upload session may still be valid. Resume with: --resume-uri "${sessionUri}"`
+    );
+  } 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();
+    let data;
+    try {
+      data = text ? JSON.parse(text) : {};
+    } catch {
+      data = {};
+    }
+    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 fetchCompletionResponse(sessionUri, totalBytes, ctx) {
+  const token = await ctx.getAccessToken();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 3e4);
+  try {
+    const response = await fetch(sessionUri, {
+      method: "PUT",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Length": "0",
+        "Content-Range": `bytes */${totalBytes}`
+      },
+      signal: controller.signal
+    });
+    if (response.status === 200 || response.status === 201) {
+      const text = await response.text();
+      let data;
+      try {
+        data = text ? JSON.parse(text) : {};
+      } catch {
+        data = {};
+      }
+      return { complete: true, response: { data, status: response.status } };
+    }
+    await response.body?.cancel();
+    return void 0;
+  } catch {
+    return void 0;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function queryProgress(sessionUri, totalBytes, ctx) {
+  const token = await ctx.getAccessToken();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 3e4);
+  let response;
+  try {
+    response = await fetch(sessionUri, {
+      method: "PUT",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Length": "0",
+        "Content-Range": `bytes */${totalBytes}`
+      },
+      signal: controller.signal
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+  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();
 }
@@ -60,14 +386,14 @@ function validateFilePath(filePath) {
 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) {
@@ -120,17 +446,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;
@@ -144,7 +470,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();
@@ -181,7 +507,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,
@@ -217,7 +543,7 @@ 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;
@@ -237,7 +563,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;
@@ -268,7 +594,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();
@@ -302,7 +628,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",
@@ -339,7 +665,7 @@ 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;
@@ -359,7 +685,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;
@@ -395,6 +721,43 @@ 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);
     },
@@ -488,11 +851,12 @@ 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 PlayApiError(
@@ -769,7 +1133,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`,
@@ -843,6 +1206,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}`
         );
@@ -1138,12 +1507,78 @@ function createApiClient(options) {
   };
 }
 
+// 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;
+    }
+  };
+}
+
 // src/reporting-client.ts
 var REPORTING_BASE_URL = "https://playdeveloperreporting.googleapis.com/v1beta1";
 function createReportingClient(options) {
   const http = createHttpClient({ ...options, baseUrl: REPORTING_BASE_URL });
+  const reportingBucket = RATE_LIMIT_BUCKETS["reporting"];
+  const limiter = options.rateLimiter ?? createRateLimiter(reportingBucket ? [reportingBucket] : []);
   return {
     async queryMetricSet(packageName, metricSet, query) {
+      await limiter.acquire("reporting");
       const { data } = await http.post(
         `/apps/${packageName}/${metricSet}:query`,
         query
@@ -1151,10 +1586,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);
@@ -1166,6 +1603,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;
@@ -1313,68 +1751,6 @@ function createEnterpriseClient(options) {
   };
 }
 
-// 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;
@@ -1429,6 +1805,7 @@ async function paginateParallel(fetchPage, pageTokens, concurrency = 4) {
 export {
   PlayApiError,
   RATE_LIMIT_BUCKETS,
+  RESUMABLE_THRESHOLD,
   createApiClient,
   createEnterpriseClient,
   createGamesClient,