NikGapps 3.95__tar.gz → 3.97__tar.gz

{nikgapps-3.95 → nikgapps-3.97}/NikGapps/build/Build.py

@@ -34,6 +34,8 @@ class Build:
                 Path(Config.PACKAGE_CACHE),
                 channel=Config.PACKAGE_CHANNEL,
                 channel_overrides=channel_overrides_from_env(Config.PACKAGE_CHANNEL_OVERRIDES),
+                release_index_url=Config.PACKAGE_RELEASE_INDEX_URL,
+                release_id=Config.PACKAGE_RELEASE_ID,
                 token=os.environ.get("GITLAB_TOKEN"),
             )
             Config.APK_SOURCE = str(registry_source.prepare(

{nikgapps-3.95 → nikgapps-3.97}/NikGapps/helper/Assets.py

@@ -22,7 +22,7 @@ class Assets:
     cwd = assets_folder + os.path.sep
     system_name = A.system_name
     apksigner_path = A.get("apksigner.jar")
-    apktool_path = A.get("apktool_2.11.1.jar")
+    apktool_path = A.get("apktool_3.0.2.jar")
     key_path = A.get("cert.pk8")
     cert_path = A.get("cert.x509.pem")
     private_key_pem = A.get("private_key.pem")

{nikgapps-3.95 → nikgapps-3.97}/NikGapps/helper/Config.py

@@ -65,6 +65,11 @@ PACKAGE_APPSETS_URL = os.environ.get(
     "PACKAGE_APPSETS_URL",
     "https://gitlab.com/nikgapps/nikgapps-package-catalog/-/raw/main/appsets.json"
 )
+PACKAGE_RELEASE_INDEX_URL = os.environ.get(
+    "PACKAGE_RELEASE_INDEX_URL",
+    "https://gitlab.com/nikgapps/nikgapps-package-catalog/-/raw/main/releases/index.json"
+)
+PACKAGE_RELEASE_ID = os.environ.get("PACKAGE_RELEASE_ID")
 PACKAGE_CACHE = os.environ.get(
     "PACKAGE_CACHE",
     os.path.abspath(os.path.join(os.getcwd(), ".nikgapps-package-cache"))

{nikgapps-3.95 → nikgapps-3.97}/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.97}/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.97/NikGapps.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NikGapps
-Version: 3.95
+Version: 3.97
 Summary: A short description of your project
 Home-page: https://github.com/nikgapps/project
 Author: Nikhil Menghani
@@ -22,7 +22,7 @@ Requires-Dist: PyGithub~=2.8.1
 Requires-Dist: python-gitlab~=8.0.0
 Requires-Dist: cryptography~=46.0.3
 Requires-Dist: python-dotenv~=1.2.1
-Requires-Dist: niklibrary~=0.55
+Requires-Dist: niklibrary~=0.56
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{nikgapps-3.95 → nikgapps-3.97}/NikGapps.egg-info/requires.txt

@@ -10,4 +10,4 @@ PyGithub~=2.8.1
 python-gitlab~=8.0.0
 cryptography~=46.0.3
 python-dotenv~=1.2.1
-niklibrary~=0.55
+niklibrary~=0.56

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NikGapps
-Version: 3.95
+Version: 3.97
 Summary: A short description of your project
 Home-page: https://github.com/nikgapps/project
 Author: Nikhil Menghani
@@ -22,7 +22,7 @@ Requires-Dist: PyGithub~=2.8.1
 Requires-Dist: python-gitlab~=8.0.0
 Requires-Dist: cryptography~=46.0.3
 Requires-Dist: python-dotenv~=1.2.1
-Requires-Dist: niklibrary~=0.55
+Requires-Dist: niklibrary~=0.56
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

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

@@ -24,6 +24,8 @@ DEFAULT_INPUT = Path(r"D:\workspace\python\16_stable")
 DEFAULT_OUTPUT = Path(r"D:\workspace\python\16_STABLE_PREBUILT_RELEASE")
 DEFAULT_CONFIG = Path(__file__).with_name("nikgapps-pipeline.example.json")
 DEFAULT_GITLAB_PROJECT = "85036487"
+DEFAULT_RELEASE_ROOT = Path(__file__).resolve().parents[2]
+DEFAULT_MULTI_RELEASE_OUTPUT = DEFAULT_RELEASE_ROOT / "MULTI_RELEASE_PREVIEW"
 
 
 def _load_env_file(path: Path) -> bool:
@@ -93,7 +95,13 @@ def build_parser() -> argparse.ArgumentParser:
         help="override platform API; otherwise derived from --android-version",
     )
     migrate.add_argument("--channel", default="stable")
+    migrate.add_argument("--source", default="legacy", help="payload source label recorded in release metadata")
     migrate.add_argument("--aapt2", default=find_aapt2())
+    migrate.add_argument(
+        "--overlay-root",
+        type=Path,
+        help="compiled overlay repository to embed into matching packages",
+    )
     migrate.add_argument(
         "--package",
         action="append",
@@ -161,6 +169,38 @@ def build_parser() -> argparse.ArgumentParser:
     )
     _common_gitlab(reset)
 
+    reset_sync = commands.add_parser(
+        "reset-and-sync",
+        help="permanently reset Generic packages, rebuild, publish, and replace metadata",
+    )
+    reset_sync.add_argument("--verbose", action="store_true")
+    reset_sync.add_argument("--confirm-project", required=True,
+                            help="must exactly match --gitlab-project")
+    reset_sync.add_argument("--gitlab-project", default=DEFAULT_GITLAB_PROJECT)
+    reset_sync.add_argument("--input", type=Path, default=DEFAULT_INPUT,
+                            help="advanced single-release input override")
+    reset_sync.add_argument("--output", type=Path, default=DEFAULT_MULTI_RELEASE_OUTPUT)
+    reset_sync.add_argument("--config", type=Path, default=DEFAULT_CONFIG)
+    reset_sync.add_argument(
+        "--android-version", default="16",
+        help="one version or comma-separated versions; discovers VERSION_stable and overlays_VERSION",
+    )
+    reset_sync.add_argument("--platform-api", type=int)
+    reset_sync.add_argument("--channel", default="stable")
+    reset_sync.add_argument("--source", default="legacy")
+    reset_sync.add_argument("--aapt2", default=find_aapt2())
+    reset_sync.add_argument("--overlay-root", type=Path)
+    reset_sync.add_argument(
+        "--release", action="append", metavar="VERSION=INPUT[=OVERLAYS]",
+        help="release to sync after one reset; repeat for Android 16 and 17",
+    )
+    reset_sync.add_argument("--package", action="append")
+    reset_sync.add_argument("--artifact-base-url")
+    reset_sync.add_argument("--metadata-branch", default="main")
+    reset_sync.add_argument("--compact", action="store_true")
+    reset_sync.add_argument("--compat-output", type=Path)
+    _common_gitlab(reset_sync)
+
     upgrade = commands.add_parser(
         "upgrade", help="create a stable legacy tree from a newer Mustang image"
     )
@@ -168,6 +208,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
 
 
@@ -192,6 +237,7 @@ def _migrate(args: argparse.Namespace) -> int:
         android_version=args.android_version,
         platform_api=derived_platform_api,
         channel=args.channel,
+        source=args.source,
     )
     client: GitLabClient | None = None
     project = args.gitlab_project
