@absolutejs/deploy 0.22.0 → 0.24.0

package/dist/appStoreConnect.js

@@ -0,0 +1,585 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = import.meta.require;
+
+// src/appStoreConnect.ts
+import { createHash, createPrivateKey, sign } from "crypto";
+import path from "path";
+var API_ROOT = "https://api.appstoreconnect.apple.com/v1";
+var DEFAULT_RECEIPT_PREFIX = "absolutejs/app-store-connect-receipts";
+var SHA256_PATTERN = /^[a-f0-9]{64}$/;
+
+class AppStoreConnectReleaseError extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "AppStoreConnectReleaseError";
+    this.status = status;
+  }
+}
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var encodedJson = (value) => new TextEncoder().encode(`${JSON.stringify(value, null, 2)}
+`);
+var decodedJson = (value) => JSON.parse(new TextDecoder().decode(value));
+var sha256Bytes = (value) => createHash("sha256").update(value).digest("hex");
+var hashIdentity = (value) => createHash("sha256").update(value).digest("hex");
+var isIsoTimestamp = (value) => typeof value === "string" && !Number.isNaN(Date.parse(value)) && new Date(value).toISOString() === value;
+var normalizedPrefix = (value) => {
+  const prefix = value.replace(/^\/+|\/+$/g, "");
+  if (!prefix || prefix.split("/").some((part) => part === "." || part === ".."))
+    throw new AppStoreConnectReleaseError("App Store Connect receipt prefix is invalid");
+  return prefix;
+};
+var normalizedIntent = (target = {}) => {
+  const groups = [
+    ...new Set((target.groups ?? []).map((value) => value.trim()))
+  ].sort();
+  if (groups.some((value) => !value))
+    throw new AppStoreConnectReleaseError("TestFlight group names or IDs must not be empty");
+  const locales = new Set;
+  const whatsNew = [...target.whatsNew ?? []].map(({ locale, text }) => ({ locale: locale.trim(), text: text.trim() })).sort((left, right) => left.locale.localeCompare(right.locale));
+  for (const item of whatsNew) {
+    if (!item.locale || !item.text || locales.has(item.locale))
+      throw new AppStoreConnectReleaseError("TestFlight notes require unique locales and non-empty text");
+    locales.add(item.locale);
+  }
+  if (target.submitForReview && groups.length === 0)
+    throw new AppStoreConnectReleaseError("TestFlight beta review requires at least one external group");
+  return { groups, submitForReview: target.submitForReview ?? false, whatsNew };
+};
+var parseReceipt = (value) => {
+  if (!isRecord(value) || value.format !== 1 || value.provider !== "app-store-connect" || typeof value.appleAppId !== "string" || typeof value.releaseId !== "string" || typeof value.sha256 !== "string" || !SHA256_PATTERN.test(value.sha256) || !Number.isSafeInteger(value.buildNumber) || Number(value.buildNumber) < 1 || typeof value.marketingVersion !== "string" || !isIsoTimestamp(value.updatedAt) || ![
+    "preparing",
+    "uploading",
+    "processing",
+    "distributed",
+    "review-submitted"
+  ].includes(String(value.stage)) || !isRecord(value.intent))
+    throw new AppStoreConnectReleaseError("App Store Connect release receipt is invalid");
+  for (const field of ["buildId", "buildUploadFileId", "buildUploadId"])
+    if (value[field] !== undefined && typeof value[field] !== "string")
+      throw new AppStoreConnectReleaseError("App Store Connect release receipt is invalid");
+  const buildId = typeof value.buildId === "string" ? value.buildId : undefined;
+  const buildUploadFileId = typeof value.buildUploadFileId === "string" ? value.buildUploadFileId : undefined;
+  const buildUploadId = typeof value.buildUploadId === "string" ? value.buildUploadId : undefined;
+  return {
+    appleAppId: value.appleAppId,
+    buildNumber: Number(value.buildNumber),
+    format: 1,
+    intent: normalizedIntent(value.intent),
+    marketingVersion: value.marketingVersion,
+    provider: "app-store-connect",
+    releaseId: value.releaseId,
+    sha256: value.sha256,
+    stage: value.stage,
+    updatedAt: value.updatedAt,
+    ...buildId ? { buildId } : {},
+    ...buildUploadFileId ? { buildUploadFileId } : {},
+    ...buildUploadId ? { buildUploadId } : {}
+  };
+};
+var base64url = (value) => Buffer.from(value).toString("base64url");
+var createTokenProvider = (auth, clock) => {
+  if (!auth.issuerId || !auth.keyId || !auth.privateKey)
+    throw new AppStoreConnectReleaseError("App Store Connect API credentials are incomplete");
+  const key = createPrivateKey(auth.privateKey);
+  return () => {
+    const issuedAt = Math.floor(clock().getTime() / 1000);
+    const header = base64url(JSON.stringify({ alg: "ES256", kid: auth.keyId, typ: "JWT" }));
+    const claims = base64url(JSON.stringify({
+      aud: "appstoreconnect-v1",
+      exp: issuedAt + 1199,
+      iat: issuedAt,
+      iss: auth.issuerId
+    }));
+    const payload = `${header}.${claims}`;
+    return `${payload}.${base64url(sign("sha256", Buffer.from(payload), { dsaEncoding: "ieee-p1363", key }))}`;
+  };
+};
+var responseError = async (response) => {
+  const body = await response.text().catch(() => "");
+  return new AppStoreConnectReleaseError(`App Store Connect request failed (${response.status})${body ? `: ${body}` : ""}`, response.status);
+};
+var createAppStoreConnectClient = (options) => {
+  const requestFetch = options.fetch ?? fetch;
+  const token = createTokenProvider(options.auth, options.clock ?? (() => new Date));
+  const request = async (route, init = {}) => {
+    const response = await requestFetch(`${API_ROOT}${route}`, {
+      ...init,
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${token()}`,
+        ...init.body ? { "Content-Type": "application/json" } : {},
+        ...init.headers
+      }
+    });
+    if (!response.ok)
+      throw await responseError(response);
+    return response.status === 204 ? undefined : await response.json();
+  };
+  const dataList = async (route) => {
+    const result = [];
+    let next = route;
+    while (next) {
+      const page = await request(next.startsWith(API_ROOT) ? next.slice(API_ROOT.length) : next);
+      if (Array.isArray(page.data))
+        result.push(...page.data.filter(isRecord));
+      const links = isRecord(page.links) ? page.links : undefined;
+      next = typeof links?.next === "string" ? links.next : undefined;
+    }
+    return result;
+  };
+  const buildFrom = (data) => {
+    const attributes = isRecord(data.attributes) ? data.attributes : {};
+    return {
+      id: String(data.id),
+      processingState: String(attributes.processingState),
+      version: String(attributes.version)
+    };
+  };
+  const uploadFrom = (data) => {
+    const attributes = isRecord(data.attributes) ? data.attributes : {};
+    const state = isRecord(attributes.state) ? attributes.state.state : attributes.state;
+    return {
+      id: String(data.id),
+      state: String(state)
+    };
+  };
+  return {
+    findAppId: async ({ bundleId, signal }) => {
+      const items = await dataList(`/apps?filter[bundleId]=${encodeURIComponent(bundleId)}&fields[apps]=bundleId&limit=2`);
+      const exact = items.filter((item) => isRecord(item.attributes) && item.attributes.bundleId === bundleId);
+      if (exact.length !== 1)
+        throw new AppStoreConnectReleaseError(`Expected one App Store Connect app for bundle ID ${bundleId}`);
+      signal?.throwIfAborted();
+      return String(exact[0].id);
+    },
+    listBuildNumbers: async ({ appId, signal }) => {
+      signal?.throwIfAborted();
+      const items = await dataList(`/builds?filter[app]=${encodeURIComponent(appId)}&fields[builds]=version&limit=200`);
+      return items.map((item) => Number(isRecord(item.attributes) ? item.attributes.version : NaN)).filter((value) => Number.isSafeInteger(value) && value > 0);
+    },
+    findBuild: async ({ appId, buildNumber, signal }) => {
+      signal?.throwIfAborted();
+      const items = await dataList(`/builds?filter[app]=${encodeURIComponent(appId)}&filter[version]=${buildNumber}&fields[builds]=version,processingState&limit=2`);
+      return items.length ? buildFrom(items[0]) : null;
+    },
+    findBuildUpload: async ({
+      appId,
+      buildNumber,
+      marketingVersion,
+      signal
+    }) => {
+      signal?.throwIfAborted();
+      const items = await dataList(`/apps/${encodeURIComponent(appId)}/buildUploads?filter[cfBundleVersion]=${buildNumber}&filter[cfBundleShortVersionString]=${encodeURIComponent(marketingVersion)}&filter[platform]=IOS&fields[buildUploads]=state,cfBundleVersion,cfBundleShortVersionString&limit=2`);
+      return items.length ? uploadFrom(items[0]) : null;
+    },
+    createBuildUpload: async ({
+      appId,
+      buildNumber,
+      marketingVersion,
+      signal
+    }) => {
+      const response = await request("/buildUploads", {
+        method: "POST",
+        signal,
+        body: JSON.stringify({
+          data: {
+            type: "buildUploads",
+            attributes: {
+              cfBundleVersion: String(buildNumber),
+              cfBundleShortVersionString: marketingVersion,
+              platform: "IOS"
+            },
+            relationships: { app: { data: { type: "apps", id: appId } } }
+          }
+        })
+      });
+      return uploadFrom(response.data);
+    },
+    getBuildUpload: async ({ buildUploadId, signal }) => {
+      const response = await request(`/buildUploads/${encodeURIComponent(buildUploadId)}?fields[buildUploads]=state`, { signal });
+      return uploadFrom(response.data);
+    },
+    createBuildUploadFile: async ({
+      buildUploadId,
+      bytes,
+      fileName,
+      signal
+    }) => {
+      const response = await request("/buildUploadFiles", {
+        method: "POST",
+        signal,
+        body: JSON.stringify({
+          data: {
+            type: "buildUploadFiles",
+            attributes: {
+              assetType: "ASSET",
+              fileName,
+              fileSize: bytes,
+              uti: "com.apple.ipa"
+            },
+            relationships: {
+              buildUpload: {
+                data: { type: "buildUploads", id: buildUploadId }
+              }
+            }
+          }
+        })
+      });
+      return String(response.data.id);
+    },
+    findBuildUploadFile: async ({ buildUploadId, signal }) => {
+      signal?.throwIfAborted();
+      const items = await dataList(`/buildUploads/${encodeURIComponent(buildUploadId)}/buildUploadFiles?fields[buildUploadFiles]=fileName&limit=2`);
+      return items.length ? String(items[0].id) : null;
+    },
+    uploadBuildFile: async ({ artifactPath, fileId, signal }) => {
+      const response = await request(`/buildUploadFiles/${encodeURIComponent(fileId)}?fields[buildUploadFiles]=uploadOperations`, { signal });
+      const data = response.data;
+      const attrs = isRecord(data.attributes) ? data.attributes : {};
+      const operations = Array.isArray(attrs.uploadOperations) ? attrs.uploadOperations.filter(isRecord) : [];
+      if (!operations.length)
+        throw new AppStoreConnectReleaseError("App Store Connect returned no IPA upload operations");
+      await Promise.all(operations.map(async (operation) => {
+        const offset = Number(operation.offset);
+        const length = Number(operation.length);
+        const headers = new Headers;
+        if (Array.isArray(operation.requestHeaders)) {
+          for (const entry of operation.requestHeaders)
+            if (isRecord(entry))
+              headers.set(String(entry.name), String(entry.value));
+        }
+        const upload = await requestFetch(String(operation.url), {
+          method: String(operation.method),
+          headers,
+          body: Bun.file(artifactPath).slice(offset, offset + length),
+          signal
+        });
+        if (!upload.ok)
+          throw await responseError(upload);
+      }));
+    },
+    commitBuildUploadFile: async ({ fileId, sha256, signal }) => {
+      await request(`/buildUploadFiles/${encodeURIComponent(fileId)}`, {
+        method: "PATCH",
+        signal,
+        body: JSON.stringify({
+          data: {
+            type: "buildUploadFiles",
+            id: fileId,
+            attributes: {
+              uploaded: true,
+              sourceFileChecksums: {
+                file: { algorithm: "SHA_256", hash: sha256 }
+              }
+            }
+          }
+        })
+      });
+    },
+    resolveGroups: async ({ appId, groups, signal }) => {
+      signal?.throwIfAborted();
+      const items = await dataList(`/betaGroups?filter[app]=${encodeURIComponent(appId)}&fields[betaGroups]=name,isInternalGroup&limit=200`);
+      return groups.map((requested) => {
+        const matches = items.filter((item2) => item2.id === requested || isRecord(item2.attributes) && item2.attributes.name === requested);
+        if (matches.length !== 1)
+          throw new AppStoreConnectReleaseError(`Expected one TestFlight group matching ${requested}`);
+        const item = matches[0];
+        const attributes = item.attributes;
+        return {
+          id: String(item.id),
+          isInternal: attributes.isInternalGroup === true,
+          name: String(attributes.name)
+        };
+      });
+    },
+    addBuildToGroup: async ({ buildId, groupId, signal }) => {
+      await request(`/betaGroups/${encodeURIComponent(groupId)}/relationships/builds`, {
+        method: "POST",
+        signal,
+        body: JSON.stringify({ data: [{ type: "builds", id: buildId }] })
+      });
+    },
+    upsertWhatsNew: async ({ buildId, locale, text, signal }) => {
+      const items = await dataList(`/builds/${encodeURIComponent(buildId)}/betaBuildLocalizations?fields[betaBuildLocalizations]=locale,whatsNew&limit=200`);
+      const existing = items.find((item) => isRecord(item.attributes) && item.attributes.locale === locale);
+      if (existing) {
+        await request(`/betaBuildLocalizations/${encodeURIComponent(String(existing.id))}`, {
+          method: "PATCH",
+          signal,
+          body: JSON.stringify({
+            data: {
+              type: "betaBuildLocalizations",
+              id: existing.id,
+              attributes: { whatsNew: text }
+            }
+          })
+        });
+      } else {
+        await request("/betaBuildLocalizations", {
+          method: "POST",
+          signal,
+          body: JSON.stringify({
+            data: {
+              type: "betaBuildLocalizations",
+              attributes: { locale, whatsNew: text },
+              relationships: {
+                build: { data: { type: "builds", id: buildId } }
+              }
+            }
+          })
+        });
+      }
+    },
+    submitBetaReview: async ({ buildId, signal }) => {
+      await request("/betaAppReviewSubmissions", {
+        method: "POST",
+        signal,
+        body: JSON.stringify({
+          data: {
+            type: "betaAppReviewSubmissions",
+            relationships: { build: { data: { type: "builds", id: buildId } } }
+          }
+        })
+      });
+    },
+    hasBetaReviewSubmission: async ({ buildId, signal }) => {
+      const response = await request(`/builds/${encodeURIComponent(buildId)}/relationships/betaAppReviewSubmission`, { signal });
+      return isRecord(response.data) && typeof response.data.id === "string";
+    }
+  };
+};
+var createAppStoreConnectReleasePublisher = (options) => {
+  const clock = options.clock ?? (() => new Date);
+  const client = options.client ?? (options.auth ? createAppStoreConnectClient({ auth: options.auth, clock }) : undefined);
+  if (!client)
+    throw new AppStoreConnectReleaseError("App Store Connect auth or client is required");
+  const prefix = normalizedPrefix(options.receiptPrefix ?? DEFAULT_RECEIPT_PREFIX);
+  const maxWaitMs = options.maxWaitMs ?? 20 * 60000;
+  const pollIntervalMs = options.pollIntervalMs ?? 5000;
+  const preparationKey = (bundleId, buildIdentity) => `${prefix}/${hashIdentity(bundleId)}/preparations/${hashIdentity(buildIdentity)}.json`;
+  const receiptKey = (appId, releaseId, intent) => `${prefix}/${hashIdentity(appId)}/${releaseId}/${hashIdentity(JSON.stringify(intent))}.json`;
+  const readStored = async (key) => {
+    const bytes = await options.receiptStore.get(key);
+    if (!bytes)
+      return null;
+    const head = await options.receiptStore.head(key);
+    if (!head || head.size !== bytes.byteLength || head.metadata?.sha256 !== sha256Bytes(bytes))
+      throw new AppStoreConnectReleaseError("Stored App Store Connect state failed integrity verification");
+    return decodedJson(bytes);
+  };
+  const writeStored = async (key, value, type) => {
+    const bytes = encodedJson(value);
+    await options.receiptStore.put(key, bytes, {
+      cacheControl: "no-cache",
+      contentType: "application/json",
+      maxBytes: bytes.byteLength,
+      metadata: { sha256: sha256Bytes(bytes), type }
+    });
+  };
+  const waitForBuild = async (appId, buildNumber, buildUploadId, signal) => {
+    const deadline = Date.now() + maxWaitMs;
+    while (Date.now() <= deadline) {
+      signal?.throwIfAborted();
+      const build = await client.findBuild({ appId, buildNumber, signal });
+      if (build?.processingState === "VALID")
+        return build;
+      if (build && (build.processingState === "FAILED" || build.processingState === "INVALID"))
+        throw new AppStoreConnectReleaseError(`Apple rejected build ${buildNumber} during processing (${build.processingState})`);
+      const upload = await client.getBuildUpload({ buildUploadId, signal });
+      if (upload.state === "FAILED")
+        throw new AppStoreConnectReleaseError(`Apple rejected build upload ${buildUploadId}`);
+      await Bun.sleep(pollIntervalMs);
+    }
+    throw new AppStoreConnectReleaseError(`Timed out waiting for Apple to process build ${buildNumber}`);
+  };
+  return {
+    ...options.registry,
+    prepareIosRelease: async ({ buildIdentity, bundleId, signal }) => {
+      if (!buildIdentity)
+        throw new AppStoreConnectReleaseError("App Store Connect build identity is invalid");
+      const key = preparationKey(bundleId, buildIdentity);
+      const stored = await readStored(key);
+      if (isRecord(stored) && stored.bundleId === bundleId && stored.buildIdentity === buildIdentity && Number.isSafeInteger(stored.buildNumber) && Number(stored.buildNumber) > 0)
+        return { buildNumber: Number(stored.buildNumber) };
+      const appleAppId = await client.findAppId({ bundleId, signal });
+      const numbers = await client.listBuildNumbers({
+        appId: appleAppId,
+        signal
+      });
+      const highest = numbers.reduce((maximum, value) => Math.max(maximum, value), 0);
+      if (!Number.isSafeInteger(highest) || highest >= Number.MAX_SAFE_INTEGER)
+        throw new AppStoreConnectReleaseError("App Store Connect cannot allocate another iOS build number");
+      const buildNumber = highest + 1;
+      await writeStored(key, {
+        appleAppId,
+        buildIdentity,
+        buildNumber,
+        bundleId,
+        format: 1,
+        preparedAt: clock().toISOString()
+      }, "app-store-connect-build-preparation");
+      return { buildNumber };
+    },
+    publish: async (input) => {
+      const publication = await options.registry.publish(input);
+      const metadata = publication.record.metadata;
+      const target = input.appStoreConnect ?? options.target;
+      if (!target)
+        return publication;
+      if (metadata.platform !== "ios" || metadata.type !== "ipa")
+        throw new AppStoreConnectReleaseError("App Store Connect publishing requires an iOS IPA release");
+      if (!metadata.signed || !metadata.buildNumber)
+        throw new AppStoreConnectReleaseError("App Store Connect publishing requires a signed, versioned IPA");
+      const intent = normalizedIntent(target);
+      const appleAppId = await client.findAppId({
+        bundleId: metadata.appId,
+        signal: input.signal
+      });
+      const key = receiptKey(appleAppId, metadata.releaseId, intent);
+      const existingValue = await readStored(key);
+      let receipt = existingValue ? parseReceipt(existingValue) : {
+        appleAppId,
+        buildNumber: metadata.buildNumber,
+        format: 1,
+        intent,
+        marketingVersion: metadata.marketingVersion,
+        provider: "app-store-connect",
+        releaseId: metadata.releaseId,
+        sha256: metadata.sha256,
+        stage: "preparing",
+        updatedAt: clock().toISOString()
+      };
+      const writeReceipt = async (values) => {
+        receipt = { ...receipt, ...values, updatedAt: clock().toISOString() };
+        await writeStored(key, receipt, "app-store-connect-release-receipt");
+      };
+      if (receipt.stage === "distributed" || receipt.stage === "review-submitted")
+        return { ...publication, appStoreConnect: { receipt, reused: true } };
+      let upload = receipt.buildUploadId ? await client.getBuildUpload({
+        buildUploadId: receipt.buildUploadId,
+        signal: input.signal
+      }) : await client.findBuildUpload({
+        appId: appleAppId,
+        buildNumber: metadata.buildNumber,
+        marketingVersion: metadata.marketingVersion,
+        signal: input.signal
+      });
+      if (!upload)
+        upload = await client.createBuildUpload({
+          appId: appleAppId,
+          buildNumber: metadata.buildNumber,
+          marketingVersion: metadata.marketingVersion,
+          signal: input.signal
+        });
+      await writeReceipt({ buildUploadId: upload.id, stage: "uploading" });
+      let build = await client.findBuild({
+        appId: appleAppId,
+        buildNumber: metadata.buildNumber,
+        signal: input.signal
+      });
+      if (!build || build.processingState !== "VALID") {
+        let fileId = receipt.buildUploadFileId;
+        if (!fileId) {
+          fileId = await client.findBuildUploadFile({
+            buildUploadId: upload.id,
+            signal: input.signal
+          }) ?? await client.createBuildUploadFile({
+            buildUploadId: upload.id,
+            bytes: metadata.bytes,
+            fileName: metadata.artifact,
+            signal: input.signal
+          });
+          await writeReceipt({ buildUploadFileId: fileId });
+        }
+        if (upload.state === "AWAITING_UPLOAD") {
+          const artifactPath = path.join(input.releaseRoot, metadata.artifact);
+          await client.uploadBuildFile({
+            artifactPath,
+            fileId,
+            signal: input.signal
+          });
+          await client.commitBuildUploadFile({
+            fileId,
+            sha256: metadata.sha256,
+            signal: input.signal
+          });
+        }
+        await writeReceipt({ stage: "processing" });
+        build = await waitForBuild(appleAppId, metadata.buildNumber, upload.id, input.signal);
+      }
+      await writeReceipt({ buildId: build.id });
+      const groups = await client.resolveGroups({
+        appId: appleAppId,
+        groups: intent.groups,
+        signal: input.signal
+      });
+      if (intent.submitForReview && groups.some((group) => group.isInternal))
+        throw new AppStoreConnectReleaseError("TestFlight beta review may only be requested for external groups");
+      for (const note of intent.whatsNew)
+        await client.upsertWhatsNew({
+          buildId: build.id,
+          locale: note.locale,
+          text: note.text,
+          signal: input.signal
+        });
+      for (const group of groups)
+        await client.addBuildToGroup({
+          buildId: build.id,
+          groupId: group.id,
+          signal: input.signal
+        });
+      if (intent.submitForReview && !await client.hasBetaReviewSubmission({
+        buildId: build.id,
+        signal: input.signal
+      }))
+        await client.submitBetaReview({
+          buildId: build.id,
+          signal: input.signal
+        });
+      await writeReceipt({
+        stage: intent.submitForReview ? "review-submitted" : "distributed"
+      });
+      return { ...publication, appStoreConnect: { receipt, reused: false } };
+    }
+  };
+};
+export {
+  createAppStoreConnectReleasePublisher,
+  createAppStoreConnectClient,
+  AppStoreConnectReleaseError
+};
+
+//# debugId=EB7E25D0A1E879F564756E2164756E21
+//# sourceMappingURL=appStoreConnect.js.map