NikGapps 3.95__tar.gz → 3.96__tar.gz

{nikgapps-3.95 → nikgapps-3.96}/NikGapps/helper/assets/config_versions.json

@@ -6,5 +6,6 @@
   "13": "37",
   "14": "37",
   "15": "37",
-  "16": "38"
-}
+  "16": "38",
+  "17": "39"
+}

{nikgapps-3.95 → nikgapps-3.96}/NikGapps/overlay_control.py

@@ -12,8 +12,22 @@ from niklibrary.git.Git import Git
 from NikGapps.helper.overlay.Overlay import Overlay
 
 
+ANDROID_PLATFORM_VERSIONS = {
+    # niklibrary 0.28 predates Android 17. Keep the compatibility entry here
+    # until the same mapping is available in the shared library.
+    "17": {"sdk": "37", "code": "CinnamonBun"},
+}
+
+
+def register_android_platform(android_version):
+    version = str(android_version)
+    if version not in Statics.android_versions and version in ANDROID_PLATFORM_VERSIONS:
+        Statics.android_versions[version] = ANDROID_PLATFORM_VERSIONS[version]
+
+
 def build_local_overlays(android_version, source_dir, output_dir):
     """Generate and compile overlays locally without cloning or pushing repos."""
+    register_android_platform(android_version)
     source_dir = os.path.abspath(source_dir)
     output_dir = os.path.abspath(output_dir)
     os.makedirs(source_dir, exist_ok=True)
@@ -40,6 +54,7 @@ def overlay_control():
     android_versions = args.get_android_versions()
 
     for android_version in android_versions:
+        register_android_platform(android_version)
         repo_name = Statics.get_overlay_source_repo(android_version)
         repo_dir = Statics.get_overlay_source_directory(android_version)
         branch = "main"

{nikgapps-3.95 → nikgapps-3.96/NikGapps.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NikGapps
-Version: 3.95
+Version: 3.96
 Summary: A short description of your project
 Home-page: https://github.com/nikgapps/project
 Author: Nikhil Menghani

{nikgapps-3.95/NikGapps.egg-info → nikgapps-3.96}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NikGapps
-Version: 3.95
+Version: 3.96
 Summary: A short description of your project
 Home-page: https://github.com/nikgapps/project
 Author: Nikhil Menghani

{nikgapps-3.95 → nikgapps-3.96}/nikgapps_package_pipeline/cli.py

@@ -168,6 +168,11 @@ def build_parser() -> argparse.ArgumentParser:
     upgrade.add_argument("--baseline-firmware", type=Path, required=True)
     upgrade.add_argument("--target-firmware", type=Path, required=True)
     upgrade.add_argument("--output", type=Path, required=True)
+    upgrade.add_argument("--carry-forward-missing", action="store_true",
+                         help="copy the complete template first, replace everything available from the target image, and audit retained files")
+    upgrade.add_argument("--android-version", help="build overlays for this Android version after upgrading")
+    upgrade.add_argument("--overlay-source", type=Path, help="generated overlay source workspace")
+    upgrade.add_argument("--overlay-output", type=Path, help="compiled overlay APK output")
     return parser
 
 
@@ -336,9 +341,22 @@ def main(argv: Sequence[str] | None = None) -> int:
         if args.command == "reset-registry":
             return _reset_registry(args)
         if args.command == "upgrade":
+            overlay_values = (args.android_version, args.overlay_source, args.overlay_output)
+            if any(overlay_values) and not all(overlay_values):
+                raise PipelineError("--android-version, --overlay-source, and --overlay-output must be supplied together")
+            overlays = []
+            if all(overlay_values):
+                from NikGapps.overlay_control import build_local_overlays
+                overlays = build_local_overlays(args.android_version, args.overlay_source, args.overlay_output)
             report = StableTreeUpgrader().upgrade(
-                args.template, args.baseline_firmware, args.target_firmware, args.output
+                args.template, args.baseline_firmware, args.target_firmware, args.output,
+                carry_forward_missing=args.carry_forward_missing,
             )
+            if overlays:
+                report.built_overlays = [str(Path(path).resolve().relative_to(args.overlay_output.resolve())).replace("\\", "/")
+                                         for path in overlays]
+                (args.output / "upgrade-report.json").write_text(
+                    json.dumps(report.as_dict(), indent=2) + "\n", encoding="utf-8")
             print(json.dumps(report.as_dict(), indent=2))
             return 0
         return _migrate(args)

{nikgapps-3.95 → nikgapps-3.96}/nikgapps_package_pipeline/pipeline.py

@@ -377,13 +377,12 @@ class MigrationPipeline:
                     "with its required support files"
                 )
             gms.dependencies = [
-                {"id": "gms_core_support_common"},
                 {
-                    "id": "gms_core_support_standard",
+                    "id": "gms_core_extra_files",
                     "when": {"appSet": "core"},
                 },
                 {
-                    "id": "gms_core_support_go",
+                    "id": "gms_core_extra_files_go",
                     "when": {"appSet": "core_go"},
                 },
             ]
