@absolutejs/deploy 0.23.0 → 0.24.0

package/dist/index.js

@@ -10504,24 +10504,49 @@ var parseMetadata = (value) => {
     throw new NativeReleaseRegistryError("Native release appId is invalid");
   if (!SHA256_PATTERN.test(sha256))
     throw new NativeReleaseRegistryError("Native release sha256 is invalid");
-  if (releaseId !== `amobile_android_${sha256}`)
+  if (value.platform !== "android" && value.platform !== "ios")
+    throw new NativeReleaseRegistryError("Native release metadata is invalid");
+  if (releaseId !== `amobile_${value.platform}_${sha256}`)
     throw new NativeReleaseRegistryError("Native release id does not match its artifact digest");
-  if (value.artifact !== "app-release.aab" || value.engine !== "capacitor" || value.format !== 1 || value.platform !== "android" || value.type !== "aab" || typeof value.signed !== "boolean" || !Number.isSafeInteger(value.bytes) || Number(value.bytes) < 1 || value.versionCode !== undefined && (!Number.isSafeInteger(value.versionCode) || Number(value.versionCode) < 1 || Number(value.versionCode) > 2100000000))
+  const commonInvalid = value.engine !== "capacitor" || value.format !== 1 || typeof value.signed !== "boolean" || !Number.isSafeInteger(value.bytes) || Number(value.bytes) < 1;
+  if (commonInvalid)
+    throw new NativeReleaseRegistryError("Native release metadata is invalid");
+  if (value.platform === "android") {
+    if (value.artifact !== "app-release.aab" || value.type !== "aab" || value.versionCode !== undefined && (!Number.isSafeInteger(value.versionCode) || Number(value.versionCode) < 1 || Number(value.versionCode) > 2100000000))
+      throw new NativeReleaseRegistryError("Native release metadata is invalid");
+    return {
+      appBuild: requireString(value.appBuild, "appBuild"),
+      appId,
+      artifact: "app-release.aab",
+      bytes: Number(value.bytes),
+      engine: "capacitor",
+      format: 1,
+      platform: "android",
+      releaseId,
+      runtime: requireString(value.runtime, "runtime"),
+      sha256,
+      signed: value.signed === true,
+      type: "aab",
+      ...value.versionCode === undefined ? {} : { versionCode: Number(value.versionCode) }
+    };
+  }
+  if (value.artifact !== "App.ipa" || value.type !== "ipa" || typeof value.marketingVersion !== "string" || !/^\d+(?:\.\d+){0,2}$/.test(value.marketingVersion) || value.buildNumber !== undefined && (!Number.isSafeInteger(value.buildNumber) || Number(value.buildNumber) < 1))
     throw new NativeReleaseRegistryError("Native release metadata is invalid");
   return {
     appBuild: requireString(value.appBuild, "appBuild"),
     appId,
-    artifact: "app-release.aab",
+    artifact: "App.ipa",
+    ...value.buildNumber === undefined ? {} : { buildNumber: Number(value.buildNumber) },
     bytes: Number(value.bytes),
     engine: "capacitor",
     format: 1,
-    platform: "android",
+    marketingVersion: value.marketingVersion,
+    platform: "ios",
     releaseId,
     runtime: requireString(value.runtime, "runtime"),
     sha256,
-    signed: value.signed,
-    type: "aab",
-    ...value.versionCode === undefined ? {} : { versionCode: Number(value.versionCode) }
+    signed: value.signed === true,
+    type: "ipa"
   };
 };
 var normalizedPrefix = (value) => {
@@ -10563,7 +10588,7 @@ var parseRecord = (value) => {
   };
 };
 var parseChannel = (value) => {
-  if (!isRecord(value) || value.format !== NATIVE_RELEASE_REGISTRY_FORMAT || value.platform !== "android" || !isIsoTimestamp(value.promotedAt))
+  if (!isRecord(value) || value.format !== NATIVE_RELEASE_REGISTRY_FORMAT || value.platform !== "android" && value.platform !== "ios" || !isIsoTimestamp(value.promotedAt))
     throw new NativeReleaseRegistryError("Native release channel is invalid");
   const appId = requireString(value.appId, "channel appId");
   const channel = requireChannel(requireString(value.channel, "channel"));
@@ -10571,13 +10596,13 @@ var parseChannel = (value) => {
   const releaseId = requireString(value.releaseId, "channel releaseId");
   if (!APP_ID_PATTERN.test(appId) || !SHA256_PATTERN.test(sha256))
     throw new NativeReleaseRegistryError("Native release channel is invalid");
-  if (releaseId !== `amobile_android_${sha256}`)
+  if (releaseId !== `amobile_${value.platform}_${sha256}`)
     throw new NativeReleaseRegistryError("Native release channel identity does not match");
   return {
     appId,
     channel,
     format: NATIVE_RELEASE_REGISTRY_FORMAT,
-    platform: "android",
+    platform: value.platform,
     promotedAt: value.promotedAt,
     releaseId,
     sha256
@@ -10602,10 +10627,10 @@ var createNativeReleaseRegistry = (options) => {
   const read = async (input) => {
     if (!APP_ID_PATTERN.test(input.appId))
       throw new NativeReleaseRegistryError("Native release appId is invalid");
-    const digest = input.releaseId.replace(/^amobile_android_/, "");
-    if (!SHA256_PATTERN.test(digest) || input.releaseId !== `amobile_android_${digest}`)
+    const digest = input.releaseId.replace(new RegExp(`^amobile_${input.platform}_`), "");
+    if (!SHA256_PATTERN.test(digest) || input.releaseId !== `amobile_${input.platform}_${digest}`)
       throw new NativeReleaseRegistryError("Native release id is invalid");
-    const identity = {
+    const identity = input.platform === "android" ? {
       appBuild: "lookup",
       appId: input.appId,
       artifact: "app-release.aab",
@@ -10618,6 +10643,20 @@ var createNativeReleaseRegistry = (options) => {
       sha256: digest,
       signed: true,
       type: "aab"
+    } : {
+      appBuild: "lookup",
+      appId: input.appId,
+      artifact: "App.ipa",
+      bytes: 1,
+      engine: "capacitor",
+      format: 1,
+      marketingVersion: "1.0.0",
+      platform: "ios",
+      releaseId: input.releaseId,
+      runtime: "lookup",
+      sha256: digest,
+      signed: true,
+      type: "ipa"
     };
     const key = recordKey(identity);
     const bytes = await options.store.get(key);
@@ -11126,6 +11165,7 @@ var createGooglePlayReleasePublisher = (options) => {
     updatedAt: clock().toISOString()
   });
   return {
+    ...options.registry,
     prepareAndroidRelease: async (input) => {
       const target = input.googlePlay ?? options.target;
       if (!target)
@@ -11167,6 +11207,8 @@ var createGooglePlayReleasePublisher = (options) => {
         return publication;
       const intent = normalizedTarget(target);
       const metadata = publication.record.metadata;
+      if (metadata.platform !== "android")
+        throw new GooglePlayReleaseError("Google Play publishing requires an Android App Bundle release");
       if (!metadata.signed)
         throw new GooglePlayReleaseError("Unsigned Android releases cannot be sent to Google Play");
       if (!metadata.versionCode)
@@ -11320,6 +11362,550 @@ var createGooglePlayReleasePublisher = (options) => {
   };
 };
 
+// src/appStoreConnect.ts
+import { createHash as createHash3, createPrivateKey, sign } from "crypto";
+import path4 from "path";
+var API_ROOT2 = "https://api.appstoreconnect.apple.com/v1";
+var DEFAULT_RECEIPT_PREFIX2 = "absolutejs/app-store-connect-receipts";
+var SHA256_PATTERN3 = /^[a-f0-9]{64}$/;
+
+class AppStoreConnectReleaseError extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "AppStoreConnectReleaseError";
+    this.status = status;
+  }
+}
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var encodedJson3 = (value) => new TextEncoder().encode(`${JSON.stringify(value, null, 2)}
+`);
+var decodedJson3 = (value) => JSON.parse(new TextDecoder().decode(value));
+var sha256Bytes3 = (value) => createHash3("sha256").update(value).digest("hex");
+var hashIdentity2 = (value) => createHash3("sha256").update(value).digest("hex");
+var isIsoTimestamp3 = (value) => typeof value === "string" && !Number.isNaN(Date.parse(value)) && new Date(value).toISOString() === value;
+var normalizedPrefix3 = (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 parseReceipt2 = (value) => {
+  if (!isRecord3(value) || value.format !== 1 || value.provider !== "app-store-connect" || typeof value.appleAppId !== "string" || typeof value.releaseId !== "string" || typeof value.sha256 !== "string" || !SHA256_PATTERN3.test(value.sha256) || !Number.isSafeInteger(value.buildNumber) || Number(value.buildNumber) < 1 || typeof value.marketingVersion !== "string" || !isIsoTimestamp3(value.updatedAt) || ![
+    "preparing",
+    "uploading",
+    "processing",
+    "distributed",
+    "review-submitted"
+  ].includes(String(value.stage)) || !isRecord3(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 responseError2 = 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_ROOT2}${route}`, {
+      ...init,
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${token()}`,
+        ...init.body ? { "Content-Type": "application/json" } : {},
+        ...init.headers
+      }
+    });
+    if (!response.ok)
+      throw await responseError2(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_ROOT2) ? next.slice(API_ROOT2.length) : next);
+      if (Array.isArray(page.data))
+        result.push(...page.data.filter(isRecord3));
+      const links = isRecord3(page.links) ? page.links : undefined;
+      next = typeof links?.next === "string" ? links.next : undefined;
+    }
+    return result;
+  };
+  const buildFrom = (data) => {
+    const attributes = isRecord3(data.attributes) ? data.attributes : {};
+    return {
+      id: String(data.id),
+      processingState: String(attributes.processingState),
+      version: String(attributes.version)
+    };
+  };
+  const uploadFrom = (data) => {
+    const attributes = isRecord3(data.attributes) ? data.attributes : {};
+    const state = isRecord3(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) => isRecord3(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(isRecord3(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 = isRecord3(data.attributes) ? data.attributes : {};
+      const operations = Array.isArray(attrs.uploadOperations) ? attrs.uploadOperations.filter(isRecord3) : [];
+      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 (isRecord3(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 responseError2(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 || isRecord3(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) => isRecord3(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 isRecord3(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 = normalizedPrefix3(options.receiptPrefix ?? DEFAULT_RECEIPT_PREFIX2);
+  const maxWaitMs = options.maxWaitMs ?? 20 * 60000;
+  const pollIntervalMs = options.pollIntervalMs ?? 5000;
+  const preparationKey = (bundleId, buildIdentity) => `${prefix}/${hashIdentity2(bundleId)}/preparations/${hashIdentity2(buildIdentity)}.json`;
+  const receiptKey = (appId, releaseId, intent) => `${prefix}/${hashIdentity2(appId)}/${releaseId}/${hashIdentity2(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 !== sha256Bytes3(bytes))
+      throw new AppStoreConnectReleaseError("Stored App Store Connect state failed integrity verification");
+    return decodedJson3(bytes);
+  };
+  const writeStored = async (key, value, type) => {
+    const bytes = encodedJson3(value);
+    await options.receiptStore.put(key, bytes, {
+      cacheControl: "no-cache",
+      contentType: "application/json",
+      maxBytes: bytes.byteLength,
+      metadata: { sha256: sha256Bytes3(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 (isRecord3(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 ? parseReceipt2(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 = path4.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 } };
+    }
+  };
+};
+
 // src/edgeIngress.ts
 var validPort = (port) => Number.isInteger(port) && port >= 1 && port <= 65535;
 
@@ -12019,13 +12605,16 @@ export {
   createGooglePlayReleasePublisher,
   createGooglePlayClient,
   createDeployer,
+  createAppStoreConnectReleasePublisher,
+  createAppStoreConnectClient,
   bareManager,
   ReleaseArtifactError,
   NativeReleaseRegistryError,
   NATIVE_RELEASE_REGISTRY_FORMAT,
   GooglePlayReleaseError,
-  EdgeIngressValidationError
+  EdgeIngressValidationError,
+  AppStoreConnectReleaseError
 };
 
-//# debugId=264DE11EAA0F4C5664756E2164756E21
+//# debugId=95C261E7DE60029364756E2164756E21
 //# sourceMappingURL=index.js.map