@stacksjs/browser-extension 0.70.144 → 0.70.146

package/README.md

@@ -31,6 +31,7 @@ buddy extension:chrome:publish --upload-only
 buddy extension:firefox:publish         # build, submit, sign through AMO
 buddy extension:safari:provision        # register Bundle IDs + check app record
 buddy extension:safari:publish
+buddy extension:safari:submit           # submit an already-uploaded version
 ```
 
 Chrome reads `CHROME_WEB_STORE_SERVICE_ACCOUNT_PATH` (or
@@ -79,23 +80,32 @@ buddy extension:safari:provision # register both Bundle IDs + check the app reco
 buddy extension:safari:app    # build configured macOS/iOS apps
 buddy extension:safari:app --platform ios # build for iPhone/iPad Simulator
 buddy extension:safari:publish # archive + upload every configured Apple platform
+buddy extension:safari:submit  # sync listing metadata and submit existing builds
 ```
 
 Set `safariBundleId` in the config (the appex gets `<safariBundleId>.Extension`)
 and `safariTeamId` to the Apple Developer team used for signing. Set
 `safariPlatforms: ['macos', 'ios']` for a universal extension; iOS covers both
 iPhone and iPad. Stacks generates the current Apple-supported universal Xcode
-project from the same built extension, archives both platforms, and uploads
-both to the same App Store Connect app record. Publishing
+project from the same built extension, archives both platforms, uploads them
+to the same App Store Connect app record, waits for Apple processing, and
+selects each processed build on its matching App Store version. Publishing
 reads `APP_STORE_CONNECT_API_KEY_ID`, `APP_STORE_CONNECT_API_ISSUER_ID`, and
 `APP_STORE_CONNECT_API_KEY_PATH` from the environment. Run with
 `--validate-only` to exercise Apple's validation without uploading a build.