@@ -433,40 +432,28 @@ class MigrationPipeline:
         normal_source = sources["Core/ExtraFiles"]
         go_source = sources["CoreGo/ExtraFilesGo"]
         scanner = LegacyRepositoryScanner()
-        normal = {item.path: item for item in scanner.payload(normal_source)}
-        go = {item.path: item for item in scanner.payload(go_source)}
-        common_paths = {
-            path for path in normal.keys() & go.keys()
-            if normal[path].sha256 == go[path].sha256
-        }
         groups = [
             (
-                "gms_core_support_common",
-                "GmsCore common support files",
-                [normal[path] for path in sorted(common_paths)],
-                ["Core/ExtraFiles", "CoreGo/ExtraFilesGo"],
-                ["Core", "CoreGo"],
-            ),
-            (
-                "gms_core_support_standard",
-                "GmsCore standard support files",
-                [normal[path] for path in sorted(normal.keys() - common_paths)],
+                "gms_core_extra_files",
+                "ExtraFiles",
+                scanner.payload(normal_source),
                 ["Core/ExtraFiles"],
                 ["Core"],
+                normal_source,
             ),
             (
-                "gms_core_support_go",
-                "GmsCore Go support files",
-                [go[path] for path in sorted(go.keys() - common_paths)],
+                "gms_core_extra_files_go",
+                "ExtraFilesGo",
+                scanner.payload(go_source),
                 ["CoreGo/ExtraFilesGo"],
                 ["CoreGo"],
+                go_source,
             ),
         ]
         result: list[BuiltPackage] = []
-        for package_id, name, files, source_names, appset_names in groups:
+        for package_id, name, files, source_names, appset_names, support_source in groups:
             if not files:
                 continue
-            support_source = normal_source if "go" not in package_id else go_source
             payload_digest = content_digest((item.path, item.sha256) for item in files)
             manifest = _manifest(package_id, support_source, files, None, None, [],
                                  payload_digest, config)
@@ -588,32 +575,29 @@ class MigrationPipeline:
                 }
             except (OSError, json.JSONDecodeError) as exc:
                 raise PipelineError(f"Cannot merge existing AppSets {appsets_path}: {exc}") from exc
