@gpc-cli/core 0.9.56 → 0.9.58

package/README.md

@@ -26,6 +26,7 @@ import {
 const result = await uploadRelease(context, {
   file: "app.aab",
   track: "internal",
+  validateOnly: true, // dry-run: server-side validation without committing
 });
 
 // Promote between tracks
@@ -37,7 +38,7 @@ await promoteRelease(context, {
 
 // Check vitals
 const vitals = await getVitalsOverview(context);
-console.log(formatOutput(vitals, "table"));
+console.log(formatOutput(vitals, "table")); // also: "json", "csv", "tsv"
 
 // Analyze bundle size
 const analysis = await analyzeBundle("./app.aab");
@@ -59,13 +60,13 @@ const analysis = await analyzeBundle("./app.aab");
 | **Users**         | `listUsers`, `inviteUser`, `updateUser`, `removeUser`                                                                                                                                      |
 | **Testers**       | `listTesters`, `addTesters`, `removeTesters`, `importTestersFromCsv`                                                                                                                       |
 | **Bundle**        | `analyzeBundle`, `compareBundles` (zero-dependency AAB/APK size analysis)                                                                                                                  |
-| **Publishing**    | `publish` (end-to-end: upload + track + notes + commit)                                                                                                                                    |
+| **Publishing**    | `publish` (end-to-end: upload + track + notes + commit; supports `validateOnly` dry-run)                                                                                                   |
 | **Changelog**     | `generateChangelog`, `fetchChangelog`, `formatChangelogEntry`, `buildLocaleBundle`, `renderPlayStore`, `renderMarkdown`, `renderJson`, `renderPrompt`, `translateBundle`, `resolveLocales` |
 | **Validation**    | `validateUploadFile`, `validateImage`, `validatePreSubmission`                                                                                                                             |
 
 ## Utilities
 
-- **Output formatting** — `formatOutput()`, `detectOutputFormat()`, `redactSensitive()`
+- **Output formatting** - `formatOutput(data, format)` supports `"json"`, `"table"`, `"csv"`, `"tsv"`; plus `detectOutputFormat()`, `redactSensitive()`
 - **Error hierarchy** — `GpcError`, `ConfigError`, `ApiError`, `NetworkError` with exit codes
 - **Audit logging** — `initAudit()`, `writeAuditLog()` for write operation tracking
 - **Path safety** — `safePath()`, `safePathWithin()` for path traversal prevention

package/dist/chunk-QIYAOW6R.js

@@ -0,0 +1,661 @@
+// src/commands/releases.ts
+import { stat as stat2 } from "fs/promises";
+import { extname as extname2 } from "path";
+import { PlayApiError } from "@gpc-cli/api";
+
+// src/errors.ts
+var GpcError = class extends Error {
+  constructor(message, code, exitCode, suggestion) {
+    super(message);
+    this.code = code;
+    this.exitCode = exitCode;
+    this.suggestion = suggestion;
+    this.name = "GpcError";
+  }
+  code;
+  exitCode;
+  suggestion;
+  toJSON() {
+    return {
+      success: false,
+      error: {
+        code: this.code,
+        message: this.message,
+        suggestion: this.suggestion
+      }
+    };
+  }
+};
+var ConfigError = class extends GpcError {
+  constructor(message, code, suggestion) {
+    super(message, code, 1, suggestion);
+    this.name = "ConfigError";
+  }
+};
+var ApiError = class extends GpcError {
+  constructor(message, code, statusCode, suggestion) {
+    super(message, code, 4, suggestion);
+    this.statusCode = statusCode;
+    this.name = "ApiError";
+  }
+  statusCode;
+};
+var NetworkError = class extends GpcError {
+  constructor(message, suggestion) {
+    super(message, "NETWORK_ERROR", 5, suggestion);
+    this.name = "NetworkError";
+  }
+};
+
+// src/utils/file-validation.ts
+import { open, stat } from "fs/promises";
+import { extname } from "path";
+var ZIP_MAGIC = Buffer.from([80, 75, 3, 4]);
+var MAX_APK_SIZE = 1024 * 1024 * 1024;
+var MAX_AAB_SIZE = 2 * 1024 * 1024 * 1024;
+var LARGE_FILE_THRESHOLD = 100 * 1024 * 1024;
+async function validateUploadFile(filePath) {
+  const errors = [];
+  const warnings = [];
+  const ext = extname(filePath).toLowerCase();
+  let fileType = "unknown";
+  if (ext === ".aab") {
+    fileType = "aab";
+  } else if (ext === ".apk") {
+    fileType = "apk";
+  } else {
+    errors.push(`Unsupported file extension "${ext}". Expected .aab or .apk`);
+  }
+  let sizeBytes;
+  try {
+    const stats = await stat(filePath);
+    sizeBytes = stats.size;
+    if (sizeBytes === 0) {
+      errors.push("File is empty (0 bytes)");
+    }
+  } catch {
+    errors.push(`File not found: ${filePath}`);
+    return { valid: false, fileType, sizeBytes: 0, errors, warnings };
+  }
+  if (fileType === "apk" && sizeBytes > MAX_APK_SIZE) {
+    errors.push(
+      `APK exceeds 1 GB limit (${formatSize(sizeBytes)}). Consider using AAB format instead.`
+    );
+  }
+  if (fileType === "aab" && sizeBytes > MAX_AAB_SIZE) {
+    errors.push(`AAB exceeds 2 GB limit (${formatSize(sizeBytes)}).`);
+  }
+  if (sizeBytes > LARGE_FILE_THRESHOLD && errors.length === 0) {
+    warnings.push(
+      `Large file (${formatSize(sizeBytes)}). Upload may take a while on slow connections.`
+    );
+  }
+  if (sizeBytes > 0) {
+    let fh;
+    try {
+      fh = await open(filePath, "r");
+      const buf = Buffer.alloc(4);
+      await fh.read(buf, 0, 4, 0);
+      if (!buf.equals(ZIP_MAGIC)) {
+        errors.push(
+          "File does not have valid ZIP magic bytes (PK\\x03\\x04). Both AAB and APK files must be valid ZIP archives."
+        );
+      }
+    } catch {
+      errors.push("Unable to read file header for validation");
+    } finally {
+      await fh?.close();
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    fileType,
+    sizeBytes,
+    errors,
+    warnings
+  };
+}
+function formatSize(bytes) {
+  if (bytes >= 1024 * 1024 * 1024) {
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+  }
+  if (bytes >= 1024 * 1024) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  }
+  if (bytes >= 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${bytes} B`;
+}
+
+// src/commands/releases.ts
+var BUNDLE_POLL_BACKOFF = [2e3, 3e3, 5e3, 8e3, 13e3];
+async function waitForBundleProcessing(client, packageName, editId, versionCode, backoff = BUNDLE_POLL_BACKOFF) {
+  for (let i = 0; i < backoff.length; i++) {
+    const bundles = await client.bundles.list(packageName, editId);
+    if (bundles.some((b) => b.versionCode === versionCode)) return;
+    await new Promise((r) => setTimeout(r, backoff[i]));
+  }
+  throw new GpcError(
+    `Bundle versionCode ${versionCode} not ready after ${backoff.length} poll attempts (~${Math.round(backoff.reduce((a, b) => a + b, 0) / 1e3)}s)`,
+    "BUNDLE_PROCESSING_TIMEOUT",
+    4,
+    "The AAB is still being processed by Google. Retry the upload, or use --status draft and commit later."
+  );
+}
+async function withRetryOnConflict(client, packageName, operation) {
+  const edit = await client.edits.insert(packageName);
+  try {
+    return await operation(edit);
+  } catch (error) {
+    const isConflict = error instanceof PlayApiError && error.statusCode === 409;
+    if (!isConflict) {
+      await client.edits.delete(packageName, edit.id).catch(() => {
+      });
+      throw error;
+    }
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    const freshEdit = await client.edits.insert(packageName);
+    try {
+      return await operation(freshEdit);
+    } catch (retryError) {
+      await client.edits.delete(packageName, freshEdit.id).catch(() => {
+      });
+      throw retryError;
+    }
+  }
+}
+var _consoleEditWarningShown = false;
+function warnAboutConcurrentEdits() {
+  if (_consoleEditWarningShown) return;
+  _consoleEditWarningShown = true;
+  process.emitWarning?.(
+    "If the Play Console has pending changes, they may be discarded when this edit is committed. Avoid making changes in the Play Console while CLI operations are in progress.",
+    "ConcurrentEditWarning"
+  );
+}
+function warnIfEditExpiring(edit) {
+  if (!edit.expiryTimeSeconds) return;
+  const expiryMs = Number(edit.expiryTimeSeconds) * 1e3;
+  const remainingMs = expiryMs - Date.now();
+  if (remainingMs < 5 * 60 * 1e3 && remainingMs > 0) {
+    const minutes = Math.round(remainingMs / 6e4);
+    process.emitWarning?.(
+      `Edit session expires in ~${minutes} minute${minutes !== 1 ? "s" : ""}. Long uploads may fail. Consider starting a fresh operation.`,
+      "EditExpiryWarning"
+    );
+  }
+}
+async function withFreshEdit(client, packageName, operation) {
+  const edit = await client.edits.insert(packageName);
+  try {
+    return await operation(edit.id);
+  } catch (error) {
+    if (error instanceof PlayApiError && error.code === "API_EDIT_EXPIRED") {
+      await client.edits.delete(packageName, edit.id).catch(() => {
+      });
+      const freshEdit = await client.edits.insert(packageName);
+      try {
+        return await operation(freshEdit.id);
+      } catch (retryError) {
+        await client.edits.delete(packageName, freshEdit.id).catch(() => {
+        });
+        throw retryError;
+      }
+    }
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function uploadRelease(client, packageName, filePath, options) {
+  const validation = await validateUploadFile(filePath);
+  if (options.dryRun) {
+    const plannedStatus = options.status || (options.userFraction ? "inProgress" : "completed");
+    let currentReleases = [];
+    const edit2 = await client.edits.insert(packageName);
+    try {
+      const trackData = await client.tracks.get(packageName, edit2.id, options.track);
+      currentReleases = (trackData.releases || []).map((r) => ({
+        versionCodes: r.versionCodes || [],
+        status: r.status,
+        ...r.userFraction !== void 0 && { userFraction: r.userFraction }
+      }));
+    } catch {
+    } finally {
+      await client.edits.delete(packageName, edit2.id).catch(() => {
+      });
+    }
+    return {
+      dryRun: true,
+      file: {
+        path: filePath,
+        valid: validation.valid,
+        errors: validation.errors,
+        warnings: validation.warnings
+      },
+      track: options.track,
+      currentReleases,
+      plannedRelease: {
+        status: plannedStatus,
+        ...options.userFraction !== void 0 && { userFraction: options.userFraction }
+      }
+    };
+  }
+  if (!validation.valid) {
+    throw new GpcError(
+      `File validation failed:
+${validation.errors.join("\n")}`,
+      "RELEASE_INVALID_FILE",
+      2,
+      "Check that the file is a valid AAB or APK and is not corrupted."
+    );
+  }
+  let fileSize = 0;
+  try {
+    const { size } = await stat2(filePath);
+    fileSize = size;
+  } catch {
+  }
+  if (options.onProgress) options.onProgress(0, fileSize);
+  const edit = await client.edits.insert(packageName);
+  warnIfEditExpiring(edit);
+  warnAboutConcurrentEdits();
+  try {
+    const isApk = extname2(filePath).toLowerCase() === ".apk";
+    const uploadOpts = {
+      ...options.uploadOptions,
+      onProgress: (event) => {
+        if (options.onProgress) options.onProgress(event.bytesUploaded, event.totalBytes);
+        if (options.onUploadProgress) options.onUploadProgress(event);
+      }
+    };
+    const bundle = isApk ? await client.apks.upload(packageName, edit.id, filePath, uploadOpts) : await client.bundles.upload(
+      packageName,
+      edit.id,
+      filePath,
+      uploadOpts,
+      options.deviceTierConfigId
+    );
+    if (!isApk) {
+      await waitForBundleProcessing(client, packageName, edit.id, bundle.versionCode);
+    }
+    if (options.mappingFile) {
+      await client.deobfuscation.upload(
+        packageName,
+        edit.id,
+        bundle.versionCode,
+        options.mappingFile,
+        options.mappingFileType
+      );
+    }
+    const release = {
+      versionCodes: [String(bundle.versionCode)],
+      status: options.status || (options.userFraction ? "inProgress" : "completed"),
+      ...options.userFraction && { userFraction: options.userFraction },
+      ...options.releaseNotes && { releaseNotes: options.releaseNotes },
+      ...options.releaseName && { name: options.releaseName }
+    };
+    await client.tracks.update(packageName, edit.id, options.track, release);
+    if (!options.commitOptions?.changesNotSentForReview) {
+      await client.edits.validate(packageName, edit.id);
+    }
+    if (options.validateOnly) {
+      await client.edits.delete(packageName, edit.id).catch(() => {
+      });
+      return {
+        versionCode: bundle.versionCode,
+        track: options.track,
+        status: release.status,
+        validateOnly: true
+      };
+    }
+    await client.edits.commit(packageName, edit.id, options.commitOptions);
+    return {
+      versionCode: bundle.versionCode,
+      track: options.track,
+      status: release.status
+    };
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function getReleasesStatus(client, packageName, trackFilter) {
+  const edit = await client.edits.insert(packageName);
+  try {
+    const tracks = trackFilter ? [await client.tracks.get(packageName, edit.id, trackFilter)] : await client.tracks.list(packageName, edit.id);
+    await client.edits.delete(packageName, edit.id);
+    const results = [];
+    for (const track of tracks) {
+      for (const release of track.releases || []) {
+        results.push({
+          track: track.track,
+          status: release.status,
+          versionCodes: release.versionCodes || [],
+          userFraction: release.userFraction,
+          releaseNotes: release.releaseNotes
+        });
+      }
+    }
+    return results;
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function promoteRelease(client, packageName, fromTrack, toTrack, options) {
+  if (options?.userFraction && (options.userFraction <= 0 || options.userFraction > 1)) {
+    throw new GpcError(
+      "Rollout percentage must be between 0 and 1 (e.g., 0.1 for 10%)",
+      "RELEASE_INVALID_FRACTION",
+      2,
+      "Use a decimal value like 0.1 for 10%, 0.5 for 50%, or 1.0 for 100%."
+    );
+  }
+  return withRetryOnConflict(client, packageName, async (edit) => {
+    const sourceTrack = await client.tracks.get(packageName, edit.id, fromTrack);
+    const currentRelease = sourceTrack.releases?.find(
+      (r) => r.status === "completed" || r.status === "inProgress"
+    );
+    if (!currentRelease) {
+      throw new GpcError(
+        `No active release found on track "${fromTrack}"`,
+        "RELEASE_NOT_FOUND",
+        1,
+        `Ensure there is a completed or in-progress release on the "${fromTrack}" track before promoting.`
+      );
+    }
+    const release = {
+      versionCodes: currentRelease.versionCodes,
+      status: options?.status || (options?.userFraction ? "inProgress" : "completed"),
+      ...options?.userFraction && { userFraction: options.userFraction },
+      releaseNotes: options?.releaseNotes || currentRelease.releaseNotes || []
+    };
+    await client.tracks.update(packageName, edit.id, toTrack, release);
+    if (!options?.commitOptions?.changesNotSentForReview) {
+      await client.edits.validate(packageName, edit.id);
+    }
+    await client.edits.commit(packageName, edit.id, options?.commitOptions);
+    return {
+      track: toTrack,
+      status: release.status,
+      versionCodes: release.versionCodes,
+      userFraction: release.userFraction
+    };
+  });
+}
+async function updateRollout(client, packageName, track, action, userFraction, commitOptions) {
+  const edit = await client.edits.insert(packageName);
+  try {
+    const trackData = await client.tracks.get(packageName, edit.id, track);
+    const currentRelease = trackData.releases?.find(
+      (r) => r.status === "inProgress" || r.status === "halted"
+    );
+    if (!currentRelease) {
+      throw new GpcError(
+        `No active rollout found on track "${track}"`,
+        "ROLLOUT_NOT_FOUND",
+        1,
+        `There is no in-progress or halted rollout on the "${track}" track. Start a staged rollout first with: gpc releases upload --track ${track} --status inProgress --fraction 0.1`
+      );
+    }
+    let newStatus;
+    let newFraction;
+    switch (action) {
+      case "increase":
+        if (!userFraction)
+          throw new GpcError(
+            "--to <percentage> is required for rollout increase",
+            "ROLLOUT_MISSING_FRACTION",
+            2,
+            "Specify the target rollout percentage with --to, e.g.: gpc rollout increase --to 0.5"
+          );
+        if (userFraction <= 0 || userFraction > 1) {
+          throw new GpcError(
+            "Rollout percentage must be between 0 and 1 (e.g., 0.1 for 10%)",
+            "RELEASE_INVALID_FRACTION",
+            2,
+            "Use a decimal value like 0.1 for 10%, 0.5 for 50%, or 1.0 for 100%."
+          );
+        }
+        newStatus = "inProgress";
+        newFraction = userFraction;
+        break;
+      case "halt":
+        newStatus = "halted";
+        newFraction = currentRelease.userFraction;
+        break;
+      case "resume":
+        newStatus = "inProgress";
+        newFraction = currentRelease.userFraction;
+        break;
+      case "complete":
+        newStatus = "completed";
+        newFraction = void 0;
+        break;
+    }
+    const release = {
+      versionCodes: currentRelease.versionCodes,
+      status: newStatus,
+      ...newFraction !== void 0 && { userFraction: newFraction },
+      releaseNotes: currentRelease.releaseNotes || []
+    };
+    await client.tracks.update(packageName, edit.id, track, release);
+    if (!commitOptions?.changesNotSentForReview) {
+      await client.edits.validate(packageName, edit.id);
+    }
+    await client.edits.commit(packageName, edit.id, commitOptions);
+    return {
+      track,
+      status: newStatus,
+      versionCodes: release.versionCodes,
+      userFraction: newFraction
+    };
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function listTracks(client, packageName) {
+  const edit = await client.edits.insert(packageName);
+  try {
+    const tracks = await client.tracks.list(packageName, edit.id);
+    await client.edits.delete(packageName, edit.id);
+    return tracks;
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function createTrack(client, packageName, trackName, commitOptions) {
+  if (!trackName || trackName.trim().length === 0) {
+    throw new GpcError(
+      "Track name must not be empty",
+      "TRACK_INVALID_NAME",
+      2,
+      "Provide a valid custom track name, e.g.: gpc tracks create my-qa-track"
+    );
+  }
+  const edit = await client.edits.insert(packageName);
+  try {
+    const track = await client.tracks.create(packageName, edit.id, trackName);
+    if (!commitOptions?.changesNotSentForReview) {
+      await client.edits.validate(packageName, edit.id);
+    }
+    await client.edits.commit(packageName, edit.id, commitOptions);
+    return track;
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function updateTrackConfig(client, packageName, trackName, config, commitOptions) {
+  if (!trackName || trackName.trim().length === 0) {
+    throw new GpcError(
+      "Track name must not be empty",
+      "TRACK_INVALID_NAME",
+      2,
+      "Provide a valid track name."
+    );
+  }
+  const edit = await client.edits.insert(packageName);
+  try {
+    const release = {
+      versionCodes: config["versionCodes"] || [],
+      status: config["status"] || "completed"
+    };
+    if (config["userFraction"] !== void 0) {
+      release.userFraction = config["userFraction"];
+    }
+    if (config["releaseNotes"]) {
+      release.releaseNotes = config["releaseNotes"];
+    }
+    if (config["name"]) {
+      release.name = config["name"];
+    }
+    const track = await client.tracks.update(packageName, edit.id, trackName, release);
+    if (!commitOptions?.changesNotSentForReview) {
+      await client.edits.validate(packageName, edit.id);
+    }
+    await client.edits.commit(packageName, edit.id, commitOptions);
+    return track;
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function fetchReleaseNotes(client, packageName, track) {
+  const edit = await client.edits.insert(packageName);
+  try {
+    const trackData = await client.tracks.get(packageName, edit.id, track);
+    const release = trackData.releases?.find((r) => r.status === "completed" || r.status === "inProgress") ?? trackData.releases?.[0];
+    if (!release) {
+      throw new GpcError(
+        `No release found on track "${track}" to copy notes from`,
+        "RELEASE_NOT_FOUND",
+        1,
+        `Ensure there is a release on the "${track}" track.`
+      );
+    }
+    return release.releaseNotes ?? [];
+  } finally {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+  }
+}
+async function applyReleaseNotes(client, packageName, track, releaseNotes, commitOptions) {
+  return withRetryOnConflict(client, packageName, async (edit) => {
+    const trackData = await client.tracks.get(packageName, edit.id, track);
+    const draft = trackData.releases?.find((r) => r.status === "draft");
+    if (!draft) {
+      throw new GpcError(
+        `No draft release found on track "${track}"`,
+        "RELEASE_NO_DRAFT",
+        1,
+        `Upload an AAB/APK first to create a draft, or check the --track value. Current track: "${track}".`
+      );
+    }
+    const patched = {
+      ...draft,
+      releaseNotes
+    };
+    await client.tracks.update(packageName, edit.id, track, patched);
+    if (!commitOptions?.changesNotSentForReview) {
+      await client.edits.validate(packageName, edit.id);
+    }
+    await client.edits.commit(packageName, edit.id, commitOptions);
+    return {
+      track,
+      versionCodes: draft.versionCodes || [],
+      localeCount: releaseNotes.length,
+      releaseNotes
+    };
+  });
+}
+async function diffReleases(client, packageName, fromTrack, toTrack) {
+  const edit = await client.edits.insert(packageName);
+  try {
+    const [fromData, toData] = await Promise.all([
+      client.tracks.get(packageName, edit.id, fromTrack),
+      client.tracks.get(packageName, edit.id, toTrack)
+    ]);
+    await client.edits.delete(packageName, edit.id);
+    const fromRelease = fromData.releases?.[0];
+    const toRelease = toData.releases?.[0];
+    const diffs = [];
+    const fields = ["versionCodes", "status", "userFraction", "releaseNotes", "name"];
+    for (const field of fields) {
+      const v1 = fromRelease ? JSON.stringify(fromRelease[field] ?? null) : "null";
+      const v2 = toRelease ? JSON.stringify(toRelease[field] ?? null) : "null";
+      if (v1 !== v2) {
+        diffs.push({ field, track1Value: v1, track2Value: v2 });
+      }
+    }
+    return { fromTrack, toTrack, diffs };
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function uploadExternallyHosted(client, packageName, data, commitOptions) {
+  if (!data.externallyHostedUrl) {
+    throw new GpcError(
+      "externallyHostedUrl is required",
+      "EXTERNAL_APK_MISSING_URL",
+      2,
+      "Provide a valid URL for the externally hosted APK."
+    );
+  }
+  if (!data.packageName) {
+    throw new GpcError(
+      "packageName is required in externally hosted APK data",
+      "EXTERNAL_APK_MISSING_PACKAGE",
+      2,
+      "Include the packageName field in the APK configuration."
+    );
+  }
+  const edit = await client.edits.insert(packageName);
+  try {
+    const result = await client.apks.addExternallyHosted(packageName, edit.id, data);
+    if (!commitOptions?.changesNotSentForReview) {
+      await client.edits.validate(packageName, edit.id);
+    }
+    await client.edits.commit(packageName, edit.id, commitOptions);
+    return result;
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+
+export {
+  GpcError,
+  ConfigError,
+  ApiError,
+  NetworkError,
+  validateUploadFile,
+  waitForBundleProcessing,
+  withFreshEdit,
+  uploadRelease,
+  getReleasesStatus,
+  promoteRelease,
+  updateRollout,
+  listTracks,
+  createTrack,
+  updateTrackConfig,
+  fetchReleaseNotes,
+  applyReleaseNotes,
+  diffReleases,
+  uploadExternallyHosted
+};
+//# sourceMappingURL=chunk-QIYAOW6R.js.map