Run a virtual iPhone on an Apple Silicon Mac.
Swift
Apple TV 4K (4th generation) bringup
Guilherme Ramboa67b3941df71
diff --git a/Documents/Downloads/README.md b/Documents/Downloads/README.mdindex bbc686b7..045f6301 100644--- a/Documents/Downloads/README.md+++ b/Documents/Downloads/README.md@@ -36,6 +36,7 @@ Use a `VPhone.bundle` from the same series as Launchpad. The series is the first| Launchpad | VPhone.bundle || --- | --- |+| 2.13.x | 2.13.x || 2.12.x | 2.12.x || 2.11.x | 2.11.x || 2.10.x | 2.10.x |@@ -52,6 +53,9 @@ Use a `VPhone.bundle` from the same series as Launchpad. The series is the firstWithin a series, install the newest `VPhone.bundle`. Patch releases fix problems without changing how Launchpad and the bundle work together.+Series 2.13 adds Apple TV 4K (4th generation). Use Launchpad 2.13 with its+bundle so New Machine selects the `tvos-4k` preset for `AppleTV18,1`.+Launchpad refuses a `VPhone.bundle` that is too old for it, but it may still list bundles from a newer series. Do not install those; update Launchpad to that series first. Launchpad does not update itself: download the new version from the release page and replace the old app.VMs created by 1.x do not start in 2.x. For 1.x, see the [1.0.14 release](https://github.com/Lakr233/vphone-cli/releases/tag/1.0.14).diff --git a/Documents/Guides/compatibility.md b/Documents/Guides/compatibility.mdindex 1ec595ec..fc410ada 100644--- a/Documents/Guides/compatibility.md+++ b/Documents/Guides/compatibility.md@@ -77,6 +77,13 @@ Checked on 2026-10-23 on Mac mini M4 hosts (Mac16,10, 16 GB, macOS 26.6.2 25G83)The tvOS 27.0 (24J361) and HomePod Software 27.2 (24K120) OTAs compress their payload with LZRAVEN, which only macOS 27 unpacks. On an older Mac `fw catalog` leaves them out, so Launchpad's default for those devices is tvOS 26.6 and HomePod Software 27.0, and naming one is refused before anything is downloaded.+Apple TV 4K (4th generation), `AppleTV18,1` / `J265AP`, is available for+bring-up with tvOS 27.2 beta (`24K120`) only, using its full OTA over the+Apple TV HD 26.6 restore base and cloudOS 26.4 beta (`23E5207q`). It requires+macOS 27 and the `tvos-4k` preset. Installation and a live boot have not yet+been verified; it is not included in the tested table above. See the+[bring-up notes](../../Research/Firmware/tvos_support.md#apple-tv-4k-4th-generation).+cloudOS 26.7 (23H20) has no iPhone release to pair with. Staged with iOS 26.6.2's userland, its mix links and its 28 kernelcache patches apply; the CFW patch `_vm_fault_enter_prepare` finds no site in that kernel. It has not booted.`vphone-escalator`'s allowlist is kept in amfid's memory, so it is lost when amfid restarts, as it did once on these hosts mid-run. Launchpad allows the bundle again when AMFI refuses it; from the CLI, run the `vphone-escalator allow` command `host preflight` prints again.diff --git a/Documents/Guides/launchpad-cli.md b/Documents/Guides/launchpad-cli.mdindex 31d81ca2..5fdcca5c 100644--- a/Documents/Guides/launchpad-cli.md+++ b/Documents/Guides/launchpad-cli.md@@ -129,6 +129,12 @@ version while a machine is bound to it; rebind or delete those machines first.| `guest unlock <name> [--passcode <code>] [--timeout <seconds>]` | Turn the screen on and unlock the guest, whatever state it was in (vphoned `screen.unlock`). `--passcode` is needed only when the guest has one || `exec [--bundle <version>] <vphone-cli arguments>` | Run the default bundle's `vphone-cli`, or that version's, streaming its output. `--bundle` must come first |+Apple TV 4K (4th generation) uses `--device AppleTV18,1` with Launchpad and+Core Bundle 2.13. It selects `tvos-4k`, restores independently without slimming,+and takes tvOS 27.2 beta (`24K120`) from its full OTA over the Apple TV HD base.+Creation requires macOS 27. A live boot is still pending; see the+[bring-up notes](../../Research/Firmware/tvos_support.md#apple-tv-4k-4th-generation).+### Patch overrides in `vm create``--block <patch>` and `--allow <patch>` take the identifiers `vphone-cli fwdiff --git a/Research/0_binary_patch_comparison.md b/Research/0_binary_patch_comparison.mdindex b7f6082a..3561e270 100644--- a/Research/0_binary_patch_comparison.md+++ b/Research/0_binary_patch_comparison.md@@ -385,6 +385,19 @@> off. See> [tvOS support](Firmware/tvos_support.md#apple-tv-4k-from-its-ota).+> **Apple TV 4K, 4th generation (2026-10-23).** `AppleTV18,1` / `J265AP`+> reuses `tvos-4k`, the Apple TV HD 26.6 restore base, and cloudOS 26.4 beta+> (`23E5207q`). Its only catalog release is the supplied Pallas tvOS 27.2 beta+> OTA (`24K120`; asset alias `24K6120` shares the archive). OTA manifest+> validation refuses other OS versions for this board. Patch discovery preserves+> the recorded J265 identity over the HD manifest, and Launchpad selects the 4K+> preset. No new binary patch or preset is introduced. The real OTA staged its+> J265 tree and all 42 chunks; `fw patch` processed all 11 components with 239+> patches, and the selected cache patchers passed dry runs against its userland.+> Launchpad and the bundle move to series 2.13 so earlier Launchpad builds cannot+> choose the HD preset for the new device. Privileged installation and a live+> boot remain pending. See [bring-up notes](Firmware/tvos_support.md#apple-tv-4k-4th-generation).+> **tvOS 27 on the Apple TV 4K (2026-10-16).** No new patch. The 4K's tvOS 27.0> (24J361) OTA goes over the HD's 26.6 IPSW, and the plan resolves for the OTA's> version. `system-tv-exp-ota_userland` now applies from 26.0 on (it was gated ondiff --git a/Research/Firmware/tvos_support.md b/Research/Firmware/tvos_support.mdindex bee7222c..82aaad7f 100644--- a/Research/Firmware/tvos_support.md+++ b/Research/Firmware/tvos_support.md@@ -1,5 +1,71 @@# tvOS support+## Apple TV 4K (4th generation)++Added on 2026-10-23: `AppleTV18,1`, board `J265AP` (`j265ap`), with **tvOS+27.2 only**. The supplied Pallas SoftwareUpdate response lists beta assets+`24K120` and `24K6120` pointing to the same AEA archive and key. Its actual+BuildManifest and SystemVersion both identify `27.2` / `24K120`, so the catalog+uses that build and offers one pairing. The archive is 5,234,491,392 bytes,+SHA-256 `a98cff4d0006b4c047c4eff163c5c1cb17fe0d1f67005ea575050523c7b858f7`.+The URL and public symmetric key are recorded in `VPhoneFirmwareCatalog`.++This board reuses the 3rd generation's OTA path: Apple TV HD 26.6 (`23L773`)+provides the restore base, cloudOS 26.4 beta (`23E5207q`) provides the boot+chain/kernel, and the OTA supplies J265's tree and System userland. The virtual+canvas is 3840×2160 at 2x. Its payload chunks use `pbzm` / LZRAVEN, so creation+requires macOS 27. On an older host there is no catalog pairing for this model;+it cannot fall back to tvOS 26.6. OTA identity checks reject OS versions other+than 27.2, including renamed local archives.++Both `vm create` and Launchpad New Machine use the existing `tvos-4k` preset+and a standalone restore without template slimming:++```zsh+vphone-cli vm create tv4k4 --device AppleTV18,1 --cpu 4 --memory 4096 --disk-size 48+```++Use Launchpad and VPhone.bundle **2.13** together. Earlier Launchpad versions+would choose the HD preset for this new product type. The CLI/catalog schema+is unchanged; the new series keeps that preset decision paired with the new+device catalog. Firmware patch discovery now preserves any recorded OTA board+with a restore base, so the HD manifest cannot replace J265's guest identity.+No new binary patch or preset is needed.++Validation completed without admin privileges:++- Xcode builds of `VPhone.bundle` and Launchpad; core identity/catalog tests,+ all 113 archive tests, 116 selected firmware/device-tree tests, and 32 patch+ model tests passed. Two TCP timing tests failed in the full core run and+ passed when rerun individually. Launchpad product/catalog and bundle-version+ tests passed.+- `fw prepare` against the real OTA and cached base/cloudOS IPSWs decrypted+ the archive, verified `27.2` / `24K120`, staged `DeviceTree.j265ap.im4p` and+ all **42** payload chunks, reused the cached GPU driver, and recorded+ `AppleTV18,1` in `config.plist`.+- `fw patch` with `tvos-4k` processed all **11** components and applied **239**+ patches. The patched device tree reports model `AppleTV18,1`, target `J265`,+ and subtype `J265AP`. No undeclared-patch warnings appeared.+- Selective, unprivileged extraction confirmed dyld and launchd are arm64e+ `USR00`, and SystemVersion reports `27.2` / `24K120`. Dry runs of the five+ enabled tvOS 27 cache patchers succeeded: IOMFB found 10 trampolines, lsd and+ libxpc found their gates, maxSlide needed no change because the cache fits,+ and lockdown mode had no target. The cache-loader gate patch also succeeded+ on a separate extracted copy.++**Still pending:** bundle installation through Launchpad, restore, privileged+`cfw install`, and both guest boots. Host-side patch success does not establish+a working J265 guest. No installed bundle or existing machine was changed.+The prepared and patched test machine is at+`/private/tmp/vphone-appletv18-validation/tv4k4`; logs are+`/private/tmp/vphone-appletv18-prepare.log` and+`/private/tmp/vphone-appletv18-patch.log`. Resume the normal restore/install+pipeline with the matching 2.13 bundle when admin authorization is available,+then verify vphoned identity, TVSetup, 4K rendering, and input before recording+a live-boot claim.++## Earlier Apple TV validation+Validated on 2026-10-15: AppleTV5,3 tvOS 26.4 beta 1 (23L5208m) on thecloudOS 26.4 beta (23E5207q) vphone600ap platform boots to TVSetup and Settings.The same VM booted normally with four CPUs after installing the persistent@@ -21,8 +87,8 @@ lists tvOS 26.6 for the Apple TV HD, and New Machine and `vm create --deviceAppleTV5,3` build it with the `tvos` preset.tvOS 27 dropped the Apple TV HD, and Apple publishes no IPSW for any Apple TV-4K: AppleDB lists only OTA packages for AppleTV11,1 and AppleTV14,1, and-AppleTV18,1 is not released. An Apple TV 4K (AppleTV14,1) guest is the HD's+4K. The 3rd generation (AppleTV14,1) and 4th generation (AppleTV18,1) use+full OTAs. An Apple TV 4K guest is the HD's26.6 restore with the 4K's identity and arm64e userland taken from its OTA;`fw prepare` reads the OTA itself. See[Apple TV 4K from its OTA](#apple-tv-4k-from-its-ota).diff --git a/VPhoneExecutable/VPhoneCommand/FirmwarePatcher/Pipeline/FirmwarePipelineDiscovery.swift b/VPhoneExecutable/VPhoneCommand/FirmwarePatcher/Pipeline/FirmwarePipelineDiscovery.swiftindex d9f71183..6923251b 100644--- a/VPhoneExecutable/VPhoneCommand/FirmwarePatcher/Pipeline/FirmwarePipelineDiscovery.swift+++ b/VPhoneExecutable/VPhoneCommand/FirmwarePatcher/Pipeline/FirmwarePipelineDiscovery.swift@@ -88,8 +88,8 @@ extension FirmwarePipeline {// An Apple TV 4K has no IPSW: it is built over an Apple TV HD restore// and takes its userland from an OTA, so the HD's manifest never lists// it. Its own device tree, placed in the restore tree, presents it.- if recorded?.guestDevice == .appleTV14_1 {- return .appleTV14_1+ if let guest = recorded?.guestDevice, guest.restoreBase != nil {+ return guest}return VPhoneGuestDevice.detect(buildManifestAt: restoreDir.appendingPathComponent("iPhone-BuildManifest.plist"),diff --git a/VPhoneExecutable/VPhoneCommand/FirmwarePatcherTests/PatchSets/FirmwareGuestPatchResolutionTests.swift b/VPhoneExecutable/VPhoneCommand/FirmwarePatcherTests/PatchSets/FirmwareGuestPatchResolutionTests.swiftindex ff438a04..9aeee471 100644--- a/VPhoneExecutable/VPhoneCommand/FirmwarePatcherTests/PatchSets/FirmwareGuestPatchResolutionTests.swift+++ b/VPhoneExecutable/VPhoneCommand/FirmwarePatcherTests/PatchSets/FirmwareGuestPatchResolutionTests.swift@@ -184,8 +184,8 @@ struct FirmwareGuestPatchResolutionTests {#expect(FirmwareGuestPatchResolution.unvalidatedTVGuestPatches(enabled: ["dyld-cfw-camera"], arm64eUserland: true) == ["dyld-cfw-camera"])}- @Test- func `the Apple TV 4K preset swaps in the OTA userland with the GPU driver and no TPRO patches`() throws {+ @Test(arguments: ["27.0", "27.2"])+ func `the Apple TV 4K preset swaps in the OTA userland with the GPU driver and no TPRO patches`(version: String) throws {let gpu = "system-extensions-boot-gpu_bundle"let ota = FirmwareGuestSystemPatchSet.tvOTAUserlandlet tpro: Set = [FirmwareGuestSystemPatchSet.tvTPRO, FirmwareKernelCustomFirmwarePatchSet.tvTPROPagers]@@ -210,7 +210,7 @@ struct FirmwareGuestPatchResolutionTests {let tv4K27 = try VPhonePatchPlan.resolve(preset: FirmwarePatchSetCatalog.tvOS4KPreset,patchSets: FirmwarePatchSetCatalog.bundled,- iOSBase: VPhoneVersion("27.0"),+ iOSBase: VPhoneVersion(version),cloudOS: VPhoneVersion("26.4"),)// The userland swap and the GPU driver carry on to the 27 OTA.diff --git a/VPhoneExecutable/VPhoneCommand/FirmwarePatcherTests/Pipeline/FirmwarePipelineOriginalsTests.swift b/VPhoneExecutable/VPhoneCommand/FirmwarePatcherTests/Pipeline/FirmwarePipelineOriginalsTests.swiftindex 6bee0d25..303ff183 100644--- a/VPhoneExecutable/VPhoneCommand/FirmwarePatcherTests/Pipeline/FirmwarePipelineOriginalsTests.swift+++ b/VPhoneExecutable/VPhoneCommand/FirmwarePatcherTests/Pipeline/FirmwarePipelineOriginalsTests.swift@@ -17,6 +17,7 @@@testable import FirmwarePatcherimport Foundationimport Testing+import VPhoneCoreKitimport VPhonePatchKit// MARK: - Harness@@ -114,6 +115,30 @@ private struct FakeVM {// MARK: - Testsstruct FirmwarePipelineOriginalsTests {+ @Test(arguments: [VPhoneGuestDevice.appleTV14_1, .appleTV18_1])+ func `patch discovery preserves each OTA board over the HD restore manifest`(device: VPhoneGuestDevice) throws {+ let vm = try FakeVM()+ defer { vm.remove() }+ let manifest: [String: Any] = [+ "SupportedProductTypes": ["AppleTV5,3"],+ "ProductVersion": "26.6",+ "ProductBuildVersion": "23L773",+ ]+ try PropertyListSerialization.data(fromPropertyList: manifest, format: .xml, options: 0)+ .write(to: vm.restoreDir.appendingPathComponent("iPhone-BuildManifest.plist"))+ try VPhoneVirtualMachineManifest.newVM().updating(guestDevice: device)+ .write(to: vm.root.appendingPathComponent("config.plist"))+ #expect(vm.pipeline().readGuestDevice(vm.restoreDir) == device)+ let ota = ["ProductVersion": "27.2", "ProductBuildVersion": "24K120"]+ try PropertyListSerialization.data(fromPropertyList: ota, format: .xml, options: 0)+ .write(to: vm.restoreDir.appendingPathComponent(FirmwarePipeline.otaVersionFileName))+ #expect(FirmwarePipeline.readBaseProductVersion(vm.restoreDir) == "27.2")+ // An IPSW-backed board still follows the manifest when it disagrees.+ try VPhoneVirtualMachineManifest.newVM().updating(guestDevice: .iPad16_1)+ .write(to: vm.root.appendingPathComponent("config.plist"))+ #expect(vm.pipeline().readGuestDevice(vm.restoreDir) == .appleTV5_3)+ }+@Test func `patching twice succeeds and lands on the same bytes`() throws {let vm = try FakeVM()defer { vm.remove() }diff --git a/VPhoneExecutable/VPhoneCommand/VPhoneCommand/Firmware/VPhoneCustomFirmwareInstaller.swift b/VPhoneExecutable/VPhoneCommand/VPhoneCommand/Firmware/VPhoneCustomFirmwareInstaller.swiftindex 12171873..ef39cf86 100644--- a/VPhoneExecutable/VPhoneCommand/VPhoneCommand/Firmware/VPhoneCustomFirmwareInstaller.swift+++ b/VPhoneExecutable/VPhoneCommand/VPhoneCommand/Firmware/VPhoneCustomFirmwareInstaller.swift@@ -444,7 +444,7 @@ struct VPhoneCustomFirmwareInstaller {// Resolved once the system volume is mounted (it needs the "was// installed" signal there), then used again by the Preboot pass.var priorGuest = Set<String>()- var installedHomePodUserland: VPhoneRestoreInfo.OSVersion?+ var installedOTAUserland: VPhoneRestoreInfo.OSVersion?do {// Every descriptor on a guest volume lives in this scope, so none// is left open to hold the volume busy when it is unmounted.@@ -514,7 +514,8 @@ struct VPhoneCustomFirmwareInstaller {environmentOnly: true,)}- if device.family == .homePod, liveGuest.contains(FirmwareGuestSystemPatchSet.homePodOTAUserland) {+ if liveGuest.contains(FirmwareGuestSystemPatchSet.homePodOTAUserland)+ || liveGuest.contains(FirmwareGuestSystemPatchSet.tvOTAUserland) {// Read the installed bytes while the private System is still// mounted. Preparation/base restore must never promote this// host label before a successful OTA System installation.@@ -522,9 +523,9 @@ struct VPhoneCustomFirmwareInstaller {guard let version = try PropertyListSerialization.propertyList(from: data, format: nil) as? [String: Any],let product = version["ProductVersion"] as? String,let build = version["ProductBuildVersion"] as? String else {- throw ValidationError("Installed HomePod userland has no SystemVersion identity.")+ throw ValidationError("Installed OTA userland has no SystemVersion identity.")}- installedHomePodUserland = .init(version: product, build: build)+ installedOTAUserland = .init(version: product, build: build)}}// The selected Preboot identity can also reach an installed guest through@@ -620,19 +621,19 @@ struct VPhoneCustomFirmwareInstaller {in: bundleDirectory,owner: invokingUser.map { ($0.uid, $0.gid) },)- if let installedHomePodUserland {+ if let installedOTAUserland {let installedBundle = URL(fileURLWithPath: bundlePath, isDirectory: true)let record: () throws -> Void = {let vm = try VPhoneBundle.load(at: installedBundle)let variant = VPhoneRestoreInfo.load(fromBundle: vm)?.variant ?? "jb"_ = try VPhoneRestoreInfo.recordVariant(variant, toBundle: vm,- installedUserland: installedHomePodUserland)+ installedUserland: installedOTAUserland)}do {if let invokingUser { try invokingUser.withUserCredentials(record) }else { try record() }} catch {- fputs("warning: could not record installed HomePod userland: \(error)\n", stderr)+ fputs("warning: could not record installed OTA userland: \(error)\n", stderr)}}switch mode {diff --git a/VPhoneExecutable/VPhoneVirtualization/Resources/Info.plist b/VPhoneExecutable/VPhoneVirtualization/Resources/Info.plistindex f0c329ec..ea79ea41 100644--- a/VPhoneExecutable/VPhoneVirtualization/Resources/Info.plist+++ b/VPhoneExecutable/VPhoneVirtualization/Resources/Info.plist@@ -9,9 +9,9 @@<key>CFBundlePackageType</key><string>BNDL</string><key>CFBundleVersion</key>- <string>46</string>+ <string>47</string><key>CFBundleShortVersionString</key>- <string>2.12.1</string>+ <string>2.13.0</string><key>NSMicrophoneUsageDescription</key><string>Shares this Mac's microphone with the virtual iPhone so apps running inside it can record.</string></dict>diff --git a/VPhoneExecutable/VPhoneVirtualization/VPhoneVirtualization.xcodeproj/project.pbxproj b/VPhoneExecutable/VPhoneVirtualization/VPhoneVirtualization.xcodeproj/project.pbxprojindex 8c477c33..dbed8f56 100644--- a/VPhoneExecutable/VPhoneVirtualization/VPhoneVirtualization.xcodeproj/project.pbxproj+++ b/VPhoneExecutable/VPhoneVirtualization/VPhoneVirtualization.xcodeproj/project.pbxproj@@ -11,10 +11,10 @@DD0000000000000000000102 /* Dynamic in Frameworks */ = {isa = PBXBuildFile; productRef = DD0000000000000000000202 /* Dynamic */; };DD0000000000000000000103 /* NIOCore in Frameworks */ = {isa = PBXBuildFile; productRef = DD0000000000000000000203 /* NIOCore */; };DD0000000000000000000104 /* NIOPosix in Frameworks */ = {isa = PBXBuildFile; productRef = DD0000000000000000000204 /* NIOPosix */; };- DD0000000000000000000107 /* NIOHTTP1 in Frameworks */ = {isa = PBXBuildFile; productRef = DD0000000000000000000205 /* NIOHTTP1 */; };- DD0000000000000000000108 /* NIOWebSocket in Frameworks */ = {isa = PBXBuildFile; productRef = DD0000000000000000000206 /* NIOWebSocket */; };DD0000000000000000000105 /* libVPhoneVirtualMachineKit.a in Frameworks */ = {isa = PBXBuildFile; fileRef = DD0000000000000000000032 /* libVPhoneVirtualMachineKit.a */; };DD0000000000000000000106 /* ArgumentParser in Frameworks */ = {isa = PBXBuildFile; productRef = DD0000000000000000000201 /* ArgumentParser */; };+ DD0000000000000000000107 /* NIOHTTP1 in Frameworks */ = {isa = PBXBuildFile; productRef = DD0000000000000000000205 /* NIOHTTP1 */; };+ DD0000000000000000000108 /* NIOWebSocket in Frameworks */ = {isa = PBXBuildFile; productRef = DD0000000000000000000206 /* NIOWebSocket */; };/* End PBXBuildFile section *//* Begin PBXContainerItemProxy section */diff --git a/VPhoneKit/VPhoneArchiveKit/Transfer/VPhoneOTAArchive.swift b/VPhoneKit/VPhoneArchiveKit/Transfer/VPhoneOTAArchive.swiftindex 596ff59c..697d8ae2 100644--- a/VPhoneKit/VPhoneArchiveKit/Transfer/VPhoneOTAArchive.swift+++ b/VPhoneKit/VPhoneArchiveKit/Transfer/VPhoneOTAArchive.swift@@ -33,6 +33,7 @@ public enum VPhoneOTAArchive {case missingMember(String, URL)case wrongDevice(URL, productTypes: [String], expected: String)case wrongBuild(URL, build: String, expected: String)+ case unsupportedVersion(URL, productType: String, version: String)case inconsistentChunks(URL, String)case unexpectedSize(URL, expected: Int64, actual: Int64)case existingUserland(URL)@@ -60,6 +61,8 @@ public enum VPhoneOTAArchive {"\(file.lastPathComponent) is for \(productTypes.isEmpty ? "no listed device" : productTypes.joined(separator: ", ")), not \(expected). Choose the \(expected) OTA."case let .wrongBuild(file, build, expected):"\(file.lastPathComponent) is build \(build), but the IPSW is \(expected). The OTA and the IPSW must be the same build."+ case let .unsupportedVersion(file, productType, version):+ "\(file.lastPathComponent) contains tvOS \(version) for \(productType). Apple TV 4K (4th generation) requires tvOS 27.2."case let .inconsistentChunks(file, reason):"\(file.lastPathComponent) has an inconsistent payload: \(reason). Download the OTA again."case let .unexpectedSize(file, expected, actual):@@ -761,6 +764,11 @@ public enum VPhoneOTAArchive {guard types.contains(device.productType) else {throw Error.wrongDevice(ota, productTypes: types, expected: device.productType)}+ // Check the archive's manifest, including renamed local sources.+ // The new board is admitted only for the 27.2 userland.+ if device == .appleTV18_1, version != "27.2", version != "27.2.0" {+ throw Error.unsupportedVersion(ota, productType: device.productType, version: version)+ }if let expected, build != expected { throw Error.wrongBuild(ota, build: build, expected: expected) }return (version, build)}diff --git a/VPhoneKit/VPhoneArchiveKitTests/OTAArchiveTests.swift b/VPhoneKit/VPhoneArchiveKitTests/OTAArchiveTests.swiftindex e2996a11..b1d80d11 100644--- a/VPhoneKit/VPhoneArchiveKitTests/OTAArchiveTests.swift+++ b/VPhoneKit/VPhoneArchiveKitTests/OTAArchiveTests.swift@@ -105,9 +105,9 @@ struct OTAArchiveTests {try stream.close()}- private func manifest(productTypes: [String] = ["AppleTV14,1"], build: String = "23L773") throws -> Data {+ private func manifest(productTypes: [String] = ["AppleTV14,1"], build: String = "23L773", version: String = "26.6") throws -> Data {try PropertyListSerialization.data(fromPropertyList: [- "ProductVersion": "26.6",+ "ProductVersion": version,"ProductBuildVersion": build,"SupportedProductTypes": productTypes,], format: .xml, options: 0)@@ -415,6 +415,60 @@ struct OTAArchiveTests {try VPhoneOTAArchive.validatePayloadPaths([a])}+ @Test func `the fourth generation stages J265 from its encrypted 27 point 2 OTA`() throws {+ let root = try makeRoot()+ defer { try? FileManager.default.removeItem(at: root) }+ try FileManager.default.createDirectory(at: root.appendingPathComponent("flash"), withIntermediateDirectories: true)+ let data = try manifest(productTypes: ["AppleTV18,1"], build: "24K120", version: "27.2")+ let entries: [Entry] = [+ .segment("E", [+ .file("AssetData/boot/BuildManifest.plist", data),+ .file("AssetData/boot/Firmware/all_flash/DeviceTree.j265ap.im4p", Data("J265".utf8)),+ .file("AssetData/payloadv2/payload.000", chunk(0)),+ .file("AssetData/payloadv2/payload_chunks.txt", Data("0: 1000\n".utf8)),+ ]),+ ]+ let ota = try makeOTA(in: root, entries)+ let identity = try VPhoneOTAArchive.checkIdentity(of: ota, key: keyText, device: .appleTV18_1, build: "24K120")+ #expect(identity.version == "27.2" && identity.build == "24K120")+ let staged = try VPhoneOTAArchive.stageUserland(+ from: ota, key: keyText, device: .appleTV18_1, build: "24K120",+ deviceTreeDirectory: root.appendingPathComponent("flash"),+ userlandDirectory: root.appendingPathComponent("userland")+ )+ #expect(staged.chunks == ["payload.000"])+ #expect(staged.deviceTree.lastPathComponent == "DeviceTree.j265ap.im4p")+ #expect(try Data(contentsOf: staged.deviceTree) == Data("J265".utf8))+ #expect(throws: VPhoneOTAArchive.Error.self) {+ try VPhoneOTAArchive.checkIdentity(of: ota, key: keyText, device: .appleTV14_1)+ }+ }++ @Test(arguments: ["26.6", "27.0", "27.1", "27.2.1", "27.3", "28.2"])+ func `the fourth generation refuses other userland versions before staging`(version: String) throws {+ let root = try makeRoot()+ defer { try? FileManager.default.removeItem(at: root) }+ let data = try manifest(productTypes: ["AppleTV18,1"], build: "24K120", version: version)+ let ota = try makeOTA(in: root, otaEntries(manifest: data))+ #expect {+ try VPhoneOTAArchive.checkIdentity(of: ota, key: keyText, device: .appleTV18_1)+ } throws: { error in+ guard case let .unsupportedVersion(_, productType, actual)? = error as? VPhoneOTAArchive.Error else { return false }+ return productType == "AppleTV18,1" && actual == version+ }+ let userland = root.appendingPathComponent("userland")+ #expect {+ try VPhoneOTAArchive.stageUserland(+ from: ota, key: keyText, device: .appleTV18_1, build: "24K120",+ deviceTreeDirectory: root.appendingPathComponent("flash"), userlandDirectory: userland+ )+ } throws: { error in+ guard case let .unsupportedVersion(_, productType, actual)? = error as? VPhoneOTAArchive.Error else { return false }+ return productType == "AppleTV18,1" && actual == version+ }+ #expect(!FileManager.default.fileExists(atPath: userland.path))+ }+@Test func `an encrypted OTA stages its device tree, payload chunks and chunk list`() throws {let root = try makeRoot()defer { try? FileManager.default.removeItem(at: root) }diff --git a/VPhoneKit/VPhoneCoreKit/Firmware/VPhoneFirmwareCatalog.swift b/VPhoneKit/VPhoneCoreKit/Firmware/VPhoneFirmwareCatalog.swiftindex db0ab0ad..9894f9bc 100644--- a/VPhoneKit/VPhoneCoreKit/Firmware/VPhoneFirmwareCatalog.swift+++ b/VPhoneKit/VPhoneCoreKit/Firmware/VPhoneFirmwareCatalog.swift@@ -60,7 +60,7 @@ public struct VPhoneOTARelease: Sendable, Equatable {public let url: String/// The `.aea` file's length, which a cached copy must have.public let size: Int64- /// The AEA archive's symmetric key, base64, as AppleDB records it; nil+ /// The AEA archive's symmetric key, base64, from AppleDB or Pallas; nil/// for an unencrypted ZIP OTA.public let key: String?/// The version of the base device's IPSW the OTA is restored over. The@@ -547,7 +547,7 @@ public enum VPhoneFirmwareCatalog {/// Full OTAs of devices without an IPSW, oldest first. Each has a/// `tvReleases` entry of its `baseVersion` for its `restoreBase`. The keys- /// are AppleDB's.+ /// are from AppleDB or the device's Pallas response.public static let otaReleases: [VPhoneOTARelease] = [.init(productType: "AppleTV14,1",@@ -569,6 +569,19 @@ public enum VPhoneFirmwareCatalog {baseVersion: "26.6",minimumHostMacOS: 27,),+ // Pallas SoftwareUpdate response, 2026-10-23: J265AP's only release+ // is the 27.2 beta. The 24K6120 asset alias points to this same archive;+ // use its restore build, 24K120, as with HomePod 27.2.+ .init(+ productType: "AppleTV18,1",+ version: "27.2",+ build: "24K120",+ url: "https://updates.cdn-apple.com/2026FallFCS/a0d11961-e437-45c7-8252-2d62f7e057b6/com_apple_MobileAsset_SoftwareUpdate/c6553d1b2d6e080adcd92fd8281e36a47dc870e22fb9d0ac057b4489916bcd9c.aea",+ size: 5_234_491_392,+ key: "B/S/c74WZgPJLoJc7BDr+IxDjtQZ2H8gUwWp7kq9RpI=",+ baseVersion: "26.6",+ minimumHostMacOS: 27,+ ),// HomePod's newer software ships as a full ZIP OTA. Keep its own// 27.0 restore IPSW as the base; the OTA supplies only the userland// and board tree, while the boot chain remains cloudOS 26.4.diff --git a/VPhoneKit/VPhoneCoreKit/VirtualMachine/VPhoneGuestDevice.swift b/VPhoneKit/VPhoneCoreKit/VirtualMachine/VPhoneGuestDevice.swiftindex 1ded1477..36781af0 100644--- a/VPhoneKit/VPhoneCoreKit/VirtualMachine/VPhoneGuestDevice.swift+++ b/VPhoneKit/VPhoneCoreKit/VirtualMachine/VPhoneGuestDevice.swift@@ -211,6 +211,17 @@ public struct VPhoneGuestDevice: Sendable, Equatable {screen: .init(width: 3840, height: 2160, pixelsPerInch: 144, scale: 2.0),)+ /// Apple TV 4K (4th generation), J265AP. Its tvOS 27.2 userland and+ /// device tree come from a full OTA over the Apple TV HD restore base.+ /// The virtual display uses the same 4K canvas as the 3rd generation.+ public static let appleTV18_1 = VPhoneGuestDevice(+ family: .appleTV,+ productType: "AppleTV18,1",+ deviceClass: "j265ap",+ productName: "Apple TV 4K (4th generation)",+ screen: .init(width: 3840, height: 2160, pixelsPerInch: 144, scale: 2.0),+ )+/// HomePod mini (B520AP). It has no physical display; this small virtual/// canvas satisfies the VM graphics configuration and is not a panel/// specification or a promise of a graphical HomePod interface.@@ -247,7 +258,7 @@ public struct VPhoneGuestDevice: Sendable, Equatable {/// device tree and userland `fw prepare` takes from its OTA. Nil for every/// device restored from its own IPSW.public var restoreBase: VPhoneGuestDevice? {- self == .appleTV14_1 ? .appleTV5_3 : nil+ self == .appleTV14_1 || self == .appleTV18_1 ? .appleTV5_3 : nil}public static let known: [VPhoneGuestDevice] = [@@ -261,7 +272,7 @@ public struct VPhoneGuestDevice: Sendable, Equatable {iPad15_3, iPad15_5,iPad16_3, iPad16_5,iPad17_1, iPad17_3,- appleTV5_3, appleTV14_1,+ appleTV5_3, appleTV14_1, appleTV18_1,audioAccessory5_1,watch7_18,]diff --git a/VPhoneKit/VPhoneCoreKitTests/Firmware/FirmwareCatalogReportTests.swift b/VPhoneKit/VPhoneCoreKitTests/Firmware/FirmwareCatalogReportTests.swiftindex b9623d5d..23439246 100644--- a/VPhoneKit/VPhoneCoreKitTests/Firmware/FirmwareCatalogReportTests.swift+++ b/VPhoneKit/VPhoneCoreKitTests/Firmware/FirmwareCatalogReportTests.swift@@ -49,7 +49,7 @@ struct FirmwareCatalogReportTests {}@Test func `lists every curated guest`() {- let report = VPhoneFirmwareCatalog.report+ let report = VPhoneFirmwareCatalog.report(hostMacOS: 27)#expect(report.devices.map(\.productType) == VPhoneGuestDevice.known.map(\.productType))#expect(report.devices.first?.pairings == report.pairings)for device in report.devices.dropFirst() {@@ -93,6 +93,29 @@ struct FirmwareCatalogReportTests {}}+ @Test func `the fourth generation Apple TV offers only its 27 point 2 OTA over the HD base`() throws {+ let release = try #require(VPhoneFirmwareCatalog.otaRelease(for: "AppleTV18,1", build: "24K120"))+ #expect(release.version == "27.2" && release.baseVersion == "26.6")+ #expect(release.size == 5_234_491_392)+ #expect(release.key == "B/S/c74WZgPJLoJc7BDr+IxDjtQZ2H8gUwWp7kq9RpI=")+ #expect(release.url.hasSuffix("/c6553d1b2d6e080adcd92fd8281e36a47dc870e22fb9d0ac057b4489916bcd9c.aea"))+ #expect(release.fileName == "AppleTV18,1_27.2_24K120_OTA.aea")+ #expect(VPhoneFirmwareCatalog.otaRelease(source: "/cache/ota/\(release.fileName)") == release)+ let pairings = VPhoneFirmwareCatalog.pairings(for: "AppleTV18,1", hostMacOS: 27)+ #expect(pairings.map(\.iosName) == ["tvOS 27.2"])+ #expect(pairings.first?.iosURL == release.url)+ #expect(pairings.first?.cloudosURL == VPhoneFirmwareCatalog.cloud264)+ let base = try #require(VPhoneFirmwareCatalog.restoreBaseURL(for: release))+ #expect(base.hasSuffix("/AppleTV5,3_26.6_23L773_Restore.ipsw"))+ let device = try #require(VPhoneFirmwareCatalog.report(hostMacOS: 27).devices.first { $0.productType == "AppleTV18,1" })+ #expect(device.family == "appleTV" && device.name == "Apple TV 4K (4th generation)")+ #expect(device.pairings.count == 1 && device.pairings[0].ios.build == "24K120")+ #expect(device.pairings[0].ios.files == ["ota/\(release.fileName)", (base as NSString).lastPathComponent])+ #expect(VPhoneFirmwareCatalog.pairings(for: "AppleTV18,1", hostMacOS: 26).isEmpty)+ #expect(!VPhoneFirmwareCatalog.report(hostMacOS: 26).devices.contains { $0.productType == "AppleTV18,1" })+ #expect(VPhoneFirmwareCatalog.otaRelease(for: "AppleTV18,1", build: "24J361") == nil)+ }+@Test func `Apple TV pairings are tvOS releases on cloudOS 26.4`() throws {let pairings = VPhoneFirmwareCatalog.pairings(for: "AppleTV5,3")#expect(pairings.map(\.iosName) == ["tvOS 26.6"])diff --git a/VPhoneKit/VPhoneCoreKitTests/Restore/RestoreInfoTests.swift b/VPhoneKit/VPhoneCoreKitTests/Restore/RestoreInfoTests.swiftindex 4dd82cd5..1ee5fbff 100644--- a/VPhoneKit/VPhoneCoreKitTests/Restore/RestoreInfoTests.swift+++ b/VPhoneKit/VPhoneCoreKitTests/Restore/RestoreInfoTests.swift@@ -148,18 +148,22 @@ struct RestoreInfoTests {#expect(try VPhoneRestoreInfo.recordVariant("jb", toBundle: b) == nil)}- @Test func `installed HomePod userland preserves cloudOS and later variant recording`() throws {- let b = try makeBundle(guestProductType: "AudioAccessory5,1")+ @Test(arguments: ["AudioAccessory5,1", "AppleTV14,1", "AppleTV18,1"])+ func `installed OTA userland preserves cloudOS and later variant recording`(productType: String) throws {+ let homePod = productType.hasPrefix("AudioAccessory")+ let baseVersion = homePod ? "27.0" : "26.6"+ let baseBuild = homePod ? "24J361" : "23L773"+ let b = try makeBundle(guestProductType: productType)defer { try? FileManager.default.removeItem(at: b.url) }let cloud = VPhoneRestoreInfo.OSVersion(version: "26.4", build: "23E5207q")- try VPhoneRestoreInfo(ios: .init(version: "27.0", build: "24J361"), cloudOS: cloud).write(toBundle: b)+ try VPhoneRestoreInfo(ios: .init(version: baseVersion, build: baseBuild), cloudOS: cloud).write(toBundle: b)// Preparation and base restore alone never promote the userland.- #expect(try VPhoneRestoreInfo.recordVariant("jb", toBundle: b)?.ios.version == "27.0")+ #expect(try VPhoneRestoreInfo.recordVariant("jb", toBundle: b)?.ios.version == baseVersion)let actual = VPhoneRestoreInfo.OSVersion(version: "27.2", build: "24K120")let installed = try VPhoneRestoreInfo.recordVariant("jb", toBundle: b, installedUserland: actual)#expect(installed?.ios == actual)#expect(installed?.cloudOS == cloud)- #expect(installed?.device == "AudioAccessory5,1")+ #expect(installed?.device == (homePod ? productType : "iPhone99,11"))// The full-install command and creator both record the variant again.let rerecorded = try VPhoneRestoreInfo.recordVariant("jb", toBundle: b)#expect(rerecorded == installed)diff --git a/VPhoneKit/VPhoneCoreKitTests/VirtualMachine/GuestDeviceTests.swift b/VPhoneKit/VPhoneCoreKitTests/VirtualMachine/GuestDeviceTests.swiftindex f772a91f..e572792f 100644--- a/VPhoneKit/VPhoneCoreKitTests/VirtualMachine/GuestDeviceTests.swift+++ b/VPhoneKit/VPhoneCoreKitTests/VirtualMachine/GuestDeviceTests.swift@@ -75,6 +75,24 @@ struct GuestDeviceTests {#expect(VPhoneGuestDevice.appleTV5_3.restoreBase == nil && VPhoneGuestDevice.iPhone17_3.restoreBase == nil)}+ @Test+ func `the fourth generation Apple TV keeps its J265 identity and 4K canvas`() throws {+ let device = try #require(VPhoneGuestDevice.named("AppleTV18,1"))+ #expect(device == .appleTV18_1 && device.family == .appleTV)+ #expect(device.productName == "Apple TV 4K (4th generation)")+ #expect(device.boardDeviceTreePath == "Firmware/all_flash/DeviceTree.j265ap.im4p")+ #expect(device.restoreBase == .appleTV5_3)+ #expect(device.usesTVOS && device.presentsBoard && !device.hasPlainArm64Userland)+ #expect(device.screen == VPhoneGuestDevice.appleTV14_1.screen)+ #expect(VPhoneGuestDevice.detect(buildManifest: ["SupportedProductTypes": ["AppleTV18,1"]]) == device)+ let manifest = VPhoneVirtualMachineManifest.newVM().updating(guestDevice: device)+ let decoded = try PropertyListDecoder().decode(+ VPhoneVirtualMachineManifest.self, from: PropertyListEncoder().encode(manifest)+ )+ #expect(decoded.guestDevice == device && decoded.screenConfig == device.screen)+ #expect(decoded.updating(cpuCount: 4).guestProductType == "AppleTV18,1")+ }+@Testfunc `a TV guest persists its identity and provisional landscape canvas`() throws {let manifest = VPhoneVirtualMachineManifest.newVM().updating(guestDevice: .appleTV5_3)diff --git a/VPhoneLaunchpad/Configuration/Version.xcconfig b/VPhoneLaunchpad/Configuration/Version.xcconfigindex 1add1472..ceb9d5b7 100644--- a/VPhoneLaunchpad/Configuration/Version.xcconfig+++ b/VPhoneLaunchpad/Configuration/Version.xcconfig@@ -1,4 +1,4 @@-MARKETING_VERSION = 2.12.0+MARKETING_VERSION = 2.13.0// Bump whenever the helper changes. The app blesses the helper again when the// installed helper's version or bytes differ from the copy it embeds.-CURRENT_PROJECT_VERSION = 20+CURRENT_PROJECT_VERSION = 21diff --git a/VPhoneLaunchpad/Tests/BundleNamesTests.swift b/VPhoneLaunchpad/Tests/BundleNamesTests.swiftindex cedcb65b..66e19d37 100644--- a/VPhoneLaunchpad/Tests/BundleNamesTests.swift+++ b/VPhoneLaunchpad/Tests/BundleNamesTests.swift@@ -17,15 +17,15 @@ struct BundleNamesTests {// `-local` (legacy), `-local.<8+ lowercase hex>` or `-ci.<7+ hex>`.// Anything else is kept whole, so it never parses as a version.let expectations: [Expectation] = [- Expectation(name: "2.12.0", bundleVersion: "2.12.0", isLocalBuild: false, isCompatible: true, isValid: true),- Expectation(name: "2.12.0-local", bundleVersion: "2.12.0", isLocalBuild: true, isCompatible: true, isValid: true),- Expectation(name: "2.12.0-local.ab12cd34", bundleVersion: "2.12.0", isLocalBuild: true, isCompatible: true, isValid: true),+ Expectation(name: "2.13.0", bundleVersion: "2.13.0", isLocalBuild: false, isCompatible: true, isValid: true),+ Expectation(name: "2.13.0-local", bundleVersion: "2.13.0", isLocalBuild: true, isCompatible: true, isValid: true),+ Expectation(name: "2.13.0-local.ab12cd34", bundleVersion: "2.13.0", isLocalBuild: true, isCompatible: true, isValid: true),// The build identifier is lowercase hex; uppercase is no build.- Expectation(name: "2.12.0-local.AB12CD34", bundleVersion: "2.12.0-local.AB12CD34", isLocalBuild: false, isCompatible: false, isValid: true),- Expectation(name: "2.12.0-local.ab12", bundleVersion: "2.12.0-local.ab12", isLocalBuild: false, isCompatible: false, isValid: true),- Expectation(name: "2.12.0-ci.abcdef1", bundleVersion: "2.12.0", isLocalBuild: false, isCompatible: true, isValid: true),- Expectation(name: "2.12.1", bundleVersion: "2.12.1", isLocalBuild: false, isCompatible: true, isValid: true),- Expectation(name: "2.11.99", bundleVersion: "2.11.99", isLocalBuild: false, isCompatible: false, isValid: true),+ Expectation(name: "2.13.0-local.AB12CD34", bundleVersion: "2.13.0-local.AB12CD34", isLocalBuild: false, isCompatible: false, isValid: true),+ Expectation(name: "2.13.0-local.ab12", bundleVersion: "2.13.0-local.ab12", isLocalBuild: false, isCompatible: false, isValid: true),+ Expectation(name: "2.13.0-ci.abcdef1", bundleVersion: "2.13.0", isLocalBuild: false, isCompatible: true, isValid: true),+ Expectation(name: "2.13.1", bundleVersion: "2.13.1", isLocalBuild: false, isCompatible: true, isValid: true),+ Expectation(name: "2.12.99", bundleVersion: "2.12.99", isLocalBuild: false, isCompatible: false, isValid: true),Expectation(name: "2.10.1", bundleVersion: "2.10.1", isLocalBuild: false, isCompatible: false, isValid: true),Expectation(name: "2.10.1-local.ab12cd34", bundleVersion: "2.10.1", isLocalBuild: true, isCompatible: false, isValid: true),Expectation(name: "2.9.5", bundleVersion: "2.9.5", isLocalBuild: false, isCompatible: false, isValid: true),diff --git a/VPhoneLaunchpad/Tests/MachineProductTypeTests.swift b/VPhoneLaunchpad/Tests/MachineProductTypeTests.swiftindex 21413e74..62a6ef70 100644--- a/VPhoneLaunchpad/Tests/MachineProductTypeTests.swift+++ b/VPhoneLaunchpad/Tests/MachineProductTypeTests.swift@@ -68,6 +68,18 @@ struct MachineProductTypeTests {let tv4K = try JSONDecoder().decode(VPhoneLaunchpadFirmwareCatalog.self, from: Data(catalog.utf8)).guests[0]expect(tv4K.pairings.map(\.build) == ["23L773", "24J361"], "OTA build from the bundle")expect(tv4K.pairings[0].ios.files == nil && tv4K.pairings[1].ios.files?.count == 2, "OTA files")++ let fourthGeneration = #"""+ {"device":"iPhone17,3","pairings":[],"devices":[{"productType":"AppleTV18,1","name":"Apple TV 4K (4th generation)","family":"appleTV","pairings":[+ {"ios":{"name":"tvOS 27.2","url":"https://example.com/J265.aea","build":"24K120","files":["ota/AppleTV18,1_27.2_24K120_OTA.aea","AppleTV5,3_26.6_23L773_Restore.ipsw"]},"recommendedCloudOS":{"name":"cloudOS 26.4","url":"https://example.com/c"}}]}]}+ """#+ let j265 = try JSONDecoder().decode(VPhoneLaunchpadFirmwareCatalog.self, from: Data(fourthGeneration.utf8)).guests[0]+ expect(j265.productType == "AppleTV18,1" && j265.isAppleTV && j265.requiresStandaloneRestore, "J265 standalone TV creation")+ expect(j265.pairings.count == 1 && j265.pairings[0].build == "24K120", "J265 only offers tvOS 27.2")+ expect(j265.pairings[0].ios.files?.first == "ota/AppleTV18,1_27.2_24K120_OTA.aea", "J265 OTA download")+ try (["guestProductType": "AppleTV18,1"] as NSDictionary).write(to: tv.appendingPathComponent("config.plist"))+ machine.guestProductType = VPhoneLaunchpadMachine.guestProductType(in: tv)+ expect(machine.guestProductType == "AppleTV18,1" && machine.isAppleTV && machine.osName == "tvOS", "J265 identity wins over HD restore tree")print("Machine product type tests passed: config, restore trees, OS name, catalog builds")}}diff --git a/VPhoneLaunchpad/VPhoneLaunchpad/Machines/VPhoneLaunchpadPatchCatalog.swift b/VPhoneLaunchpad/VPhoneLaunchpad/Machines/VPhoneLaunchpadPatchCatalog.swiftindex b401e979..8820edaa 100644--- a/VPhoneLaunchpad/VPhoneLaunchpad/Machines/VPhoneLaunchpadPatchCatalog.swift+++ b/VPhoneLaunchpad/VPhoneLaunchpad/Machines/VPhoneLaunchpadPatchCatalog.swift@@ -298,7 +298,7 @@ nonisolated struct VPhoneLaunchpadPatchSelection: Hashable, Sendable {static func defaultPreset(forDevice productType: String?) -> String {switch productType {case "AudioAccessory5,1": homePodMiniPreset- case "AppleTV14,1": tvOS4KPreset+ case "AppleTV14,1", "AppleTV18,1": tvOS4KPresetcase let type? where type.hasPrefix("AppleTV"): tvOSPresetcase let type? where type.hasPrefix("Watch"): watchOSPreset// The iOS 18 research board kernels boot no other preset.diff --git a/VPhoneLaunchpad/VPhoneLaunchpadShared/VPhoneLaunchpadBundleStore.swift b/VPhoneLaunchpad/VPhoneLaunchpadShared/VPhoneLaunchpadBundleStore.swiftindex 1a215dd8..22747a3e 100644--- a/VPhoneLaunchpad/VPhoneLaunchpadShared/VPhoneLaunchpadBundleStore.swift+++ b/VPhoneLaunchpad/VPhoneLaunchpadShared/VPhoneLaunchpadBundleStore.swift@@ -71,7 +71,8 @@ nonisolated struct VPhoneLaunchpadBundleReceipt: Codable, Equatable, Sendable {/// must not trust the app.nonisolated enum VPhoneLaunchpadNames {/// Minimum bundle version for Launchpad's CLI and receipt contract.- private static let minimumBundleComponents = (2, 12, 0)+ /// Series 2.13 adds the AppleTV18,1 OTA pairing and its 4K preset default.+ private static let minimumBundleComponents = (2, 13, 0)static let minimumBundleVersion ="\(minimumBundleComponents.0).\(minimumBundleComponents.1).\(minimumBundleComponents.2)"