@@ -232,7 +278,7 @@ def _migrate(args: argparse.Namespace) -> int:
         release_path = (
             f"releases/android-{config.android_version}-{config.architecture}.json"
         )
-        for relative in ("catalog.json", "appsets.json", release_path):
+        for relative in ("catalog.json", "appsets.json", "releases/index.json", release_path):
             local = metadata / Path(relative)
             if local.exists():
                 continue
@@ -262,6 +308,7 @@ def _migrate(args: argparse.Namespace) -> int:
         artifact_base_url=base_url,
         pretty=not args.compact,
         package_filter=set(args.package) if args.package else None,
+        overlay_root=args.overlay_root,
     )
     if args.compat_output:
         LegacyCompatibilityExporter().export(packages, args.compat_output)
@@ -309,6 +356,60 @@ def _reset_registry(args: argparse.Namespace) -> int:
     return 0
 
 
+def _reset_and_sync(args: argparse.Namespace) -> int:
+    if args.confirm_project != str(args.gitlab_project):
+        raise PipelineError(
+            "--confirm-project must exactly match --gitlab-project; reset-and-sync is destructive"
+        )
+    releases: list[tuple[str, Path, Path | None]] = []
+    for value in args.release or []:
+        parts = value.split("=", 2)
+        if len(parts) not in (2, 3) or not parts[0] or not parts[1]:
+            raise PipelineError(
+                f"Invalid --release {value!r}; expected VERSION=INPUT[=OVERLAYS]"
+            )
+        releases.append((parts[0], Path(parts[1]), Path(parts[2]) if len(parts) == 3 else None))
+    if not releases:
+        versions = [value.strip() for value in str(args.android_version).split(",") if value.strip()]
+        if not versions:
+            raise PipelineError("--android-version must contain at least one Android version")
+        for android_version in versions:
+            releases.append((
+                android_version,
+                DEFAULT_RELEASE_ROOT / f"{android_version}_stable",
+                DEFAULT_RELEASE_ROOT / f"overlays_{android_version}",
+            ))
+    for android_version, input_path, overlay_root in releases:
+        if not input_path.is_dir():
+            raise PipelineError(f"Android {android_version} input directory does not exist: {input_path}")
+        if overlay_root is not None and not overlay_root.is_dir():
+            raise PipelineError(f"Android {android_version} overlay directory does not exist: {overlay_root}")
+
+    reset_result = _reset_registry(args)
+    if reset_result != 0:
+        return reset_result
+    # Force the only safe post-reset migration mode. These are intentionally
+    # not user-selectable flags on this command.
+
+    print(f"Starting fresh build and registry sync for {len(releases)} release(s)...")
+    for index, (android_version, input_path, overlay_root) in enumerate(releases):
+        operation = argparse.Namespace(**vars(args))
+        operation.android_version = android_version
+        operation.input = input_path
+        operation.overlay_root = overlay_root
+        operation.publish = True
+        operation.fresh_metadata = index == 0
+        operation.create_project = False
+        operation.namespace_id = None
+        operation.namespace = "nikgapps"
+        operation.visibility = "public"
+        print(f"[{index + 1}/{len(releases)}] Syncing Android {android_version} from {input_path}")
+        result = _migrate(operation)
+        if result != 0:
+            return result
+    return 0
+
+
 def main(argv: Sequence[str] | None = None) -> int:
     parser = build_parser()
     args = parser.parse_args(argv)