-and list any build output that is not part of the extension (marketing pages,
+List any build output that is not part of the extension (marketing pages,
 etc.) in `safariExclude` so it stays out of the appex. The scaffold mirrors
 what `xcrun safari-web-extension-converter` generates, so day-to-day work
 never needs the converter; `--signed` builds need an Apple Development
 identity selected in Xcode.
 
+When `safariAppStore` is configured, publishing also synchronizes the app
+description, category, content-rights declaration, pricing, age rating,
+territory availability, review contact, export compliance, and required
+screenshots. With `submitForReview: true`, the macOS and iOS versions are then
+submitted independently to App Review. The workflow is resumable and keeps an
+existing active review submission intact.
+
 For device testing, install the generated iOS app from Xcode, then enable the
 extension in Settings > Apps > Safari > Extensions. The iOS target supports
 iPhone and iPad from iOS 15 onward; the extension's configured Safari minimum
@@ -117,6 +127,27 @@ export default defineExtension({
   safariTeamId: 'TEAM123456',
   safariPlatforms: ['macos', 'ios'], // iOS includes iPhone and iPad
   safariAppCategory: 'public.app-category.utilities',
+  safariAppStore: {
+    subtitle: 'Fast, private blocking',
+    privacyPolicyUrl: 'https://example.com/privacy',
+    description: 'A private Safari extension.',
+    keywords: 'privacy,blocking',
+    supportUrl: 'https://example.com/support',
+    copyright: '2026 Example',
+    primaryCategory: 'UTILITIES',
+    contentRightsDeclaration: 'DOES_NOT_USE_THIRD_PARTY_CONTENT',
+    price: '0',
+    reviewContact: {
+      firstName: 'App', lastName: 'Reviewer',
+      phone: '+1 555-555-0100', email: 'review@example.com',
+    },
+    screenshots: {
+      APP_DESKTOP: ['resources/store/macos.png'],
+      APP_IPHONE_67: ['resources/store/iphone.png'],
+      APP_IPAD_PRO_3GEN_129: ['resources/store/ipad.png'],
+    },
+    submitForReview: true,
+  },
   targets: ['chrome', 'firefox'],
 
   background: 'src/background/index.ts',

package/dist/app-store-connect.d.ts

@@ -2,6 +2,8 @@ import type { AppStoreConnectAuth } from './safari';
 import type { ExtensionConfig, SafariPlatform } from './types';
 /** Generate the short-lived ES256 team token required by App Store Connect. */
 export declare function appStoreConnectToken(auth: Required<AppStoreConnectAuth>, now?: unknown): string;
+/** Wait for the uploaded binaries to process, then select them for their App Store versions. */
+export declare function attachSafariBuilds(client: AppStoreConnectClient, appId: string, versions: SafariAppStoreVersionResult[], buildNumber: string, options?: AttachSafariBuildsOptions): Promise<SafariBuildAttachmentResult[]>;
 /**
  * Register the explicit container and extension Bundle IDs required by a
  * Safari Web Extension, then check for the manually-created App Store Connect
@@ -12,6 +14,7 @@ export declare interface AppStoreConnectResource<T extends Record<string, unknow
   type: string
   id: string
   attributes: T
+  relationships?: Record<string, { data?: { type: string, id: string } | null }>
 }
 export declare interface BundleIdAttributes extends Record<string, unknown> {
   identifier: string
@@ -30,6 +33,23 @@ export declare interface AppStoreVersionAttributes extends Record<string, unknow
   versionString: string
   appStoreState: string
 }
+export declare interface BuildAttributes extends Record<string, unknown> {
+  version: string
+  uploadedDate: string
+  expired: boolean
+  processingState: string
+}
+export declare interface PreReleaseVersionAttributes extends Record<string, unknown> {
+  version: string
+  platform: AppStoreVersionPlatform
+}
+export declare interface AppStoreBuildResult {
+  id: string
+  buildNumber: string
+  version: string
+  platform: AppStoreVersionPlatform
+  processingState: string
+}
 export declare interface AppStoreConnectClientOptions extends AppStoreConnectAuth {
   baseUrl?: string
   fetch?: typeof globalThis.fetch
@@ -42,6 +62,16 @@ export declare interface SafariAppStoreVersionResult {
   updated: boolean
   id: string
 }
+export declare interface SafariBuildAttachmentResult {
+  platform: SafariPlatform
+  versionId: string
+  buildId: string
+  buildNumber: string
+}
+export declare interface AttachSafariBuildsOptions {
+  timeoutMs?: number
+  pollIntervalMs?: number
+}
 export declare interface SafariProvisionOptions extends AppStoreConnectClientOptions {
   checkOnly?: boolean
   platform?: BundleIdPlatform
@@ -59,6 +89,8 @@ export type AppStoreVersionPlatform = 'IOS' | 'MAC_OS';
 /** Minimal official App Store Connect client for Safari provisioning checks. */
 export declare class AppStoreConnectClient {
   constructor(options?: AppStoreConnectClientOptions);
+  request<T>(path: string, init?: RequestInit): Promise<T>;
+  upload(url: string, init: RequestInit): Promise<void>;
   findBundleId(identifier: string): Promise<AppStoreConnectResource<BundleIdAttributes> | undefined>;
   registerBundleId(identifier: string, name: string, platform?: BundleIdPlatform): Promise<AppStoreConnectResource<BundleIdAttributes>>;
   ensureBundleId(identifier: string, name: string, options?: { checkOnly?: boolean, platform?: BundleIdPlatform }): Promise<{ bundleId?: AppStoreConnectResource<BundleIdAttributes>, created: boolean }>;
@@ -66,4 +98,6 @@ export declare class AppStoreConnectClient {
   listAppStoreVersions(appId: string): Promise<Array<AppStoreConnectResource<AppStoreVersionAttributes>>>;
   createAppStoreVersion(appId: string, platform: AppStoreVersionPlatform, versionString: string): Promise<AppStoreConnectResource<AppStoreVersionAttributes>>;
   updateAppStoreVersion(versionId: string, versionString: string): Promise<AppStoreConnectResource<AppStoreVersionAttributes>>;
+  listBuilds(appId: string, buildNumber: string): Promise<AppStoreBuildResult[]>;
+  attachBuild(versionId: string, buildId: string): Promise<void>;
 }

package/dist/app-store-connect.js

@@ -2,6 +2,13 @@ import { createPrivateKey, sign } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { resolveAppStoreConnectAuth } from "./safari";
 const appStoreConnectBaseUrl = "https://api.appstoreconnect.apple.com/v1";
+function apiErrorMessages(error) {
+  const messages = [error.detail ?? error.title ?? error.code].filter((message) => Boolean(message));
+  for (const associated of Object.values(error.meta?.associatedErrors ?? {}))
+    for (const nested of associated)
+      messages.push(...apiErrorMessages(nested));
+  return messages;
+}
 function base64urlJson(value) {
   return Buffer.from(JSON.stringify(value)).toString("base64url");
 }
@@ -34,7 +41,7 @@ export class AppStoreConnectClient {
     this.now = options.now ?? (() => Math.floor(Date.now() / 1000));
   }
   async request(path, init = {}) {
-    const response = await this.fetcher(`${this.baseUrl}${path}`, {
+    const url = /^https?:\/\//.test(path) ? path : /^\/v\d+\//.test(path) ? `${new URL(this.baseUrl).origin}${path}` : `${this.baseUrl}${path}`, response = await this.fetcher(url, {
       ...init,
       headers: {
         Accept: "application/json",
@@ -44,11 +51,18 @@ export class AppStoreConnectClient {
       }
     });
     if (!response.ok) {
-      const details = (await response.json().catch(() => ({}))).errors?.map((error) => error.detail ?? error.title ?? error.code).filter(Boolean).join("; ");
+      const body = await response.json().catch(() => ({})), details = [...new Set(body.errors?.flatMap(apiErrorMessages) ?? [])].join("; ");
       throw Error(`[browser-extension] App Store Connect ${init.method ?? "GET"} ${path} failed (${response.status})${details ? `: ${details}` : ""}`);
     }
+    if (response.status === 204)
+      return;
     return await response.json();
   }
+  async upload(url, init) {
+    const response = await this.fetcher(url, init);
+    if (!response.ok)
+      throw Error(`[browser-extension] App Store Connect asset upload failed (${response.status})`);
+  }
   async findBundleId(identifier) {
     const query = new URLSearchParams({ "filter[identifier]": identifier });
     return (await this.request(`/bundleIds?${query}`)).data.find((bundleId) => bundleId.attributes.identifier === identifier);
@@ -106,6 +120,34 @@ export class AppStoreConnectClient {
       })
     })).data;
   }
+  async listBuilds(appId, buildNumber) {
+    const query = new URLSearchParams({
+      "filter[app]": appId,
+      "filter[version]": buildNumber,
+      include: "preReleaseVersion",
+      limit: "20",
+      "fields[builds]": "version,uploadedDate,expired,processingState,preReleaseVersion",
+      "fields[preReleaseVersions]": "version,platform"
+    }), response = await this.request(`/builds?${query}`), preReleaseVersions = new Map((response.included ?? []).filter((item) => item.type === "preReleaseVersions").map((item) => [item.id, item.attributes]));
+    return response.data.flatMap((build) => {
+      const preReleaseVersionId = build.relationships?.preReleaseVersion?.data?.id, preReleaseVersion = preReleaseVersionId ? preReleaseVersions.get(preReleaseVersionId) : void 0;
+      if (!preReleaseVersion)
+        return [];
+      return [{
+        id: build.id,
+        buildNumber: build.attributes.version,
+        version: preReleaseVersion.version,
+        platform: preReleaseVersion.platform,
+        processingState: build.attributes.processingState
+      }];
+    });
+  }
+  async attachBuild(versionId, buildId) {
+    await this.request(`/appStoreVersions/${versionId}/relationships/build`, {
+      method: "PATCH",
+      body: JSON.stringify({ data: { type: "builds", id: buildId } })
+    });
+  }
 }
 const editableVersionStates = new Set([
   "PREPARE_FOR_SUBMISSION",
@@ -116,6 +158,37 @@ const editableVersionStates = new Set([
 function appStorePlatform(platform) {
   return platform === "ios" ? "IOS" : "MAC_OS";
 }
+export async function attachSafariBuilds(client, appId, versions, buildNumber, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 1200000, pollIntervalMs = options.pollIntervalMs ?? 15000, deadline = Date.now() + timeoutMs, pending = new Map(versions.map((version) => [appStorePlatform(version.platform), version]));
+  while (!0) {
+    const builds = await client.listBuilds(appId, buildNumber), attachments = [];
+    for (const [platform, version] of pending) {
+      const build = builds.find((item) => item.platform === platform && item.version === version.version);
+      if (!build)
+        continue;
+      if (build.processingState === "FAILED" || build.processingState === "INVALID")
+        throw Error(`[browser-extension] Safari ${version.platform} build ${buildNumber} failed App Store Connect processing (${build.processingState})`);
+      if (build.processingState !== "VALID")
+        continue;
+      attachments.push({
+        platform: version.platform,
+        versionId: version.id,
+        buildId: build.id,
+        buildNumber
+      });
+    }
+    if (attachments.length === pending.size) {
+      for (const attachment of attachments)
+        await client.attachBuild(attachment.versionId, attachment.buildId);
+      return attachments;
+    }
+    if (Date.now() >= deadline) {
+      const waiting = [...pending.values()].map((item) => item.platform).join(", ");
+      throw Error(`[browser-extension] timed out waiting for Safari ${waiting} build ${buildNumber} to finish App Store Connect processing`);
+    }
+    await Bun.sleep(pollIntervalMs);
+  }
+}
 async function ensureConfiguredAppStoreVersions(client, appId, platforms, version) {
   const versions = await client.listAppStoreVersions(appId), results = [];
   for (const platform of [...new Set(platforms)]) {

package/dist/app-store-submission.d.ts

@@ -0,0 +1,27 @@
+import { AppStoreConnectClient } from './app-store-connect';
+import type { AppStoreConnectClientOptions } from './app-store-connect';
+import type { ExtensionConfig, SafariPlatform } from './types';
+/** Synchronize a Safari listing and optionally submit all configured platforms to App Review. */
+export declare function prepareSafariAppStoreSubmission(client: AppStoreConnectClient, config: ExtensionConfig, appId: string, versions: SafariStoreVersion[], options?: SafariStoreSubmissionOptions): Promise<SafariStoreSubmissionResult>;
+/** Prepare and submit an already-uploaded Safari version without rebuilding its binary. */
+export declare function submitSafariAppStore(config: ExtensionConfig, options: SubmitSafariAppStoreOptions): Promise<SafariStoreSubmissionResult>;
+declare interface SafariStoreVersion {
+  platform: SafariPlatform
+  id: string
+  buildId?: string
+}
+export declare interface SafariStoreSubmissionOptions {
+  cwd?: string
+  submit?: boolean
+  screenshotTimeoutMs?: number
+  screenshotPollIntervalMs?: number
+}
+export declare interface SafariStoreSubmissionResult {
+  appId: string
+  versions: Array<{ platform: SafariPlatform, versionId: string, localizationId: string }>
+  reviewSubmissionIds: string[]
+}
+export declare interface SubmitSafariAppStoreOptions extends AppStoreConnectClientOptions, SafariStoreSubmissionOptions {
+  version: string
+  platforms?: SafariPlatform[]
+}

package/dist/app-store-submission.js

@@ -0,0 +1,443 @@
+import { createHash } from "node:crypto";
+import { basename, resolve } from "node:path";
+import { readFile, stat } from "node:fs/promises";
+import { AppStoreConnectClient } from "./app-store-connect";
+const frequencyFields = [
+  "alcoholTobaccoOrDrugUseOrReferences",
+  "contests",
+  "gamblingSimulated",
+  "gunsOrOtherWeapons",
+  "medicalOrTreatmentInformation",
+  "profanityOrCrudeHumor",
+  "sexualContentGraphicAndNudity",
+  "sexualContentOrNudity",
+  "horrorOrFearThemes",
+  "matureOrSuggestiveThemes",
+  "violenceCartoonOrFantasy",
+  "violenceRealisticProlongedGraphicOrSadistic",
+  "violenceRealistic"
+], booleanFields = [
+  "advertising",
+  "gambling",
+  "healthOrWellnessTopics",
+  "lootBox",
+  "messagingAndChat",
+  "parentalControls",
+  "ageAssurance",
+  "socialMedia",
+  "socialMediaAgeRestricted",
+  "unrestrictedWebAccess",
+  "userGeneratedContent"
+], editableVersionStates = new Set(["PREPARE_FOR_SUBMISSION", "DEVELOPER_REJECTED", "REJECTED", "METADATA_REJECTED"]);
+function ageRatingAttributes(config = {}) {
+  const attributes = {
+    ageRatingOverrideV2: "NONE",
+    koreaAgeRatingOverride: "NONE"
+  };
+  for (const field of frequencyFields)
+    attributes[field] = config[field] ?? "NONE";
+  for (const field of booleanFields)
+    attributes[field] = config[field] ?? !1;
+  return attributes;
+}
+function applePlatform(platform) {
+  return platform === "ios" ? "IOS" : "MAC_OS";
+}
+function displayTypesForPlatform(platform) {
+  return platform === "macos" ? ["APP_DESKTOP"] : ["APP_IPHONE_67", "APP_IPAD_PRO_3GEN_129"];
+}
+async function updateAppInfo(client, appId, config) {
+  await client.request(`/apps/${appId}`, {
+    method: "PATCH",
+    body: JSON.stringify({
+      data: {
+        type: "apps",
+        id: appId,
+        attributes: { contentRightsDeclaration: config.contentRightsDeclaration }
+      }
+    })
+  });
+  const infos = await client.request(`/apps/${appId}/appInfos?limit=10`), info = infos.data.find((item) => item.attributes.appStoreState === "PREPARE_FOR_SUBMISSION") ?? infos.data[0];
+  if (!info)
+    throw Error("[browser-extension] App Store Connect has no editable app information resource");
+  await client.request(`/appInfos/${info.id}`, {
+    method: "PATCH",
+    body: JSON.stringify({
+      data: {
+        type: "appInfos",
+        id: info.id,
+        relationships: {
+          primaryCategory: { data: { type: "appCategories", id: config.primaryCategory } }
+        }
+      }
+    })
+  });
+  const localizations = await client.request(`/appInfos/${info.id}/appInfoLocalizations?limit=200`), locale = config.locale ?? "en-US", localization = localizations.data.find((item) => item.attributes.locale === locale);
+  if (!localization)
+    throw Error(`[browser-extension] App Store Connect app information is missing the ${locale} localization`);
+  await client.request(`/appInfoLocalizations/${localization.id}`, {
+    method: "PATCH",
+    body: JSON.stringify({
+      data: {
+        type: "appInfoLocalizations",
+        id: localization.id,
+        attributes: {
+          subtitle: config.subtitle,
+          privacyPolicyUrl: config.privacyPolicyUrl
+        }
+      }
+    })
+  });
+  await client.request(`/ageRatingDeclarations/${info.id}`, {
+    method: "PATCH",
+    body: JSON.stringify({
+      data: {
+        type: "ageRatingDeclarations",
+        id: info.id,
+        attributes: ageRatingAttributes(config.ageRating)
+      }
+    })
+  });
+  return info.id;
+}
+async function ensurePrice(client, appId, config) {
+  if ((await client.request(`/appPriceSchedules/${appId}/manualPrices?limit=200`)).data.length)
+    return;
+  const baseTerritory = config.baseTerritory ?? "USA", pricePoints = await client.request(`/apps/${appId}/appPricePoints?filter[territory]=${encodeURIComponent(baseTerritory)}&limit=200`), requestedPrice = Number(config.price), pricePoint = pricePoints.data.find((item) => Number(item.attributes.customerPrice) === requestedPrice);
+  if (!pricePoint)
+    throw Error(`[browser-extension] App Store price ${config.price} is unavailable in ${baseTerritory}`);
+  const localId = "${price}";
+  await client.request("/appPriceSchedules", {
+    method: "POST",
+    body: JSON.stringify({
+      data: {
+        type: "appPriceSchedules",
+        relationships: {
+          app: { data: { type: "apps", id: appId } },
+          baseTerritory: { data: { type: "territories", id: baseTerritory } },
+          manualPrices: { data: [{ type: "appPrices", id: localId }] }
+        }
+      },
+      included: [{
+        type: "appPrices",
+        id: localId,
+        attributes: { startDate: null, endDate: null },
+        relationships: { appPricePoint: { data: { type: "appPricePoints", id: pricePoint.id } } }
+      }]
+    })
+  });
+}
+async function ensureAvailability(client, appId, availableInNewTerritories = !0) {
+  try {
+    if ((await client.request(`/apps/${appId}/appAvailabilityV2`)).data.attributes.availableInNewTerritories === availableInNewTerritories)
+      return;
+    return;
+  } catch (error) {
+    if (!(error instanceof Error) || !error.message.includes("(404)"))
+      throw error;
+  }
+  const included = (await client.request("/territories?limit=200")).data.map((territory, index) => {
+    return {
+      type: "territoryAvailabilities",
+      id: `\${territory-${index}}`,
+      attributes: { available: !0 },
+      relationships: { territory: { data: { type: "territories", id: territory.id } } }
+    };
+  });
+  await client.request("/v2/appAvailabilities", {
+    method: "POST",
+    body: JSON.stringify({
+      data: {
+        type: "appAvailabilities",
+        attributes: { availableInNewTerritories },
+        relationships: {
+          app: { data: { type: "apps", id: appId } },
+          territoryAvailabilities: {
+            data: included.map((item) => ({ type: item.type, id: item.id }))
+          }
+        }
+      },
+      included
+    })
+  });
+}
+async function ensureVersionLocalization(client, versionId, config) {
+  const locale = config.locale ?? "en-US";
+  let localization = (await client.request(`/appStoreVersions/${versionId}/appStoreVersionLocalizations?limit=200`)).data.find((item) => item.attributes.locale === locale);
+  if (!localization)
+    localization = (await client.request("/appStoreVersionLocalizations", {
+      method: "POST",
+      body: JSON.stringify({
+        data: {
+          type: "appStoreVersionLocalizations",
+          attributes: { locale },
+          relationships: { appStoreVersion: { data: { type: "appStoreVersions", id: versionId } } }
+        }
+      })
+    })).data;
+  await client.request(`/appStoreVersionLocalizations/${localization.id}`, {
+    method: "PATCH",
+    body: JSON.stringify({
+      data: {
+        type: "appStoreVersionLocalizations",
+        id: localization.id,
+        attributes: {
+          description: config.description,
+          keywords: config.keywords,
+          supportUrl: config.supportUrl,
+          ...config.marketingUrl ? { marketingUrl: config.marketingUrl } : {},
+          ...config.promotionalText ? { promotionalText: config.promotionalText } : {},
+          ...config.whatsNew ? { whatsNew: config.whatsNew } : {}
+        }
+      }
+    })
+  });
+  return localization.id;
+}
+async function ensureReviewDetail(client, versionId, config) {
+  const response = await client.request(`/appStoreVersions/${versionId}/appStoreReviewDetail`), attributes = {
+    contactFirstName: config.reviewContact.firstName,
+    contactLastName: config.reviewContact.lastName,
+    contactPhone: config.reviewContact.phone,
+    contactEmail: config.reviewContact.email,
+    demoAccountRequired: !1,
+    ...config.reviewContact.notes ? { notes: config.reviewContact.notes } : {}
+  };
+  if (response.data) {
+    await client.request(`/appStoreReviewDetails/${response.data.id}`, {
+      method: "PATCH",
+      body: JSON.stringify({ data: { type: "appStoreReviewDetails", id: response.data.id, attributes } })
+    });
+    return;
+  }
+  await client.request("/appStoreReviewDetails", {
+    method: "POST",
+    body: JSON.stringify({
+      data: {
+        type: "appStoreReviewDetails",
+        attributes,
+        relationships: { appStoreVersion: { data: { type: "appStoreVersions", id: versionId } } }
+      }
+    })
+  });
+}
+async function ensureScreenshotSet(client, localizationId, displayType) {
+  const existing = (await client.request(`/appStoreVersionLocalizations/${localizationId}/appScreenshotSets?limit=200`)).data.find((item) => item.attributes.screenshotDisplayType === displayType);
+  if (existing)
+    return existing.id;
+  return (await client.request("/appScreenshotSets", {
+    method: "POST",
+    body: JSON.stringify({
+      data: {
+        type: "appScreenshotSets",
+        attributes: { screenshotDisplayType: displayType },
+        relationships: {
+          appStoreVersionLocalization: { data: { type: "appStoreVersionLocalizations", id: localizationId } }
+        }
+      }
+    })
+  })).data.id;
+}
+async function waitForScreenshot(client, id, timeoutMs, pollIntervalMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (!0) {
+    const response = await client.request(`/appScreenshots/${id}`), state = response.data.attributes.assetDeliveryState?.state;
+    if (state === "COMPLETE")
+      return;
+    if (state === "FAILED") {
+      const detail = response.data.attributes.assetDeliveryState?.errors?.map((error) => error.message).filter(Boolean).join("; ");
+      throw Error(`[browser-extension] App Store screenshot processing failed${detail ? `: ${detail}` : ""}`);
+    }
+    if (Date.now() >= deadline)
+      throw Error(`[browser-extension] timed out waiting for App Store screenshot ${response.data.attributes.fileName}`);
+    await Bun.sleep(pollIntervalMs);
+  }
+}
+async function uploadScreenshot(client, setId, path, timeoutMs, pollIntervalMs) {
+  const bytes = await readFile(path), file = basename(path), checksum = createHash("md5").update(bytes).digest("hex"), reserved = await client.request("/appScreenshots", {
+    method: "POST",
+    body: JSON.stringify({
+      data: {
+        type: "appScreenshots",
+        attributes: { fileName: file, fileSize: bytes.byteLength },
+        relationships: { appScreenshotSet: { data: { type: "appScreenshotSets", id: setId } } }
+      }
+    })
+  });
+  for (const operation of reserved.data.attributes.uploadOperations ?? []) {
+    const body = bytes.subarray(operation.offset, operation.offset + operation.length);
+    await client.upload(operation.url, {
+      method: operation.method,
+      headers: Object.fromEntries(operation.requestHeaders.map((header) => [header.name, header.value])),
+      body
+    });
+  }
+  await client.request(`/appScreenshots/${reserved.data.id}`, {
+    method: "PATCH",
+    body: JSON.stringify({
+      data: {
+        type: "appScreenshots",
+        id: reserved.data.id,
+        attributes: { uploaded: !0, sourceFileChecksum: checksum }
+      }
+    })
+  });
+  await waitForScreenshot(client, reserved.data.id, timeoutMs, pollIntervalMs);
+  return reserved.data.id;
+}
+async function syncScreenshotSet(client, setId, paths, cwd, timeoutMs, pollIntervalMs) {
+  if (paths.length > 10)
+    throw Error("[browser-extension] App Store screenshot sets accept at most 10 images");
+  const files = await Promise.all(paths.map(async (path) => {
+    const absolute = resolve(cwd, path);
+    await stat(absolute);
+    const bytes = await readFile(absolute);
+    return { absolute, name: basename(absolute), checksum: createHash("md5").update(bytes).digest("hex") };
+  })), existing = await client.request(`/appScreenshotSets/${setId}/appScreenshots?limit=200`);
+  for (const screenshot of existing.data) {
+    const desired = files.find((file) => file.name === screenshot.attributes.fileName);
+    if (!desired || desired.checksum !== screenshot.attributes.sourceFileChecksum)
+      await client.request(`/appScreenshots/${screenshot.id}`, { method: "DELETE" });
+  }
+  for (const file of files)
+    if (!existing.data.find((screenshot) => screenshot.attributes.fileName === file.name && screenshot.attributes.sourceFileChecksum === file.checksum))
+      await uploadScreenshot(client, setId, file.absolute, timeoutMs, pollIntervalMs);
+}
+async function updateVersion(client, version, config) {
+  await client.request(`/appStoreVersions/${version.id}`, {
+    method: "PATCH",
+    body: JSON.stringify({
+      data: {
+        type: "appStoreVersions",
+        id: version.id,
+        attributes: {
+          copyright: config.copyright,
+          releaseType: config.releaseType ?? "AFTER_APPROVAL",
+          usesIdfa: config.usesIdfa ?? !1
+        }
+      }
+    })
+  });
+  if (version.buildId) {
+    const encryption = config.usesNonExemptEncryption ?? !1, build = await client.request(`/builds/${version.buildId}?fields[builds]=usesNonExemptEncryption`);
+    if (build.data.attributes.usesNonExemptEncryption === void 0 || build.data.attributes.usesNonExemptEncryption === null)
+      await client.request(`/builds/${version.buildId}`, {
+        method: "PATCH",
+        body: JSON.stringify({
+          data: {
+            type: "builds",
+            id: version.buildId,
+            attributes: { usesNonExemptEncryption: encryption }
+          }
+        })
+      });
+  }
+}
+async function submitVersions(client, appId, versions) {
+  const existing = await client.request(`/apps/${appId}/reviewSubmissions?limit=200`), ids = [];
+  for (const version of versions) {
+    const platform = applePlatform(version.platform), platformSubmissions = existing.data.filter((item) => item.attributes.platform === platform);
+    let submission;
+    for (const candidate of platformSubmissions) {
+      if (!((await client.request(`/reviewSubmissions/${candidate.id}/items?include=appStoreVersion&limit=200`)).included ?? []).some((item) => item.type === "appStoreVersions" && item.id === version.id))
+        continue;
+      submission = candidate;
+      if (candidate.attributes.state !== "READY_FOR_REVIEW") {
+        ids.push(candidate.id);
+        break;
+      }
+    }
+    if (submission && submission.attributes.state !== "READY_FOR_REVIEW")
+      continue;
+    submission ??= platformSubmissions.find((item) => item.attributes.state === "READY_FOR_REVIEW");
+    if (!submission)
+      submission = (await client.request("/reviewSubmissions", {
+        method: "POST",
+        body: JSON.stringify({
+          data: {
+            type: "reviewSubmissions",
+            attributes: { platform },
+            relationships: { app: { data: { type: "apps", id: appId } } }
+          }
+        })
+      })).data;
+    if (!((await client.request(`/reviewSubmissions/${submission.id}/items?include=appStoreVersion&limit=200`)).included ?? []).some((item) => item.type === "appStoreVersions" && item.id === version.id))
+      await client.request("/reviewSubmissionItems", {
+        method: "POST",
+        body: JSON.stringify({
+          data: {
+            type: "reviewSubmissionItems",
+            relationships: {
+              reviewSubmission: { data: { type: "reviewSubmissions", id: submission.id } },
+              appStoreVersion: { data: { type: "appStoreVersions", id: version.id } }
+            }
+          }
+        })
+      });
+    await client.request(`/reviewSubmissions/${submission.id}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        data: { type: "reviewSubmissions", id: submission.id, attributes: { submitted: !0 } }
+      })
+    });
+    ids.push(submission.id);
+  }
+  return ids;
+}
+export async function prepareSafariAppStoreSubmission(client, config, appId, versions, options = {}) {
+  const store = config.safariAppStore;
+  if (!store)
+    throw Error("[browser-extension] Safari App Store automation needs safariAppStore in config/extension.ts");
+  const cwd = options.cwd ?? process.cwd(), timeoutMs = options.screenshotTimeoutMs ?? 600000, pollIntervalMs = options.screenshotPollIntervalMs ?? 5000;
+  await updateAppInfo(client, appId, store);
+  await ensurePrice(client, appId, store);
+  await ensureAvailability(client, appId, store.availableInNewTerritories ?? !0);
+  const results = [];
+  for (const version of versions) {
+    await updateVersion(client, version, store);
+    const localizationId = await ensureVersionLocalization(client, version.id, store);
+    await ensureReviewDetail(client, version.id, store);
+    for (const displayType of displayTypesForPlatform(version.platform)) {
+      const paths = store.screenshots[displayType] ?? [];
+      if (!paths.length)
+        continue;
+      const setId = await ensureScreenshotSet(client, localizationId, displayType);
+      await syncScreenshotSet(client, setId, paths, cwd, timeoutMs, pollIntervalMs);
+    }
+    results.push({ platform: version.platform, versionId: version.id, localizationId });
+  }
+  const shouldSubmit = options.submit ?? store.submitForReview ?? !1;
+  return {
+    appId,
+    versions: results,
+    reviewSubmissionIds: shouldSubmit ? await submitVersions(client, appId, versions) : []
+  };
+}
+export async function submitSafariAppStore(config, options) {
+  if (!config.safariBundleId)
+    throw Error("[browser-extension] Safari App Store submission needs safariBundleId in config/extension.ts");
+  const client = new AppStoreConnectClient(options), app = await client.findApp(config.safariBundleId);
+  if (!app)
+    throw Error("[browser-extension] the App Store Connect app record is missing");
+  const selectedPlatforms = options.platforms ?? config.safariPlatforms ?? ["macos"], availableVersions = await client.listAppStoreVersions(app.id), versions = [], versionStates = [];
+  for (const platform of selectedPlatforms) {
+    const match = availableVersions.find((item) => item.attributes.platform === applePlatform(platform) && item.attributes.versionString === options.version);
+    if (!match)
+      throw Error(`[browser-extension] Safari ${platform} App Store version ${options.version} does not exist`);
+    const build = await client.request(`/appStoreVersions/${match.id}/build`);
+    versions.push({ platform, id: match.id, buildId: build.data?.id });
+    versionStates.push(match.attributes.appStoreState);
+  }
+  if ((options.submit ?? config.safariAppStore?.submitForReview ?? !1) && versionStates.every((state) => !editableVersionStates.has(state))) {
+    const preparedVersions = await Promise.all(versions.map(async (version) => {
+      const localizations = await client.request(`/appStoreVersions/${version.id}/appStoreVersionLocalizations?limit=200`);
+      return { platform: version.platform, versionId: version.id, localizationId: localizations.data[0]?.id ?? "" };
+    }));
+    return {
+      appId: app.id,
+      versions: preparedVersions,
+      reviewSubmissionIds: await submitVersions(client, app.id, versions)
+    };
+  }
+  return await prepareSafariAppStoreSubmission(client, config, app.id, versions, options);
+}

package/dist/index.d.ts

@@ -9,6 +9,7 @@
  */
 export * from './build';
 export * from './app-store-connect';
+export * from './app-store-submission';
 export * from './chrome-web-store';
 export * from './config';
 export * from './firefox-addons';

package/dist/index.js

@@ -1,5 +1,6 @@
 export * from "./build";
 export * from "./app-store-connect";
+export * from "./app-store-submission";
 export * from "./chrome-web-store";
 export * from "./config";
 export * from "./firefox-addons";

package/dist/safari.d.ts

@@ -107,6 +107,8 @@ export declare interface SafariPublishOptions extends SafariSyncOptions, AppStor
   validateOnly?: boolean
   build?: boolean
   platforms?: SafariPlatform[]
+  processingTimeoutMs?: number
+  processingPollIntervalMs?: number
 }
 export declare interface SafariPublishedArtifact {
   platform: SafariPlatform
@@ -118,4 +120,9 @@ export declare interface SafariPublishResult {
   exportPath: string
   buildNumber: string
   artifacts: SafariPublishedArtifact[]
+  attachments: Array<{ platform: SafariPlatform, versionId: string, buildId: string, buildNumber: string }>
+  appStoreSubmission?: {
+    versions: Array<{ platform: SafariPlatform, versionId: string, localizationId: string }>
+    reviewSubmissionIds: string[]
+  }
 }

package/dist/safari.js

@@ -327,12 +327,12 @@ export async function publishSafariApp(config, options) {
   const platforms = resolveSafariPlatforms(config, options.platforms);
   if (!platforms.length)
     throw Error("[browser-extension] Safari publishing needs at least one platform");
-  const { provisionSafariApp } = await import("./app-store-connect");
-  if (!(await provisionSafariApp(config, {
+  const { AppStoreConnectClient, attachSafariBuilds, provisionSafariApp } = await import("./app-store-connect"), provisioned = await provisionSafariApp(config, {
     ...auth,
     version: options.version,
     platforms
-  })).appRecord.exists)
+  });
+  if (!provisioned.appRecord.exists)
     throw Error("[browser-extension] the App Store Connect app record is missing; create it once in App Store Connect before publishing");
   if (options.build !== !1)
     await buildExtension(config, { target: "safari", version: options.version, cwd });
@@ -372,6 +372,7 @@ export async function publishSafariApp(config, options) {
       `MARKETING_VERSION=${options.version}`,
       `CURRENT_PROJECT_VERSION=${buildNumber}`,
       `DEVELOPMENT_TEAM=${teamId}`,
+      "INFOPLIST_KEY_ITSAppUsesNonExemptEncryption=NO",
       ...platform === "ios" ? ["CODE_SIGNING_ALLOWED=NO"] : [],
       ...platform === "macos" && config.safariAppCategory ? [`INFOPLIST_KEY_LSApplicationCategoryType=${config.safariAppCategory}`] : [],
       ...authArgs,
@@ -390,10 +391,20 @@ export async function publishSafariApp(config, options) {
     ], projectCwd, `Safari ${platform} export`);
     artifacts.push({ platform, archivePath, exportPath });
   }
+  const attachments = options.validateOnly ? [] : await attachSafariBuilds(new AppStoreConnectClient(auth), provisioned.appRecord.id, provisioned.appStoreVersions, buildNumber, {
+    timeoutMs: options.processingTimeoutMs,
+    pollIntervalMs: options.processingPollIntervalMs
+  }), appStoreSubmission = !options.validateOnly && config.safariAppStore ? await (await import("./app-store-submission")).prepareSafariAppStoreSubmission(new AppStoreConnectClient(auth), config, provisioned.appRecord.id, attachments.map((attachment) => ({
+    platform: attachment.platform,
+    id: attachment.versionId,
+    buildId: attachment.buildId
+  })), { cwd }) : void 0, firstArtifact = artifacts[0];
   return {
-    archivePath: artifacts[0].archivePath,
-    exportPath: artifacts[0].exportPath,
+    archivePath: firstArtifact.archivePath,
+    exportPath: firstArtifact.exportPath,
     buildNumber,
-    artifacts
+    artifacts,
+    attachments,
+    appStoreSubmission: appStoreSubmission ? { versions: appStoreSubmission.versions, reviewSubmissionIds: appStoreSubmission.reviewSubmissionIds } : void 0
   };
 }

package/dist/types.d.ts

@@ -68,6 +68,65 @@ export declare interface FirefoxAddonsConfig {
   requiresPayment?: boolean
   artifactsDir?: string
 }
+export declare interface SafariAppStoreReviewContact {
+  firstName: string
+  lastName: string
+  phone: string
+  email: string
+  notes?: string
+}
+/** App Store age-rating answers. Omitted answers default to no content. */
+export declare interface SafariAppStoreAgeRating {
+  advertising?: boolean
+  alcoholTobaccoOrDrugUseOrReferences?: SafariAgeRatingFrequency
+  contests?: SafariAgeRatingFrequency
+  gambling?: boolean
+  gamblingSimulated?: SafariAgeRatingFrequency
+  gunsOrOtherWeapons?: SafariAgeRatingFrequency
+  healthOrWellnessTopics?: boolean
+  lootBox?: boolean
+  medicalOrTreatmentInformation?: SafariAgeRatingFrequency
+  messagingAndChat?: boolean
+  parentalControls?: boolean
+  profanityOrCrudeHumor?: SafariAgeRatingFrequency
+  ageAssurance?: boolean
+  sexualContentGraphicAndNudity?: SafariAgeRatingFrequency
+  sexualContentOrNudity?: SafariAgeRatingFrequency
+  socialMedia?: boolean
+  socialMediaAgeRestricted?: boolean
+  horrorOrFearThemes?: SafariAgeRatingFrequency
+  matureOrSuggestiveThemes?: SafariAgeRatingFrequency
+  unrestrictedWebAccess?: boolean
+  userGeneratedContent?: boolean
+  violenceCartoonOrFantasy?: SafariAgeRatingFrequency
+  violenceRealisticProlongedGraphicOrSadistic?: SafariAgeRatingFrequency
+  violenceRealistic?: SafariAgeRatingFrequency
+}
+/** Metadata and assets managed through the official App Store Connect API. */
+export declare interface SafariAppStoreConfig {
+  locale?: string
+  subtitle: string
+  privacyPolicyUrl: string
+  description: string
+  keywords: string
+  supportUrl: string
+  marketingUrl?: string
+  promotionalText?: string
+  whatsNew?: string
+  copyright: string
+  primaryCategory: string
+  contentRightsDeclaration: 'DOES_NOT_USE_THIRD_PARTY_CONTENT' | 'USES_THIRD_PARTY_CONTENT'
+  price: string
+  baseTerritory?: string
+  releaseType?: SafariAppStoreReleaseType
+  availableInNewTerritories?: boolean
+  usesIdfa?: boolean
+  usesNonExemptEncryption?: boolean
+  ageRating?: SafariAppStoreAgeRating
+  reviewContact: SafariAppStoreReviewContact
+  screenshots: Partial<Record<SafariScreenshotDisplayType, string[]>>
+  submitForReview?: boolean
+}
 export declare interface ExtensionConfig {
   name: string
   description: string
@@ -78,6 +137,7 @@ export declare interface ExtensionConfig {
   safariTeamId?: string
   safariPlatforms?: SafariPlatform[]
   safariAppCategory?: string
+  safariAppStore?: SafariAppStoreConfig
   safariExclude?: string[]
   targets?: ExtensionTarget[]
   background?: string
@@ -110,3 +170,6 @@ export declare interface BuildOptions {
  */
 export type ExtensionTarget = 'chrome' | 'firefox' | 'safari';
 export type SafariPlatform = 'macos' | 'ios';
+export type SafariScreenshotDisplayType = 'APP_DESKTOP' | 'APP_IPHONE_67' | 'APP_IPAD_PRO_3GEN_129';
+export type SafariAppStoreReleaseType = 'MANUAL' | 'AFTER_APPROVAL' | 'SCHEDULED';
+export type SafariAgeRatingFrequency = 'NONE' | 'INFREQUENT_OR_MILD' | 'FREQUENT_OR_INTENSE';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/browser-extension",
   "type": "module",
-  "version": "0.70.144",
+  "version": "0.70.146",
   "description": "Build MV3 browser extensions (Chrome, Firefox, Safari) the Stacks way — manifest, content/background scripts, DNR rules, packaging, Safari container app, all config-driven.",
   "author": "Chris Breuer",
   "contributors": [