Few experiences in mobile release engineering are as frustrating as waiting 20 minutes for a 200 MB iOS application archive (.ipa) to upload to App Store Connect, only to encounter an immediate rejection error from Apple's Transporter service or receive an automated email minutes later informing you that your build is INVALID.
Many common issues—such as an unincremented build number, a mismatched bundle identifier, a malformed property list, or packaging an unarchived folder—can be caught on your local machine before a single byte leaves your computer.
FlightDeck includes an offline package inspection engine (build_upload_preview) designed to inspect and validate compiled .ipa packages before initiating an upload. Through conversational prompts with your AI coding assistant, FlightDeck audits archive structure and metadata in seconds, preventing unnecessary network transfers.
This guide explores the anatomy of an .ipa package, breaks down exactly what FlightDeck validates locally, explains which checks must be performed using macOS command-line tools or Apple's ingestion servers, and shows how to run pre-upload checks with your AI assistant.
The Anatomy of an iOS Application Archive (.ipa)
An .ipa file is not a proprietary opaque binary format. It is a standard ZIP archive structured according to Apple's bundle specifications:
MyApp.ipa (ZIP Container)
└── Payload/
└── MyApp.app/
├── MyApp (Mach-O compiled binary executable)
├── Info.plist (Application configuration & metadata)
├── embedded.mobileprovision (Cryptographic provisioning profile)
├── Assets.car (Compiled asset catalog & icon sets)
├── Frameworks/ (Embedded dynamic frameworks & dylibs)
└── _CodeSignature/
└── CodeResources (XML signature manifest of all resources)
When you instruct an upload tool to deliver an .ipa to App Store Connect, Apple's ingestion system unpacks this archive and performs rigorous analysis on its contents. If any required component is missing or misconfigured, Apple rejects the package.
What FlightDeck Validates Offline
When you prompt your AI assistant to preview an upload, FlightDeck uses its in-process ArtifactInspector engine to evaluate package structure and metadata offline.
┌────────────────────────────────────────┐
│ FlightDeck Local Package Inspection │
└───────────────────┬────────────────────┘
│
┌────────────────────────────┼────────────────────────────┐
▼ ▼ ▼
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
│ Container Check │ │ Security Bounds │ │ Metadata Match │
├──────────────────┤ ├──────────────────┤ ├──────────────────┤
│ • Valid ZIP file │ │ • Entry count lim│ │ • CFBundleId match│
│ • Payload/ dir │ │ • No traversal ..│ │ • Semantic version│
│ • Single .app │ │ • Size limits │ │ • Numeric build │
│ • Rejects dirs │ │ • No symlink plist│ │ • Target platform│
└──────────────────┘ └──────────────────┘ └──────────────────┘
FlightDeck performs the following concrete checks directly on your local workstation:
- File Container Verification: Confirms the target path is an existing, non-empty packaged file (
.ipa,.pkg, or.zip). If a developer accidentally passes an unpackaged.appdirectory or raw.xcarchive, FlightDeck halts immediately with anUnsupportedArtifactException, reminding you that App Store Connect requires an archive package. - ZIP Decompression Bounds: Decodes the archive in memory using pure Dart decoders, enforcing safe bounds (up to 10,000 entries) to defend against zip-bomb denial-of-service vulnerabilities.
- Directory Traversal Defense: Scans entry paths to ensure no entry contains
.., leading slashes, backslashes, null bytes, or traversal tokens, and verifies thatInfo.plistis not a symbolic link. - Bounded Extraction: Enforces a 10 MB limit on the decompressed
Info.plistto prevent memory exhaustion from corrupt archives. - In-Process Property List Parsing: Natively parses binary property lists (
bplist00) and XML property lists to extract metadata without invoking external shell scripts. - Bundle Identifier Matching: Compares the extracted
CFBundleIdentifieragainst your registered App Store Connect app record (app.bundleId) to prevent uploading a staging build to a production container. - Marketing Version Verification: Extracts
CFBundleShortVersionStringand validates it against expected semantic version formats. - Build Number Integrity: Extracts
CFBundleVersionand confirms it contains valid numeric components. - Target Platform Inference: Determines whether the application targets
IOSorMAC_OSbased on bundle structure and property list contents. - Streaming Digest Computation: Generates SHA-256 and MD5 cryptographic checksums of the entire archive for upload part verification without buffering the full file into memory.
Technical Inspection Boundaries: FlightDeck vs. Local CLI vs. Apple
To avoid false expectations, developers must understand what FlightDeck validates versus what requires local macOS developer tools or Apple's server-side ingestion:
| Validation Capability | Checked by FlightDeck (build_upload_preview) |
Checked via Local macOS Tools (codesign, lipo) |
Checked by Apple During Ingestion / Processing |
|---|---|---|---|
| ZIP archive & entry bounds | Yes | Yes (unzip -t) |
Yes |
*Payload/.app bundle presence** |
Yes | Yes | Yes |
Info.plist bundle ID match |
Yes | Yes (plutil) |
Yes |
| Version & build number format | Yes | Yes (plutil) |
Yes |
| Streaming SHA-256 / MD5 digest | Yes | Yes (shasum) |
Yes |
Mach-O CPU architecture slices (arm64) |
No | Yes (lipo -info) |
Yes |
| Mach-O header structure | No | Yes (otool -h) |
Yes |
| Cryptographic code signatures | No | Yes (codesign -dv) |
Yes |
Provisioning profile trust & get-task-allow |
No | Yes (security cms) |
Yes |
| Nested framework signatures | No | Yes (codesign --verify) |
Yes |
| Apple certificate revocation (OCSP) | No | No | Yes |
| Private Apple API symbol usage | No | No | Yes |
| App Review Guideline compliance | No | No | Yes (Human Review) |
No Acceptance Guarantee: FlightDeck's build_upload_preview verifies local package integrity and bundle metadata alignment. It does not parse Mach-O headers, check CPU architecture slices, verify cryptographic signature trust, or scan for private API symbols. Running build_upload_preview cannot guarantee that Apple's backend processing will accept the binary.
Running Local Binary Checks with macOS Developer Tools
If you need to verify executable architectures or code signatures before uploading, your AI coding assistant can run native macOS command-line tools in your local terminal. These tools are part of Apple's Xcode Command Line Tools, not FlightDeck.
1. Verifying ARM64 Architecture Slices (lipo)
To confirm that your executable contains the required 64-bit ARM device slice rather than an x86_64 simulator binary:
# Unpack archive into a temporary folder
mkdir -p /tmp/inspect_ipa
unzip -q /path/to/MyApp.ipa -d /tmp/inspect_ipa
# Inspect Mach-O binary architecture slices
lipo -info /tmp/inspect_ipa/Payload/*.app/MyApp
Expected output for a physical iOS device build:
Non-fat file: /tmp/inspect_ipa/Payload/MyApp.app/MyApp is architecture: arm64
2. Verifying Code Signatures and Entitlements (codesign)
To verify that the application is signed with an Apple Distribution identity and has production entitlements:
# Check signing authority
codesign -dv --verbose=4 /tmp/inspect_ipa/Payload/*.app
# Verify signature validity on disk
codesign --verify --deep --strict --verbose=2 /tmp/inspect_ipa/Payload/*.app
# Inspect embedded profile get-task-allow (must be 0 for production)
security cms -D -i /tmp/inspect_ipa/Payload/*.app/embedded.mobileprovision | grep -A 1 get-task-allow
Inspecting Your Binary Using Natural Language AI Prompts
Through FlightDeck, you can ask your AI coding assistant to inspect your .ipa archive using conversational English. FlightDeck handles the offline package inspection and validates metadata against App Store Connect.
Because inspecting local archives is an offline, read-only analysis (Tier 2), FlightDeck executes the inspection immediately without requiring manual approval.
Pre-Upload Inspection Prompt
Copy and paste this prompt into your connected AI coding assistant:
Inspect the local iOS archive at [path/to/MyApp.ipa] using FlightDeck. Verify its package structure, Info.plist metadata, bundle identifier, and version numbers against App Store Connect for [Your App Name], and confirm whether it is ready to be staged for upload.
Your assistant connects to FlightDeck, unpacks the archive in memory, and reports:
- The package structure and whether a valid
Payload/*.appbundle exists. - The extracted bundle ID (
CFBundleIdentifier) and whether it matches your registered App Store Connect app record. - The marketing version (
CFBundleShortVersionString) and build number (CFBundleVersion). - The inferred target platform (
IOSorMAC_OS). - The computed file size and SHA-256 digest.
Staging the Upload in the FlightDeck Approval Center
Once local inspection confirms that your archive is structurally sound and matches your App Store Connect app record, prompt your AI assistant to stage the upload:
The pre-upload validation passed. Stage an upload of [path/to/MyApp.ipa] to App Store Connect for [Your App Name] and show me the approval summary before delivering.
Because delivering a new binary creates resources on Apple's servers, FlightDeck intercepts the mutating network request and stages it for your review. FlightDeck Desktop displays the Approval Center sheet:
Illustrative representation of the FlightDeck Approval Center sheet:
┌──────────────────────────────────────────────────────────────┐
│ FlightDeck Desktop — Operation Approval Request │
├──────────────────────────────────────────────────────────────┤
│ Operation: Deliver iOS Binary (.ipa) │
│ Target App: [Your App Name] (App ID: 6812899314) │
│ Binary Path: /path/to/MyApp.ipa │
│ Version: 1.0.0 (Build 12) │
│ Platform: iOS │
│ Action: Upload binary parts to Apple Ingestion Storage │
│ Impact: Stages build for Apple server processing. │
├──────────────────────────────────────────────────────────────┤
│ [Reject Proposal] [Approve & Execute] │
└──────────────────────────────────────────────────────────────┘
Review the parameters in FlightDeck Desktop and click Approve & Execute. FlightDeck streams the binary in chunked parts directly to Apple's ingestion storage.
Summary Checklist and Related Resources
| Inspection Step | What Is Checked | Tool Used |
|---|---|---|
| Package Structure | Valid ZIP container, Payload/*.app/Info.plist |
FlightDeck build_upload_preview |
| App Alignment | Bundle ID matches App Store Connect app record | FlightDeck build_upload_preview |
| Version & Build | Valid semantic version and numeric build counter | FlightDeck build_upload_preview |
| Architecture | Mach-O executable contains arm64 device slice |
Local macOS CLI (lipo -info) |
| Code Signing | Apple Distribution identity, get-task-allow = 0 |
Local macOS CLI (codesign, security cms) |
| Delivery Staging | Human review of target app, version, and file path | FlightDeck Desktop Approval Center |
Related Resources
- Uploading iOS IPAs to App Store Connect Without Xcode
- Fixing ITMS-90034, ITMS-90035, and Code-Signing Errors on App Store Upload
- Uploading React Native and Expo IPAs to App Store Connect with AI
- Why Is My TestFlight Build Stuck on Processing? Causes and Fixes
- Fixing Missing Encryption Key (ITSAppUsesNonExemptEncryption)