@@ -335,10 +436,25 @@ def main(argv: Sequence[str] | None = None) -> int:
             return 0
         if args.command == "reset-registry":
             return _reset_registry(args)
+        if args.command == "reset-and-sync":
+            return _reset_and_sync(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.97}/nikgapps_package_pipeline/config.py

@@ -34,7 +34,9 @@ class PipelineConfig:
     android_version: str = "16"
     platform_api: int = 36
     channel: str = "stable"
+    source: str = "legacy"
     architecture: str = "arm64-v8a"
+    default_device_type: str = "phone"
     default_partition: str = "product"
     packages: dict[str, PackageOverride] = field(default_factory=dict)
 
@@ -48,7 +50,7 @@ class PipelineConfig:
 def _override(value: dict[str, Any], default_partition: str) -> PackageOverride:
     accepted = {
         "id", "name", "primaryApk", "defaultPartition", "minApi", "maxApi",
-        "architectures", "replaceable", "include", "exclude",
+        "architectures", "deviceTypes", "replaceable", "include", "exclude",
         "removeFiles", "removeOverlays", "privilegedPermissions",
         "cleanFlashOnly", "additionalInstallerScript", "validationScript",
         "addonIndex",
@@ -67,6 +69,7 @@ def _override(value: dict[str, Any], default_partition: str) -> PackageOverride:
         min_api=value.get("minApi"),
         max_api=value.get("maxApi"),
         architectures=value.get("architectures"),
+        device_types=value.get("deviceTypes"),
         replaceable=value.get("replaceable", True),
         include=value.get("include"),
         exclude=value.get("exclude", []),
@@ -81,13 +84,15 @@ def _override(value: dict[str, Any], default_partition: str) -> PackageOverride:
 
 
 def load_config(
-    path: Path | None, *, android_version: str, platform_api: int, channel: str
+    path: Path | None, *, android_version: str, platform_api: int, channel: str,
+    source: str = "legacy",
 ) -> PipelineConfig:
     if path is None:
         return PipelineConfig(
             android_version=android_version,
             platform_api=platform_api,
             channel=channel,
+            source=source,
         )
     try:
         raw = json.loads(path.read_text(encoding="utf-8"))
@@ -105,7 +110,9 @@ def load_config(
         # The channel is an operation-time promotion target. A single config
         # must be reusable for stable, beta, and canary publication.
         channel=channel,
+        source=source,
         architecture=raw.get("architecture", "arm64-v8a"),
+        default_device_type=raw.get("defaultDeviceType", "phone"),
         default_partition=default_partition,
     )
     packages = raw.get("packages", {})

{nikgapps-3.95 → nikgapps-3.97}/nikgapps_package_pipeline/consumer.py

@@ -56,6 +56,8 @@ class CatalogPackageSource:
         *,
         channel: str = "stable",
         channel_overrides: dict[str, str] | None = None,
+        release_index_url: str | None = None,
+        release_id: str | None = None,
         token: str | None = None,
     ) -> None:
         self.catalog_url = catalog_url
