The Five Days Between the iOS 27 RC and Release — I Check Init Order and Entitlement Restore Before Layout

<!-- .antigravity/rules/os-update-window.md -->
# Search scope for the OS update window
 
Limit the scope to "the path executed from app launch until the first frame is drawn."
Read only these three kinds of files:
 
1. Files containing `application(_:didFinishLaunchingWithOptions:)` or `@main`
2. Initialization helpers called synchronously from the above
3. `Info.plist` and `*.entitlements`
 
Do not read layout definitions, assets, or localized strings unless explicitly asked.
 
Reporting format:
- Before proposing any change, output the resolved execution order first
- Where the order cannot be determined, say "undetermined" and do not guess an ordering

#!/usr/bin/env python3
"""Launch-path audit - only the ordering and entitlement surface that matters before an OS update."""
import os, re, sys, json
 
# Calls whose order carries meaning. We want them to appear left to right.
ORDERED_CALLS = [
    ("att_request",  r"requestTrackingAuthorization"),
    ("ads_start",    r"(MobileAds|GADMobileAds)[^\n]{0,40}\.(start|startWithCompletionHandler)"),
]
# Synchronous work that tends to stall right after launch
BLOCKING_IN_LAUNCH = r"(Data\(contentsOf:|contentsOfFile:|semaphore\.wait|DispatchSemaphore)"
# Traces of the older purchase API that never moved to current entitlements
LEGACY_STOREKIT = r"(SKPaymentQueue|SKPayment\b|restoreCompletedTransactions)"
# Hardcoded size branches - only comparisons against known point values
DEVICE_POINTS = {375, 390, 393, 402, 414, 420, 428, 430, 440,
                 812, 844, 852, 874, 896, 912, 926, 932, 956}
HARDCODED_SIZE = re.compile(r"[=<>!]=?\s*(\d{3})(?:\.0)?\b|\b(\d{3})(?:\.0)?\s*[=<>!]=")
LAUNCH_ENTRY = r"(didFinishLaunchingWithOptions|@main|applicationDidFinishLaunching)"
 
USAGE_KEYS = [
    "NSUserTrackingUsageDescription",
    "NSPhotoLibraryAddUsageDescription",
    "NSLocalNetworkUsageDescription",
]
 
def scan(root):
    report = {"launch_files": [], "order": [], "blocking": [], "legacy_storekit": [],
              "hardcoded_size": [], "missing_usage_keys": []}
    for dirpath, dirnames, filenames in os.walk(root):
        dirnames[:] = [d for d in dirnames if d not in {".git", "Pods", "build", "DerivedData"}]
        for fn in filenames:
            p = os.path.join(dirpath, fn)
            if fn.endswith((".swift", ".m", ".mm", ".h")):
                try:
                    src = open(p, encoding="utf-8", errors="ignore").read()
                except OSError:
                    continue
                rel = os.path.relpath(p, root)
                if re.search(LAUNCH_ENTRY, src):
                    report["launch_files"].append(rel)
                    pos = {}
                    for name, pat in ORDERED_CALLS:
                        m = re.search(pat, src)
                        if m:
                            pos[name] = m.start()
                    # Judge only when both land in the same file; otherwise stay silent
                    if len(pos) == len(ORDERED_CALLS):
                        seq = [k for k, _ in ORDERED_CALLS]
                        if [pos[k] for k in seq] != sorted(pos[k] for k in seq):
                            report["order"].append({"file": rel, "found": pos})
                    for m in re.finditer(BLOCKING_IN_LAUNCH, src):
                        report["blocking"].append(
                            {"file": rel, "line": src[:m.start()].count("\n") + 1, "hit": m.group(0)})
                for m in re.finditer(LEGACY_STOREKIT, src):
                    report["legacy_storekit"].append(
                        {"file": rel, "line": src[:m.start()].count("\n") + 1, "hit": m.group(0)})
                for m in HARDCODED_SIZE.finditer(src):
                    value = int(m.group(1) or m.group(2))
                    if value in DEVICE_POINTS:
                        report["hardcoded_size"].append(
                            {"file": rel, "line": src[:m.start()].count("\n") + 1, "value": value})
            elif fn == "Info.plist":
                try:
                    plist = open(p, encoding="utf-8", errors="ignore").read()
                except OSError:
                    continue
                rel = os.path.relpath(p, root)
                missing = [k for k in USAGE_KEYS if k not in plist]
                if missing:
                    report["missing_usage_keys"].append({"file": rel, "missing": missing})
    return report
 
if __name__ == "__main__":
    root = sys.argv[1] if len(sys.argv) > 1 else "."
    r = scan(root)
    print(json.dumps(r, ensure_ascii=False, indent=2))
    # Only ordering violations and launch-time blocking exit non-zero
    sys.exit(1 if (r["order"] or r["blocking"]) else 0)

{
  "order": [
    {"file": "App/AppDelegate.swift", "found": {"att_request": 394, "ads_start": 321}}
  ],
  "blocking": [
    {"file": "App/AppDelegate.swift", "line": 15, "hit": "Data(contentsOf:"}
  ],
  "hardcoded_size": [
    {"file": "App/AppDelegate.swift", "line": 13, "value": 440}
  ],
  "missing_usage_keys": [
    {"file": "App/Info.plist", "missing": ["NSLocalNetworkUsageDescription"]}
  ]
}