-        generated_appsets = [
-            {
+        generated_appsets = []
+        for name, package_ids in sorted(appsets.items()):
+            selected = list(dict.fromkeys(package_ids))
+            resolved = MigrationPipeline._resolved_packages(name, selected, packages)
+            legacy_names = {}
+            for package_id in resolved:
+                legacy_names[package_id] = next(
+                    (
+                        membership.split("/", 1)[1]
+                        for package in packages
+                        if package.package_id == package_id
+                        for membership in package.source_names
+                        if membership.split("/", 1)[0] == name
+                    ),
+                    package_id,
+                )
+            generated_appsets.append({
                 "id": stable_id(name),
                 "name": name,
-                "packages": list(dict.fromkeys(package_ids)),
-                "resolvedPackages": MigrationPipeline._resolved_packages(
-                    name,
-                    list(dict.fromkeys(package_ids)),
-                    packages,
-                ),
-                "legacyPackageNames": {
-                    package_id: next(
-                        (
-                            membership.split("/", 1)[1]
-                            for package in packages
-                            if package.package_id == package_id
-                            for membership in package.source_names
-                            if membership.split("/", 1)[0] == name
-                        ),
-                        package_id,
-                    )
-                    for package_id in dict.fromkeys(package_ids)
-                },
-            }
-            for name, package_ids in sorted(appsets.items())
-        ]
+                "packages": selected,
+                "resolvedPackages": resolved,
+                "legacyPackageNames": legacy_names,
+            })
         existing_appsets.update({item["id"]: item for item in generated_appsets})
         appsets_path.write_bytes(json_data({
             "schemaVersion": 1,

{nikgapps-3.95 → nikgapps-3.96}/nikgapps_package_pipeline/upgrade.py

@@ -9,11 +9,24 @@ from typing import Any
 from .errors import PipelineError
 
 
+def _is_profile(path: Path) -> bool:
+    return path.suffix.casefold() == ".prof"
+
+
+def _ignore_profiles(_directory: str, names: list[str]) -> set[str]:
+    return {name for name in names if Path(name).suffix.casefold() == ".prof"}
+
+
 @dataclass
 class UpgradeReport:
     upgraded_packages: list[str] = field(default_factory=list)
     file_only_packages: list[str] = field(default_factory=list)
     unavailable_packages: list[str] = field(default_factory=list)
+    carried_forward_packages: list[str] = field(default_factory=list)
+    updated_dependencies: list[str] = field(default_factory=list)
+    carried_forward_files: list[str] = field(default_factory=list)
+    ambiguous_dependencies: list[str] = field(default_factory=list)
+    built_overlays: list[str] = field(default_factory=list)
     copied_files: int = 0
 
     def as_dict(self) -> dict[str, Any]:
@@ -22,6 +35,11 @@ class UpgradeReport:
             "upgradedPackages": sorted(self.upgraded_packages),
             "fileOnlyPackages": sorted(self.file_only_packages),
             "unavailablePackages": sorted(self.unavailable_packages),
+            "carriedForwardPackages": sorted(self.carried_forward_packages),
+            "updatedDependencies": sorted(self.updated_dependencies),
+            "carriedForwardFiles": sorted(self.carried_forward_files),
+            "ambiguousDependencies": sorted(self.ambiguous_dependencies),
+            "builtOverlays": sorted(self.built_overlays),
             "copiedFiles": self.copied_files,
         }
 
@@ -95,7 +113,8 @@ def _copy_firmware_directory(
     source_directory = source_apk.parent
     count = 0
     for source in sorted(source_directory.rglob("*")):
-        if not source.is_file() or any(part.endswith("_extracted") for part in source.parts):
+        if (not source.is_file() or _is_profile(source)
+                or any(part.endswith("_extracted") for part in source.parts)):
             continue
         source_location = Path(location).parent / source.relative_to(source_directory)
         destination = package_output / encode_builder_path(source_location.as_posix())
@@ -114,6 +133,8 @@ class StableTreeUpgrader:
         baseline_firmware: Path,
         target_firmware: Path,
         output: Path,
+        *,
+        carry_forward_missing: bool = False,
     ) -> UpgradeReport:
         template_root = template_root.resolve()
         baseline_firmware = baseline_firmware.resolve()
@@ -128,6 +149,18 @@ class StableTreeUpgrader:
 
         baseline = _load_inventory(baseline_firmware)
         target = _load_inventory(target_firmware)
+        target_files: dict[str, list[Path]] = {}
+        for candidate in sorted(target_firmware.rglob("*")):
+            if not candidate.is_file() or candidate.name in {"mustang.json", "all_files.txt"}:
+                continue
+            if any(part.endswith("_extracted") or part == ".git" for part in candidate.parts):
+                continue
+            relative = candidate.relative_to(target_firmware).as_posix()
+            try:
+                builder_path = encode_builder_path(relative).as_posix()
+            except PipelineError:
+                continue
+            target_files.setdefault(builder_path, []).append(candidate)
         report = UpgradeReport()
         output.mkdir(parents=True)
         for metadata_name in (".gitattributes", "README.md"):
@@ -141,10 +174,18 @@ class StableTreeUpgrader:
                 destination = output / appset.name / package.name
                 # Preserve the complete AppSet/package skeleton even when a
                 # package is not shipped by the target firmware image.
-                destination.mkdir(parents=True, exist_ok=True)
+                if carry_forward_missing:
+                    shutil.copytree(package, destination, ignore=_ignore_profiles)
+                else:
+                    destination.mkdir(parents=True, exist_ok=True)
                 template_apks = sorted(package.rglob("*.apk"))
+                template_dependencies = sorted(
+                    path for path in package.rglob("*")
+                    if path.is_file() and path.suffix.casefold() not in {".apk", ".prof"}
+                )
                 copied = 0
                 seen_targets: set[str] = set()
+                replaced_apk_parents: set[Path] = set()
                 for template_apk in template_apks:
                     match = _record_for_template(template_apk, package, baseline)
                     if not match:
@@ -157,36 +198,48 @@ class StableTreeUpgrader:
                     if location in seen_targets:
                         continue
                     seen_targets.add(location)
+                    if carry_forward_missing:
+                        old_parent = destination / template_apk.parent.relative_to(package)
+                        if old_parent not in replaced_apk_parents:
+                            shutil.rmtree(old_parent)
+                            replaced_apk_parents.add(old_parent)
                     copied += _copy_firmware_directory(target_firmware, target_record, destination)
 
+                dependency_copied = 0
+                for template_file in template_dependencies:
+                    relative = template_file.relative_to(package)
+                    builder_path = relative.as_posix()
+                    matches = target_files.get(builder_path, [])
+                    audit_path = f"{membership}/{builder_path}"
+                    if len(matches) == 1:
+                        destination_file = destination / relative
+                        destination_file.parent.mkdir(parents=True, exist_ok=True)
+                        shutil.copy2(matches[0], destination_file)
+                        dependency_copied += 1
+                        report.copied_files += 1
+                        report.updated_dependencies.append(audit_path)
+                    elif len(matches) > 1:
+                        report.ambiguous_dependencies.append(audit_path)
+                        if carry_forward_missing and destination.joinpath(relative).is_file():
+                            report.carried_forward_files.append(audit_path)
+                    elif carry_forward_missing and destination.joinpath(relative).is_file():
+                        report.carried_forward_files.append(audit_path)
+
                 if copied:
                     report.upgraded_packages.append(membership)
                     report.copied_files += copied
+                    if carry_forward_missing and any(
+                        destination.joinpath(apk.relative_to(package)).is_file() for apk in template_apks
+                    ):
+                        report.carried_forward_packages.append(membership)
                     continue
 
-                # File-only packages are retained only when the same path is
-                # present in Android 17. Nothing is ever copied from Android 16.
-                file_only_copied = 0
-                for template_file in sorted(package.rglob("*")):
-                    if not template_file.is_file() or template_file.suffix == ".apk":
-                        continue
-                    suffix = decode_builder_path(template_file.relative_to(package))
-                    matches = [
-                        candidate for candidate in target_firmware.rglob(template_file.name)
-                        if candidate.is_file()
-                        and candidate.as_posix().endswith("/" + suffix)
-                        and "_extracted" not in candidate.as_posix()
-                    ]
-                    if len(matches) == 1:
-                        destination_file = destination / template_file.relative_to(package)
-                        destination_file.parent.mkdir(parents=True, exist_ok=True)
-                        shutil.copy2(matches[0], destination_file)
-                        report.copied_files += 1
-                        file_only_copied += 1
-                if file_only_copied:
+                if dependency_copied:
                     report.file_only_packages.append(membership)
                 else:
                     report.unavailable_packages.append(membership)
+                if carry_forward_missing and any(destination.rglob("*")):
+                    report.carried_forward_packages.append(membership)
 
         (output / "upgrade-report.json").write_text(
             json.dumps(report.as_dict(), indent=2) + "\n", encoding="utf-8"

{nikgapps-3.95 → nikgapps-3.96}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="NikGapps",
-    version="3.95",
+    version="3.96",
     packages=find_packages(),
     include_package_data=True,
     package_data={

{nikgapps-3.95 → nikgapps-3.96}/tests_package_pipeline/test_consumer.py

@@ -57,21 +57,17 @@ class ConsumerTests(unittest.TestCase):
                 "gms_core": artifact(
                     root, "gms", "priv-app/Gms/Gms.apk", b"apk"
                 ),
-                "gms_core_support_common": artifact(
-                    root, "common", "etc/permissions/common.xml", b"common"
+                "gms_core_extra_files": artifact(
+                    root, "extra", "etc/permissions/common.xml", b"common"
                 ),
-                "gms_core_support_standard": artifact(
-                    root, "standard", "etc/sysconfig/variant.xml", b"standard"
-                ),
-                "gms_core_support_go": artifact(
+                "gms_core_extra_files_go": artifact(
                     root, "go", "etc/sysconfig/go.xml", b"go"
                 ),
             }
             memberships = {
                 "gms_core": ["Core/GmsCore", "CoreGo/GmsCore"],
-                "gms_core_support_common": ["Core/ExtraFiles", "CoreGo/ExtraFilesGo"],
-                "gms_core_support_standard": ["Core/ExtraFiles"],
-                "gms_core_support_go": ["CoreGo/ExtraFilesGo"],
+                "gms_core_extra_files": ["Core/ExtraFiles"],
+                "gms_core_extra_files_go": ["CoreGo/ExtraFilesGo"],
             }
             packages = []
             for package_id, artifact_data in artifacts.items():
@@ -83,7 +79,7 @@ class ConsumerTests(unittest.TestCase):
                     "versions": {
                         key: {
                             "android": {"minApi": 29, "maxApi": None},
-                            "architectures": [] if "support" in package_id else ["arm64-v8a"],
+                            "architectures": [] if "extra_files" in package_id else ["arm64-v8a"],
                             "artifact": artifact_data,
                         }
                     },
@@ -98,10 +94,12 @@ class ConsumerTests(unittest.TestCase):
                     "packages": ["gms_core"],
                     "resolvedPackages": [
                         "gms_core",
-                        "gms_core_support_common",
-                        "gms_core_support_standard",
+                        "gms_core_extra_files",
                     ],
-                    "legacyPackageNames": {"gms_core": "GmsCore"},
+                    "legacyPackageNames": {
+                        "gms_core": "GmsCore",
+                        "gms_core_extra_files": "ExtraFiles",
+                    },
                 }]
             }), encoding="utf-8")
             requested = [SimpleNamespace(
@@ -120,9 +118,6 @@ class ConsumerTests(unittest.TestCase):
             self.assertTrue(
                 (source / "Core" / "ExtraFiles" / "___etc___permissions" / "common.xml").is_file()
             )
-            self.assertTrue(
-                (source / "Core" / "ExtraFiles" / "___etc___sysconfig" / "variant.xml").is_file()
-            )
             self.assertFalse((source / "CoreGo").exists())
 
     def test_checksum_mismatch_is_rejected(self) -> None:

{nikgapps-3.95 → nikgapps-3.96}/tests_package_pipeline/test_overlay_control.py

@@ -10,7 +10,8 @@ sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "niklibrary"))
 sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "nikassets"))
 
 try:
-    from NikGapps.overlay_control import build_local_overlays
+    from NikGapps.overlay_control import build_local_overlays, register_android_platform
+    from niklibrary.helper.Statics import Statics
 except ModuleNotFoundError:
     build_local_overlays = None
 
@@ -26,6 +27,17 @@ class FakeOverlay:
 
 @unittest.skipIf(build_local_overlays is None, "optional NikGapps build dependencies unavailable")
 class OverlayControlTests(unittest.TestCase):
+    def test_android_17_platform_compatibility(self) -> None:
+        original = Statics.android_versions.pop("17", None)
+        try:
+            register_android_platform("17")
+            self.assertEqual(Statics.get_android_sdk("17"), "37")
+            self.assertEqual(Statics.get_android_code("17"), "CinnamonBun")
+        finally:
+            Statics.android_versions.pop("17", None)
+            if original is not None:
+                Statics.android_versions["17"] = original
+
     def test_android_17_local_overlay_output(self) -> None:
         with tempfile.TemporaryDirectory() as temporary:
             root = Path(temporary)

{nikgapps-3.95 → nikgapps-3.96}/tests_package_pipeline/test_pipeline.py

@@ -293,9 +293,8 @@ class MigrationTests(unittest.TestCase):
                     "example",
                     "shared",
                     "gms_core",