@@ -63,6 +65,8 @@ class CatalogPackageSource:
         self.cache_directory = cache_directory.resolve()
         self.channel = channel
         self.channel_overrides = channel_overrides or {}
+        self.release_index_url = release_index_url
+        self.release_id = release_id
         self.token = token
 
     def prepare(
@@ -70,6 +74,7 @@ class CatalogPackageSource:
         appsets: Iterable[Any],
         android_version: str | int | float,
         architecture: str,
+        device_type: str = "phone",
     ) -> Path:
         appsets = list(appsets)
         selected_names = ", ".join(appset.title for appset in appsets)
@@ -80,6 +85,32 @@ class CatalogPackageSource:
         _message("Reading catalog and AppSet metadata")
         catalog = self._read_json(self.catalog_url)
         appset_document = self._read_json(self.appsets_url)
+        release_versions: dict[str, str] = {}
+        if self.release_index_url:
+            release_index = self._read_json(self.release_index_url)
+            arch = catalog_architecture(architecture)
+            selected_id = self.release_id
+            if not selected_id:
+                selected_id = (
+                    release_index.get("latest", {}).get(str(android_version), {})
+                    .get(self.channel, {}).get(arch)
+                )
+            summary = next((item for item in release_index.get("releases", [])
+                            if item.get("id") == selected_id), None)
+            if not summary:
+                raise PipelineError(
+                    f"No {self.channel} release for Android {android_version} ({arch})"
+                )
+            metadata_root = self.release_index_url.rsplit("/releases/index.json", 1)[0]
+            release = self._read_json(f"{metadata_root}/{summary['manifest']}")
+            release_versions = {
+                package_id: value["version"]
+                for package_id, value in release.get("packages", {}).items()
+            }
+            appset_document = {
+                "schemaVersion": release.get("schemaVersion", 1),
+                "appSets": release.get("appSets", []),
+            }
         catalog_packages = {
             item["id"]: item for item in catalog.get("packages", [])
         }
@@ -137,7 +168,10 @@ class CatalogPackageSource:
             package = catalog_packages.get(package_id)
             if not package:
                 raise PipelineError(f"Resolved package {package_id!r} is absent from catalog.json")
