# Copyright 2019 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import("//build/assembly/legacy.gni")
import("//build/component/component_id_index.gni")
import("//build/config.gni")
import("//build/drivers/driver_manifest.gni")
import("//build/images/assembly/compare_json_list.gni")
import("//build/images/assembly/generated_assembly_inputs.gni")
import("//build/images/assembly/generated_images_config.gni")
import("//build/images/assembly/generated_partitions_config.gni")
import("//build/images/assembly/generated_product_config.gni")
import("//build/images/assembly/hermetic_inputs_for_image_assembly.gni")
import("//build/images/fvm.gni")
import("//build/images/shell_commands.gni")
import("//build/info/info.gni")
import("//build/packages/package_metadata.gni")
import("//build/product.gni")
import("//build/python/python_action.gni")
import("//build/security/verifier/verify_bootfs.gni")
import("//build/security/verifier/verify_kernel_cmdline.gni")
import("//build/security/verifier/verify_route_sources.gni")
import("//build/security/verifier/verify_static_pkgs.gni")
import("//build/zircon/tools.gni")
import("//src/developer/ffx/build/ffx_action.gni")
import("//src/storage/fshost/generated_fshost_config.gni")

# Assembles a Fuchsia system.
#
# Given base, cache, and universe packages, assembles a Fuchsia system
# containing those packages.
#
# Parameters:
#
#   image_name (optional; default: target_name)
#     [string] A name to use for naming all outputs and generated files, instead
#     of $target_name.
#
#   sysmgr_golden, sysmgr_golden_warn (optional, default: false)
#     [path, boolean] Passed directly to the config_package template, see //build/config.gni.
#
#   output_dir (optional; default: target_out_dir)
#     [string] The output directory into which the final system ZBI is written.
#
#   output_name (optional; default: <target_name>.zbi)
#     [string] The name of the final system ZBI file.
#
#   cmdline_goldens (optional)
#     [list of files] A list of possible kernel cmdline golden file to compare
#     against. Verified if matches one of the goldens. At most two entries are
#     supported for soft migration, if the content matches either of the entries,
#     it is consider a match. Only one entry should be used for normal case.
#
#   bootfs_goldens (optional)
#     [list of files] A list of possible bootFS golden file to compare against.
#     Verified if matches one of the goldens. At most two entries are
#     supported for soft migration, if the content matches either of the entries,
#     it is consider a match. Only one entry should be used for normal case.
#
#   static_pkgs_goldens (optional)
#     [list of files] A list of possible static pkgs golden file to compare
#     against. Verified if matches one of the goldens. At most two entries are
#     supported for soft migration, if the content matches either of the entries,
#     it is consider a match. Only one entry should be used for normal case.
#
#   route_sources_config
#     [string] A path to the config file to be used when invoking the
#     route_sources verifier on the assembled system. This parameter is,
#     temporarily, only available for the `fuchsia` image. For details, see
#     fxbug.dev/85664.
#
#   testonly (optional)
#     [bool] Usual GN meanings.
#
# Product parameters:
#
#   base_packages (required)
#     [list of labels] The packages to include in the base package set.
#
#   base_driver_packages (optional)
#     [list of labels] The driver packages to include in the base package set.
#
#   cache_packages (optional)
#     [list of labels] The packages to cache in the images.
#
#   universe_packages (optional)
#     [list of labels] The packages to build in addition to the base and cache
#     sets. These packages do not contribute to the produced images directly,
#     however they may contribute to the config-data and shell-commands meta
#     packages.
#
#   meta_packages (optional)
#     [list of labels] The packages to build in addition to the base and cache
#     sets, but are base_packages themselves.  These are packages that contain
#     files that are generated based on other packages in the base, cache,
#     and/or universe sets, and therefore cannot be part of those sets directly,
#     or a GN dependency cycle will result.
#
#   bootfs_labels (required)
#     [list of labels] The objects installed on the bootfs partition of the
#     generated ZBI.
#
#   system_image_deps (optional)
#     [list of labels] The objects installed in the system image.
#
#   devmgr_config (default: [])
#     [list of strings] List of arguments to add to /boot/config/devmgr.
#     These arguments come after synthesized arguments to configure blobfs and
#     pkgfs.
#
#   fshost_config (default: {})
#     [scope] Arguments to add to fshost's configuration. These
#     arguments come before other arguments set by build args.
#
#   cmdline (optional)
#     [list of strings] Kernel command line text.
#
#   cmdline_deps (optional)
#     [list of labels] Dependencies with metadata including additional kernel
#     command arguments to add to the ZBI.
#
#   include_component_id_index (default: false)
#     [bool] Collect and merges a component id index from the base
#     package set.
#
#   include_shell_commands (default: true)
#     [bool] Whether to include shell commands. Should be set to false for
#     build without shell access.
#
#   base_package_name (optional; default: "system_image")
#     [string] The name to give the base package. For prime builds this
#     should be "system_image_prime", so that the package does not override the
#     non-prime package during publishing.
#
#   pkgfs_package_label (optional; default: //src/sys/pkg/bin/pkgfs/pkgfs)
#     [GN label] The pkgfs implementation to use, for those assemblies that
#     require one.
#
# Board parameters:
#
#   assembly_compress_blobs (default: true)
#     [boolean] Whether the blobs added to the blobfs image should be compressed.
#
#   assembly_blob_layout_format (default: "compact")
#     [string] The format blobfs should store blobs in. The valid values are "deprecated_padded" and
#     "compact". The deprecated padded format is supported only for Astro devices and will be
#     removed in the future (it wastes space).
#
#   check_production_tag (default: false)
#      [bool] Whether to check there is no non_production_tag dependencies.
#
# Board: MinFS parameters:
#
#   minfs_minimum_data_bytes, minfs_maximum_bytes (optional)
#     [int] Size options for minfs to pass to the fvm tool.
#
# Board: BlobFS parameters
#
#   blobfs_minimum_inodes, blobfs_minimum_data_bytes, blobfs_maximum_bytes (optional)
#     [int] Size options for blobfs to pass to the fvm tool.
#
# Board: FVM parameters
#
#   generate_fvm (optional; default: true)
#     [bool] Whether to generate a FVM image.
#
#   assembly_include_account_in_fvm (optional; default: false)
#     [bool] Whether to include an account partition in the FVM image.
#
#   ramdisk_fvm_in_zbi (optional)
#     [bool] Whether the FVM should be embedded into the ZBI as a ramdisk.
#
#   assembly_fvm_slice_size (optional; default: 1048576)
#     [int] The slice size of the FVM.
#
#   fvm_truncate_to_length (optional)
#     [int] The precise size to make the (non-sparse) FVM image. See
#     documentation of the `--length` parameter of the `fvm` binary host tool
#     for details.
#
# Board: ZBI arguments
#
#   zbi_name (optional; default: target_name)
#     [string] The name to give the ZBI in the out directory.
#     Typically: fuchsia, recovery, etc.
#
#   zbi_signing_script (optional)
#     [path] Location of script to use to sign the ZBI.
#
#   zbi_signing_args (optional)
#     [list of strings] Arguments to pass to the signing script.
#
template("assemble_system") {
  assert(defined(invoker.base_packages), "Need to define base_packages")
  assert(defined(invoker.bootfs_labels), "Need to define bootfs_labels")

  fvm_tool_target = "//src/storage/bin/fvm($host_toolchain)"
  fvm_tool_path = get_label_info(fvm_tool_target, "root_out_dir")
  fvm_tool_path += "/fvm"

  # This should be removed once all clients are no longer supplying board_name.
  not_needed(invoker, [ "board_name" ])

  image_name = target_name
  if (defined(invoker.image_name)) {
    image_name = invoker.image_name
  }

  base_package_name = "system_image"
  if (defined(invoker.base_package_name)) {
    base_package_name = invoker.base_package_name
  }

  # Internal labels used for Image Assembly.
  labels = {
    base_packages_group = "${image_name}_base_packages"
    cache_packages_group = "${image_name}_cache_packages"
    meta_packages_group = "${image_name}_meta_packages"
    all_packages_group = "${image_name}_packages"
    legacy_assembly_input_bundle = "${image_name}_legacy_input_bundle"
    product_assembly_config = "${image_name}_product_assembly_config"
    image_assembly_config = "${image_name}_image_assembly_config"
    image_assembly_inputs = "${image_name}_image_assembly_inputs"
    compare_image_assembly_configs =
        "${image_name}_compare_image_assembly_configs"
    images_config = "${image_name}_images_config"
    partitions_config = "${image_name}_partitions_config"
    product_assembler = "${image_name}_product_assembler"
    image_assembler = "${image_name}_image_assembler"
    copy_vbmeta = "${image_name}_copy_vbmeta"
    copy_zbi = "${image_name}_copy_zbi"
    copy_zbi_signed = "${image_name}_copy_zbi_signed"
    copy_zbi_manifest = "${image_name}_copy_zbi_manifest"
    copy_images = "${image_name}_copy_images"
    config_data = "${image_name}_config-data"
    shell_commands = "${image_name}_shell_commands"
    assembly_inputs = "${image_name}_assembly_inputs"
    fshost_config = "${image_name}_fshost_config"
    pkgfs_package_label = "//src/sys/pkg/bin/pkgfs"
    compare_command_logs = "${image_name}_compare_command_logs"
    compare_images_manifests = "${image_name}_compare_images_manifests"
  }

  # Intermediate files produced for Image Assembly.
  files = {
    product_assembly_config =
        "$target_out_dir/${image_name}_product_assembly_config.json"
    image_assembly_config =
        "$target_out_dir/${image_name}_image_assembly_config.json"
    image_assembly_inputs =
        "$target_out_dir/${image_name}_image_assembly_inputs"

    images_config = "$target_out_dir/${image_name}_images_config.json"
    partitions_config = "$target_out_dir/${image_name}_partitions.json"

    outdir = "$target_out_dir/$image_name"
    gendir = "$outdir/gen"

    legacy_assembly_input_bundle_manifest =
        "${outdir}/legacy/assembly_config.json"

    # This file is created implicitly by ffx assembly product, so this is the
    # path that it's expected to be found at, not the path that it's to be
    # written to.
    regenerated_image_assembly_config = "${outdir}/image_assembly.json"
    config_data_manifest = "${outdir}/config_data/package_manifest.json"
    compare_image_assembly_configs =
        "${outdir}/compare_image_assembly_configs.verified"

    bootfs_files = "${gendir}/bootfs_files.list"
    devmgr_config = "${gendir}/devmgr_config.txt"
    zbi = "${outdir}/${image_name}.zbi"
    zbi_signed = "${zbi}.signed"
    vbmeta = "${outdir}/${image_name}.vbmeta"
    minfs = "${outdir}/data.blk"
    blobfs = "${outdir}/blob.blk"
    fvm = "${outdir}/fvm.blk"
    fvm_sparse = "${outdir}/fvm.sparse.blk"
    fvm_blob_sparse = "${outdir}/fvm.blob.sparse.blk"
    fvm_fastboot_tmp = "${outdir}/fvm.fastboot.tmp.blk"
    fvm_fastboot = "${outdir}/fvm.fastboot.blk"

    base_package = "${outdir}/base/meta.far"
    base_package_manifest = "${outdir}/base/package_manifest.json"
    base_package_merkle = "${outdir}/base/base.merkle"

    packages = "${outdir}/packages.json"
    zbi_manifest = "${gendir}/zbi.json"
    blobfs_manifest = "${gendir}/blob.manifest"
    blobs_json = "${gendir}/blobs.json"
    static_packages = "${gendir}/${base_package_name}/data/static_packages"
    cache_packages = "${gendir}/${base_package_name}/data/cache_packages"
    base_meta_package = "${gendir}/${base_package_name}/meta/package"
    base_pkg_abi_revision =
        "${gendir}/${base_package_name}/meta/fuchsia.abi/abi-revision"
    images_manifest = "${outdir}/images.json"
    assembly_inputs = "${outdir}/assembly_inputs.json"

    image_command_log = "${gendir}/command_log.json"

    # Determine which ZBI we are shipping.
    zbi_final = zbi
    if (defined(invoker.zbi_signing_script)) {
      zbi_final = zbi_signed
    }
  }

  _base_packages = invoker.base_packages
  _base_driver_packages = []
  _cache_packages = []
  _universe_packages = []
  _meta_packages = []
  if (defined(invoker.base_driver_packages)) {
    _base_driver_packages = invoker.base_driver_packages
  }
  _base_packages += _base_driver_packages

  if (defined(invoker.cache_packages)) {
    _cache_packages = invoker.cache_packages
  }
  if (defined(invoker.universe_packages)) {
    _universe_packages = invoker.universe_packages
  }
  if (defined(invoker.meta_packages)) {
    _meta_packages = invoker.meta_packages
  }

  generate_fvm = true
  if (defined(invoker.generate_fvm)) {
    generate_fvm = invoker.generate_fvm
  }

  system_image_deps = []
  if (defined(invoker.system_image_deps) && generate_fvm) {
    system_image_deps += invoker.system_image_deps
  } else {
    not_needed(invoker, [ "system_image_deps" ])
  }

  embed_fvm_in_zbi = false
  if (defined(invoker.ramdisk_fvm_in_zbi)) {
    embed_fvm_in_zbi = invoker.ramdisk_fvm_in_zbi && generate_fvm
  }

  devmgr_config = []
  if (defined(invoker.devmgr_config)) {
    devmgr_config = invoker.devmgr_config
  }

  fshost_config = {
  }
  if (defined(invoker.fshost_config)) {
    fshost_config = invoker.fshost_config
  }

  include_shell_commands = true
  if (defined(invoker.include_shell_commands)) {
    include_shell_commands = invoker.include_shell_commands
  }

  # Generate the base driver manifest file that lists all available drivers
  # collected from _base_driver_packages dependency tree. This manifest file
  # will be included in the driver-manager-base-config package.
  base_driver_manifest_label = "${image_name}_base-driver-manifest"
  combined_driver_manifest(base_driver_manifest_label) {
    forward_variables_from(invoker, [ "testonly" ])
    manifest_name = "base-driver-manifest.json"
    deps = _base_driver_packages
  }

  # The driver-manager-base-config package is read by Driver Manager to
  # discover where the base drivers are located.
  driver_manager_base_config_label = "${image_name}_driver-manager-base-config"
  fuchsia_package(driver_manager_base_config_label) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])
    package_name = "driver-manager-base-config"
    deps = [ ":${base_driver_manifest_label}" ]
  }
  _meta_packages += [ ":${driver_manager_base_config_label}" ]

  # TODO(fxbug.dev/81290): Construct the shell commands package in the Image
  # Assembler.
  if (include_shell_commands) {
    shell_commands(labels.shell_commands) {
      forward_variables_from(invoker,
                             [
                               "testonly",
                               "visibility",
                             ])
      package_name = "shell-commands"
      deps = _base_packages + _cache_packages + _universe_packages
    }
    _meta_packages += [ ":${labels.shell_commands}" ]
  } else {
    not_needed([ "_universe_packages" ])
  }

  # For details, see //docs/development/components/component_id_index.md#system-assembly
  component_id_index_config("${image_name}_component_id_index_config") {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])

    # collect and merge component ID indices from the base set.
    deps = _base_packages
  }

  component_id_index_dep = []
  component_id_index_config_data_dep = []
  include_component_index = defined(invoker.include_component_id_index) &&
                            invoker.include_component_id_index
  if (include_component_index) {
    component_id_index_dep = [ ":${image_name}_component_id_index_config" ]
    component_id_index_config_data_dep =
        [ ":${image_name}_component_id_index_config-config-data" ]
  }
  _meta_packages += component_id_index_dep

  config_package(labels.config_data) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])
    package_name = "config-data"
    deps = _base_packages + _cache_packages + _universe_packages +
           component_id_index_config_data_dep
    if (defined(invoker.sysmgr_golden)) {
      sysmgr_golden = invoker.sysmgr_golden
    }
    if (defined(invoker.sysmgr_golden_warn)) {
      sysmgr_golden_warn = invoker.sysmgr_golden_warn
    }
  }
  _meta_packages += [ ":${labels.config_data}" ]

  generated_fshost_config(labels.fshost_config) {
    options = fshost_config
    if (embed_fvm_in_zbi) {
      fvm_ramdisk = true
    }
  }

  # Create GN groups for each of the package sets.
  group(labels.base_packages_group) {
    forward_variables_from(invoker, [ "testonly" ])
    public_deps = _base_packages
  }

  group(labels.cache_packages_group) {
    forward_variables_from(invoker, [ "testonly" ])
    public_deps = _cache_packages
  }

  # The group of generated packages that contain files that depend on metadata
  # walks of the base/cache/universe package sets and therefore cannot be part
  # of those package sets.
  group(labels.meta_packages_group) {
    forward_variables_from(invoker, [ "testonly" ])
    public_deps = _meta_packages
  }

  #######
  # Build the images using the Image Assembler.
  #

  generated_product_config(labels.image_assembly_config) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])

    output_path = files.image_assembly_config
    kernel_image = "//zircon/kernel"

    base_packages = []
    if (generate_fvm) {
      base_packages = _base_packages
      base_packages += _meta_packages

      if (defined(invoker.pkgfs_package_label)) {
        base_packages += [ invoker.pkgfs_package_label ]
      } else {
        base_packages += [ labels.pkgfs_package_label ]
      }

      cache_packages = _cache_packages
    }

    boot_args = devmgr_config

    # Search for BootFS files in these targets.
    bootfs_labels = invoker.bootfs_labels
    bootfs_labels += component_id_index_dep
    bootfs_labels += [ "//zircon/kernel" ]
    bootfs_labels += [ ":${labels.fshost_config}" ]

    # Only builds with an FVM need base-resolver for pkgfs.
    if (generate_fvm) {
      bootfs_labels += [ "//src/sys/base-resolver:bootfs" ]
    }

    # If not building an FVM, then put the driver_manager config into bootfs
    if (!generate_fvm) {
      bootfs_labels += [ ":${driver_manager_base_config_label}" ]
    }

    extra_base_deps = system_image_deps

    # Search for the Kernel cmdline in the BootFS dependencies.
    cmdline_deps = invoker.bootfs_labels
    if (defined(invoker.cmdline_deps)) {
      cmdline_deps += invoker.cmdline_deps
    }
    if (defined(invoker.cmdline)) {
      cmdline = invoker.cmdline
    }
  }

  generated_images_config(labels.images_config) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                             "zbi_signing_script",
                             "zbi_signing_args",
                             "minfs_maximum_bytes",
                             "minfs_minimum_data_bytes",
                             "blobfs_maximum_bytes",
                             "blobfs_minimum_data_bytes",
                             "blobfs_minimum_inodes",
                             "fvm_truncate_to_length",
                           ])

    output_path = files.images_config
    zbi_name = "${image_name}"
    fvm_reserved_slices = fvm_reserved_slices
    generate_fvm = generate_fvm

    fvm_slice_size = 1048576
    if (defined(invoker.assembly_fvm_slice_size)) {
      fvm_slice_size = invoker.assembly_fvm_slice_size
    }

    blob_layout_format = "compact"
    if (defined(invoker.assembly_blob_layout_format)) {
      blob_layout_format = invoker.assembly_blob_layout_format
    }

    compress_blobs = true
    if (defined(invoker.assembly_compress_blobs)) {
      compress_blobs = invoker.assembly_compress_blobs
    }

    if (defined(invoker.assembly_include_account_in_fvm)) {
      empty_account_partition = invoker.assembly_include_account_in_fvm
    }
  }

  generated_partitions_config(labels.partitions_config) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])

    output_path = files.partitions_config
    if (defined(invoker.use_esp) && invoker.use_esp) {
      esp_image_path = "${root_build_dir}/fuchsia.esp.blk"
      deps = [ "//build/images:esp" ]
    }
  }

  check_production_tag = false
  if (defined(invoker.check_production_tag)) {
    check_production_tag = invoker.check_production_tag
  }

  generated_file(labels.product_assembly_config) {
    outputs = [ files.product_assembly_config ]
    output_conversion = "json"
    contents = {
      platform = platform_config
      product = product_config
    }
  }

  generated_assembly_inputs(labels.assembly_inputs) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])
    images_config = files.images_config
    output_path = files.assembly_inputs

    sources = [
      "${files.outdir}/legacy",
      "${files.product_assembly_config}",
    ]

    deps = [
      ":${labels.images_config}",
      ":${labels.product_assembly_config}",
    ]
  }

  # Create the legacy assembly input bundle for the above-generated image
  # assembly configuration.
  legacy_assembly_input_bundle(labels.legacy_assembly_input_bundle) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])
    image_assembly_label = ":${image_name}"
    bundles_dir = files.outdir
    include_config_data = generate_fvm
  }

  # Run product assembly.
  ffx_action(labels.product_assembler) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])

    # TODO(fxbug.dev/77290) - Add depfile support and then remove the following
    hermetic_deps = false

    args = [
      "--config",
      "assembly_enabled=true",
      "assembly",
      "product",
      "--product",
      rebase_path(files.product_assembly_config, root_build_dir),
      "--input-bundles-dir",
      rebase_path(files.outdir, root_build_dir),
      "--outdir",
      rebase_path(files.outdir, root_build_dir),
    ]

    deps = [
      ":${labels.legacy_assembly_input_bundle}",
      ":${labels.product_assembly_config}",
    ]

    inputs = [
      files.product_assembly_config,
      files.legacy_assembly_input_bundle_manifest,
    ]

    outputs = [ files.regenerated_image_assembly_config ]

    # If there isn't an FVM, there won't be a config-data package, and so it
    # won't be created by product assembly (it won't have any config data in
    # the legacy or common configs.)
    if (generate_fvm) {
      outputs += [ files.config_data_manifest ]
    }
  }

  python_action(labels.compare_image_assembly_configs) {
    forward_variables_from(invoker, [ "testonly" ])
    hermetic_deps = false

    binary_label = "//build/assembly/scripts:compare_image_assembly_configs"
    deps = [
      ":${labels.image_assembly_config}",
      ":${labels.product_assembler}",
    ]
    inputs = [
      files.image_assembly_config,
      files.regenerated_image_assembly_config,
    ]
    outputs = [ files.compare_image_assembly_configs ]
    args = [
      "--stamp",
      rebase_path(files.compare_image_assembly_configs, root_build_dir),
      rebase_path(files.image_assembly_config, root_build_dir),
      rebase_path(files.regenerated_image_assembly_config, root_build_dir),
    ]
  }

  hermetic_inputs_for_image_assembly(labels.image_assembly_inputs) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])
    deps = [
      ":${labels.images_config}",
      ":${labels.product_assembler}",
    ]

    image_assembly_config = files.regenerated_image_assembly_config
    images_config = files.images_config
    output = files.image_assembly_inputs
  }

  ffx_action(labels.image_assembler) {
    no_output_dir_leaks = false

    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])
    metadata = {
      # We insert these barriers to prevent the dependencies of these images
      # from leaking into images "higher up" in the dependency chain.
      package_barrier = []
      config_package_barrier = []
      distribution_entries_barrier = []

      if (defined(invoker.metadata)) {
        forward_variables_from(invoker.metadata, "*")
      }

      if (generate_fvm) {
        package_output_manifests = [ files.base_package_manifest ]
      }
    }

    hermetic_inputs_target = ":${labels.image_assembly_inputs}"
    hermetic_inputs_file = files.image_assembly_inputs

    args = [
      "--config",
      "assembly_enabled=true",
      "assembly",
      "create-system",
      "--image-assembly-config",
      rebase_path(files.regenerated_image_assembly_config, root_build_dir),
      "--images",
      rebase_path(files.images_config, root_build_dir),
      "--base-package-name",
      "$base_package_name",
      "--gendir",
      rebase_path(files.gendir, root_build_dir),
      "--outdir",
      rebase_path(files.outdir, root_build_dir),
    ]

    if (embed_fvm_in_zbi) {
      args += [
        "--mode",
        "fvm-in-zbi",
      ]
    } else if (!generate_fvm) {
      args += [
        "--mode",
        "bootfs",
      ]
    }

    deps = []
    if (defined(invoker.deps)) {
      deps += invoker.deps
    }
    deps += [
      ":${labels.images_config}",
      ":${labels.product_assembler}",
    ]

    inputs = [
      files.images_config,
      files.regenerated_image_assembly_config,
    ]
    if (defined(invoker.inputs)) {
      inputs += invoker.inputs
    }

    outputs = [
      files.bootfs_files,
      files.devmgr_config,
      files.zbi,
      files.zbi_manifest,
      files.packages,
      files.image_command_log,
      files.images_manifest,
    ]

    if (defined(invoker.zbi_signing_script)) {
      outputs += [ files.zbi_signed ]
    }

    if (use_vbmeta) {
      outputs += [ files.vbmeta ]
    }

    # Base package dependencies and outputs, if this configuration uses them.
    if (generate_fvm) {
      deps += [
        blobfs_tool_target,
        fvm_tool_target,
      ]

      inputs += [
        blobfs_tool_path,
        fvm_tool_path,
      ]

      outputs += [
        # In the outdir.
        files.base_package,
        files.base_package_manifest,
        files.base_package_merkle,
        files.minfs,
        files.blobfs,
        files.fvm,
        files.fvm_sparse,
        files.fvm_blob_sparse,

        # In the gendir.
        files.blobfs_manifest,
        files.blobs_json,
        files.static_packages,
        files.cache_packages,
        files.base_meta_package,
        files.base_pkg_abi_revision,
      ]

      if (fvm_emmc_partition_size != false ||
          fvm_ftl_nand_block_count != false) {
        outputs += [ files.fvm_fastboot ]
        if (fvm_ftl_nand_block_count != false) {
          outputs += [ files.fvm_fastboot_tmp ]
        }
      }
    }

    if (check_production_tag) {
      assert_no_deps = [ "//build/validate:non_production_tag" ]
    }
  }

  #######
  # Optionally, copy the resulting ZBI to the specified directory.
  #

  if (defined(invoker.output_dir)) {
    assert(
        invoker.output_dir != target_out_dir,
        "The specified output directory must be different from the default target_out_dir")

    # The output name is the same as the original file by default.
    # Otherwise, it takes the output_name, and strips any extension.
    output_name = "${image_name}"
    if (defined(invoker.output_name)) {
      parts = string_split(invoker.output_name, ".")
      output_name = parts[0]
    }

    copy(labels.copy_zbi) {
      forward_variables_from(invoker,
                             [
                               "testonly",
                               "visibility",
                             ])
      sources = [ files.zbi ]
      outputs = [ "${invoker.output_dir}/${output_name}.zbi" ]
      deps = [ ":${labels.image_assembler}" ]
    }

    copy(labels.copy_zbi_manifest) {
      forward_variables_from(invoker,
                             [
                               "testonly",
                               "visibility",
                             ])
      sources = [ files.zbi_manifest ]
      outputs = [ "${invoker.output_dir}/${output_name}.zbi.json" ]
      deps = [ ":${labels.image_assembler}" ]
    }

    if (defined(invoker.zbi_signing_script)) {
      copy(labels.copy_zbi_signed) {
        forward_variables_from(invoker,
                               [
                                 "testonly",
                                 "visibility",
                               ])
        sources = [ files.zbi_signed ]
        outputs = [ "${invoker.output_dir}/${output_name}.zbi.signed" ]
        deps = [ ":${labels.image_assembler}" ]
      }
    }

    if (use_vbmeta) {
      copy(labels.copy_vbmeta) {
        forward_variables_from(invoker,
                               [
                                 "testonly",
                                 "visibility",
                               ])
        sources = [ files.vbmeta ]
        outputs = [ "${invoker.output_dir}/${output_name}.vbmeta" ]
        deps = [ ":${labels.image_assembler}" ]
      }
    }

    group(labels.copy_images) {
      forward_variables_from(invoker,
                             [
                               "testonly",
                               "visibility",
                             ])
      public_deps = [
        ":${labels.copy_zbi_manifest}",
        ":${labels.copy_zbi}",
      ]
      if (defined(invoker.zbi_signing_script)) {
        public_deps += [ ":${labels.copy_zbi_signed}" ]
      }
      if (use_vbmeta) {
        public_deps += [ ":${labels.copy_vbmeta}" ]
      }
    }
  }

  #######
  # Check the golden files.
  #

  if (defined(invoker.cmdline_goldens)) {
    verify_kernel_cmdline("${image_name}_cmdline_verify_files") {
      forward_variables_from(invoker,
                             [
                               "testonly",
                               "visibility",
                             ])
      zbi = files.zbi_final
      goldens = invoker.cmdline_goldens
      zbi_target = ":${labels.image_assembler}"
    }
  }
  if (defined(invoker.bootfs_goldens)) {
    verify_bootfs_filelist("${image_name}_bootfs_verify_files") {
      forward_variables_from(invoker,
                             [
                               "testonly",
                               "visibility",
                             ])
      zbi = files.zbi_final
      goldens = invoker.bootfs_goldens
      zbi_target = ":${labels.image_assembler}"
    }
  }
  if (defined(invoker.static_pkgs_goldens)) {
    verify_static_pkgs("${image_name}_static_pkgs_verify_files") {
      forward_variables_from(invoker,
                             [
                               "testonly",
                               "visibility",
                             ])
      zbi = files.zbi_final
      zbi_target = ":${labels.image_assembler}"
      blobfs_manifest = files.blobfs_manifest
      blobfs_manifest_target = ":${labels.image_assembler}"
      goldens = invoker.static_pkgs_goldens
    }
  }
  if (defined(invoker.route_sources_config)) {
    assert(
        image_name == "fuchsia",
        "assemble_system() { route_sources_config } is temporarily only available for the `fuchsia` image")
    verify_route_sources("${image_name}_route_sources_verify_files") {
      # TODO(fxbug.dev/85664): The testonly and the dependency on pm publish
      # are both temporary; they will be fixed after all collectors use
      # blobfs_manifest as the source of truth for loading blobs.
      #
      # Unlike other verifiers that rely on assembly metadata, the route_sources
      # verifier depends on pm publish and is integrated into the build via the
      # testonly //build/images:updates target.
      testonly = true
      forward_variables_from(invoker, [ "visibility" ])
      zbi = files.zbi_final
      zbi_target = ":${labels.image_assembler}"
      blobfs_manifest = files.blobfs_manifest
      blobfs_manifest_target = ":${labels.image_assembler}"
      config_path = invoker.route_sources_config
    }
  }

  group(target_name) {
    forward_variables_from(invoker,
                           [
                             "testonly",
                             "visibility",
                           ])

    # public_deps is used, so that the outputs of these dependencies are
    # available to external targets.
    public_deps = [
      ":${labels.assembly_inputs}",
      ":${labels.compare_image_assembly_configs}",
      ":${labels.image_assembler}",
      ":${labels.images_config}",
      ":${labels.partitions_config}",
    ]
    if (defined(invoker.output_dir)) {
      public_deps += [ ":${labels.copy_images}" ]
    }

    deps = []
    if (defined(invoker.cmdline_goldens)) {
      deps += [ ":${image_name}_cmdline_verify_files" ]
    }
    if (defined(invoker.bootfs_goldens)) {
      deps += [ ":${image_name}_bootfs_verify_files" ]
    }
    if (defined(invoker.static_pkgs_goldens)) {
      deps += [ ":${image_name}_static_pkgs_verify_files" ]
    }

    metadata = {
      # Assemblies have some defined packages, such as the base package.
      # This barrier prevents a Assembly#1 from including a depending Assembly#2
      # packages in the package sets (base, cache, system) for Assembly#1.
      assembly_package_barrier = []

      assembly_inputs_barrier = []
      assembly_inputs = [
        {
          path = rebase_path(files.assembly_inputs, root_build_dir)
        },
      ]
    }

    # Note: "${image_name}_route_sources_verify_files" dependency on pm-publish
    # would create a dependency cycle if it were included here. Instead, it is
    # integrated into the build via //build/images:updates.
  }
}