-                    "gms_core_support_common",
-                    "gms_core_support_standard",
-                    "gms_core_support_go",
+                    "gms_core_extra_files",
+                    "gms_core_extra_files_go",
                 },
             )
             shared = next(item for item in packages if item.package_id == "shared")
@@ -306,10 +305,16 @@ class MigrationTests(unittest.TestCase):
             )
             support = next(
                 item for item in packages
-                if item.package_id == "gms_core_support_common"
+                if item.package_id == "gms_core_extra_files"
             )
             self.assertIsNone(support.primary_apk)
             self.assertTrue(support.internal)
+            with zipfile.ZipFile(support.artifact_path) as support_archive:
+                support_installer = support_archive.read("installer.sh").decode()
+                support_uninstaller = support_archive.read("uninstaller.sh").decode()
+                self.assertIn("com.google.android.maps.xml", support_installer)
+                self.assertIn("uninstall_package() {", support_uninstaller)
+                self.assertIn("___etc___permissions/common.xml", support_uninstaller)
             self.assertRegex(
                 support.version_key,
                 r"^content-[0-9a-f]{12}-arm64-v8a$",
@@ -344,9 +349,9 @@ class MigrationTests(unittest.TestCase):
             appsets = json.loads((output / "metadata" / "appsets.json").read_text())
             core_go = next(item for item in appsets["appSets"] if item["name"] == "CoreGo")
             self.assertEqual(core_go["packages"], ["gms_core", "shared"])
-            self.assertIn("gms_core_support_common", core_go["resolvedPackages"])
-            self.assertIn("gms_core_support_go", core_go["resolvedPackages"])
-            self.assertNotIn("gms_core_support_standard", core_go["resolvedPackages"])
+            self.assertIn("gms_core_extra_files_go", core_go["resolvedPackages"])
+            self.assertNotIn("gms_core_extra_files", core_go["resolvedPackages"])
+            self.assertEqual(core_go["legacyPackageNames"]["gms_core_extra_files_go"], "ExtraFilesGo")
             compatible = Path(temporary) / "compatible"
             LegacyCompatibilityExporter().export(packages, compatible)
             self.assertTrue(

{nikgapps-3.95 → nikgapps-3.96}/tests_package_pipeline/test_upgrade.py

@@ -43,7 +43,7 @@ class StableTreeUpgradeTests(unittest.TestCase):
 
             upgraded = output / "Set" / "App" / "___priv-app___AppNew_17"
             self.assertEqual((upgraded / "AppNew_17.apk").read_bytes(), b"new")
-            self.assertEqual((upgraded / "AppNew_17.apk.prof").read_bytes(), b"profile")
+            self.assertFalse((upgraded / "AppNew_17.apk.prof").exists())
             self.assertEqual(report.upgraded_packages, ["Set/App"])
             self.assertFalse((output / "Set" / "App" / "___priv-app___AppOld").exists())
 
@@ -59,6 +59,43 @@ class StableTreeUpgradeTests(unittest.TestCase):
                     root / "template", root / "old", root / "new", root / "output"
                 )
 
+    def test_complete_upgrade_replaces_dependencies_and_audits_carry_forward(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            template = root / "16_stable"
+            old = root / "16_mustang"
+            new = root / "17_mustang"
+            output = root / "17_stable"
+            old_location = "product/priv-app/AppOld/AppOld.apk"
+            new_location = "product/priv-app/AppNew/AppNew.apk"
+            self.inventory(old, "com.example", old_location)
+            self.inventory(new, "com.example", new_location)
+            (old / old_location).parent.mkdir(parents=True)
+            (old / old_location).write_bytes(b"old")
+            (new / new_location).parent.mkdir(parents=True)
+            (new / new_location).write_bytes(b"new")
+            (new / "product/etc/permissions/updated.xml").parent.mkdir(parents=True)
+            (new / "product/etc/permissions/updated.xml").write_bytes(b"17")
+            package = template / "Set" / "App"
+            (package / "___priv-app___AppOld").mkdir(parents=True)
+            (package / "___priv-app___AppOld/AppOld.apk").write_bytes(b"template")
+            (package / "___etc___permissions").mkdir(parents=True)
+            (package / "___etc___permissions/updated.xml").write_bytes(b"16")
+            (package / "___etc___permissions/retained.xml").write_bytes(b"retain")
+            (package / "___priv-app___AppOld/AppOld.apk.prof").write_bytes(b"old profile")
+
+            report = StableTreeUpgrader().upgrade(
+                template, old, new, output, carry_forward_missing=True)
+
+            upgraded = output / "Set/App"
+            self.assertFalse((upgraded / "___priv-app___AppOld").exists())
+            self.assertEqual((upgraded / "___priv-app___AppNew/AppNew.apk").read_bytes(), b"new")
+            self.assertEqual((upgraded / "___etc___permissions/updated.xml").read_bytes(), b"17")
+            self.assertEqual((upgraded / "___etc___permissions/retained.xml").read_bytes(), b"retain")
+            self.assertFalse(any(upgraded.rglob("*.prof")))
+            self.assertIn("Set/App/___etc___permissions/updated.xml", report.updated_dependencies)
+            self.assertIn("Set/App/___etc___permissions/retained.xml", report.carried_forward_files)
+
 
 if __name__ == "__main__":
     unittest.main()