-            version = self._resolve_version(package, api, arch)
+            version = self._resolve_version(
+                package, api, arch, release_versions.get(package_id),
+                catalog.get("defaults", {}), device_type
+            )
             resolutions.append((package_id, package, version))
         fingerprint = hashlib.sha256(
             "\n".join(
@@ -157,9 +191,15 @@ class CatalogPackageSource:
         source_root.mkdir(parents=True, exist_ok=True)
         selected_appset_names = {appset.title for appset in appsets}
         for package_id, package, version in resolutions:
+            resolved_version_key = (
+                release_versions.get(package_id)
+                or package.get("channels", {}).get(
+                    self.channel_overrides.get(package_id, self.channel)
+                )
+                or "unknown"
+            )
             _message(
-                f"Resolving {package_id} -> "
-                f"{package.get('channels', {}).get(self.channel, 'channel override')}"
+                f"Resolving {package_id} -> {resolved_version_key}"
             )
             archive = self._artifact(version["artifact"])
             self._materialize(
@@ -181,27 +221,45 @@ class CatalogPackageSource:
         package: dict[str, Any],
         api: int,
         architecture: str,
+        release_version: str | None = None,
+        defaults: dict[str, Any] | None = None,
+        device_type: str = "phone",
     ) -> dict[str, Any]:
         package_id = package["id"]
         channel = self.channel_overrides.get(package_id, self.channel)
-        version_key = package.get("channels", {}).get(channel)
+        version_key = release_version or package.get("channels", {}).get(channel)
         if not version_key:
             raise PipelineError(f"Package {package_id} has no {channel!r} channel")
         version = package.get("versions", {}).get(version_key)
         if not version:
             raise PipelineError(f"Package {package_id} channel points to missing {version_key}")
         android = version.get("android", {})
+        supported_android = version.get("supportedAndroidVersions", [])
+        requested_android = {
+            29: "10", 30: "11", 31: "12", 32: "12.1", 33: "13",
+            34: "14", 35: "15", 36: "16", 37: "17",
+        }.get(api)
+        if supported_android and requested_android not in supported_android:
+            raise PipelineError(
+                f"Package {package_id} is not published for Android {requested_android or api}"
+            )
         minimum = android.get("minApi")
         maximum = android.get("maxApi")
         if minimum is not None and api < int(minimum):
             raise PipelineError(f"Package {package_id} requires API {minimum}; build targets API {api}")
         if maximum is not None and api > int(maximum):
             raise PipelineError(f"Package {package_id} supports at most API {maximum}; build targets API {api}")
-        architectures = version.get("architectures", [])
+        defaults = defaults or {}
+        architectures = version.get("architectures", defaults.get("architectures", []))
         if architectures and architecture not in architectures:
             raise PipelineError(
                 f"Package {package_id} does not support {architecture}: {architectures}"
             )
+        device_types = version.get("deviceTypes", defaults.get("deviceTypes", ["phone"]))
+        if device_types and device_type not in device_types:
+            raise PipelineError(
+                f"Package {package_id} does not support {device_type} devices: {device_types}"
+            )
         return version
 
     def _artifact(self, artifact: dict[str, Any]) -> Path:

{nikgapps-3.95 → nikgapps-3.97}/nikgapps_package_pipeline/gitlab.py

@@ -216,9 +216,25 @@ class GitLabClient:
 
     def delete_package(self, project: str, package_id: int) -> None:
         encoded_project = urllib.parse.quote(str(project), safe="")
-        self._request(
-            "DELETE", f"projects/{encoded_project}/packages/{int(package_id)}"
-        )
+        endpoint = f"projects/{encoded_project}/packages/{int(package_id)}"
+        last_error: PipelineError | None = None
+        for attempt in range(6):
+            try:
+                self._request("DELETE", endpoint)
+                return
+            except PipelineError as exc:
+                last_error = exc
+                retryable = any(f"HTTP {status}" in str(exc) for status in (429, 500, 502, 503, 504))
+                if not retryable or attempt == 5:
+                    raise
+                delay = min(30, 2 ** attempt)
+                print(
+                    f"[Registry] Delete rate-limited or temporarily unavailable "
+                    f"(attempt {attempt + 1}/6); retrying in {delay}s"
+                )
+                time.sleep(delay)
+        assert last_error is not None
+        raise last_error
 
     def commit_directory(
         self,

{nikgapps-3.95 → nikgapps-3.97}/nikgapps_package_pipeline/models.py

@@ -31,6 +31,7 @@ class PackageOverride:
     min_api: int | None = None
     max_api: int | None = None
     architectures: list[str] | None = None
+    device_types: list[str] | None = None
     replaceable: bool = True
     include: list[str] | None = None
     exclude: list[str] = field(default_factory=list)
@@ -64,6 +65,7 @@ class BuiltPackage:
     max_api: int | None
     default_partition: str
     architectures: list[str]
+    device_types: list[str]
     primary_apk: str | None
     replaceable: bool
     files: list[PayloadFile]
@@ -75,8 +77,9 @@ class BuiltPackage:
     dependencies: list[dict[str, Any]] = field(default_factory=list)
     descriptor: dict[str, Any] = field(default_factory=dict)
 
-    def catalog_version(self, artifact_url: str) -> dict[str, Any]:
-        return {
+    def catalog_version(self, artifact_url: str, android_version: str, source: str,
+                        default_architecture: str, default_device_type: str) -> dict[str, Any]:
+        result = {
             "versionName": self.metadata.version_name if self.metadata else self.version_key,
             "versionCode": self.metadata.version_code if self.metadata else 0,
             "packageName": self.metadata.package_name if self.metadata else None,
@@ -85,7 +88,8 @@ class BuiltPackage:
                 "targetApi": self.target_api,
                 "maxApi": self.max_api,
             },
-            "architectures": self.architectures,
+            "supportedAndroidVersions": [str(android_version)],
+            "sources": [source],
             "defaultPartition": self.default_partition,
             "apk": {
                 "path": self.primary_apk,
@@ -100,3 +104,8 @@ class BuiltPackage:
             "files": self.descriptor.get("files", []),
             "install": self.descriptor.get("install"),
         }
+        if self.architectures != [default_architecture]:
+            result["architectures"] = self.architectures
+        if self.device_types != [default_device_type]:
+            result["deviceTypes"] = self.device_types
+        return result