#
    variable loginUrn; # DEFAULT: pkgd_login

    if {$force || ![info exists loginUrn]} then {
      set loginUrn pkgd_login
    }

    #
    # NOTE: The URN, relative to the base URI, where the list of supported
    #       platforms for a single package may be found.
    #
    variable platformsUrn; # DEFAULT: pkgd_platforms

    if {$force || ![info exists platformsUrn]} then {
      set platformsUrn pkgd_platforms
    }

    #
    # NOTE: The URN, relative to the base URI, where a single package file
    #       may be found.
    #
    variable downloadUrn; # DEFAULT: pkgd_file

    if {$force || ![info exists downloadUrn]} then {

    variable loginUri; # DEFAULT: ${baseUri}/${loginUrn}?...

    if {$force || ![info exists loginUri]} then {
      set loginUri [appendArgs \
          {${baseUri}/${loginUrn}?} {[uriEscape name $userName]} & \
          {[uriEscape password $password]}]
    }

    #
    # NOTE: The URI where the list of supported platforms for a single
    #       package may be found.
    #
    variable platformsUri; # DEFAULT: ${baseUri}/${platformsUrn}?...

    if {$force || ![info exists platformsUri]} then {
      set platformsUri {${baseUri}/${platformsUrn}?download&name=trunk}
    }

    #
    # NOTE: The URI where a single package file may be found.  This file will
    #       belong to a specific version of one package.
    #
    variable downloadUri; # DEFAULT: ${baseUri}/${downloadUrn}?...

  proc isOpenPgpSignatureFileName { fileName nameOnly } {
    if {[string length $fileName] == 0} then {
      return false
    }

    set extension [file extension $fileName]

    if {$extension eq ".txt" || $extension eq ".asc"} then {
      if {!$nameOnly && [file exists $fileName]} then {
        return [::PackageRepository::isOpenPgpSignature \
            [readFile $fileName]]
      } else {
        return true
      }
    } else {

      set isClient true
    } else {
      error "unsupported language"
    }
  }

  #
  # NOTE: This procedure returns the name of the current platform.  There are
  #       no arguments.  An empty string will be returned if the name of the
  #       current platform cannot be determined for any reason.
  #
  proc getPlatform {} {
    global tcl_platform

    if {[info exists tcl_platform(platform)]} then {
      set platform $tcl_platform(platform)

      if {[info exists tcl_platform(machine)]} then {
        set machine $tcl_platform(machine)
      } else {
        set machine ""
      }

      switch -exact -- $platform {
        windows {
          switch -exact -- $machine {
            intel -
            ia32_on_win64 {
              return win32-x86
            }
            arm {
              return win32-arm
            }
            ia64 {
              return win64-ia64
            }
            amd64 {
              return win64-x64
            }
            arm64 {
              return win64-arm64
            }
          }
        }
      }
    }

    return ""
  }

  #
  # NOTE: This procedure verifies the platform specified by the caller.  The
  #       platform argument must be an empty string -OR- one of the literal
  #       strings "neutral", "win32-arm", "win32-x86", "win64-arm64",
  #       "win64-ia64", or "win64-x64".  An empty string means that the
  #       associated entity does not require a specific platform.  The
  #       varName argument is the name of a variable in the context of the
  #       immediate caller that will receive a modified platform name, if
  #       applicable.  Upon failure, a script error will be raised.  The
  #       return value is undefined.
  #
  proc verifyPlatform { platform varName } {
    #
    # NOTE: The platform name must be matched exactly and case-sensitively.
    #
    switch -exact -- $platform {
      "" {
        #
        # NOTE: The empty string means "attempt to automatically detect" the
        #       necessary platform based on context information that may be
        #       present in the context of the immediate caller.  If this is
        #       not possible, a script error will be raised.
        #
        upvar 1 language language

        if {![info exists language]} then {
          error "unable to detect language"
        }

        upvar 1 version version

        if {![info exists version]} then {
          error "unable to detect version"
        }

        upvar 1 packageName packageName

        if {[info exists packageName]} then {
          set localPackageName $packageName
        } else {
          set localPackageName ""
        }

        upvar 1 usePgp usePgp

        if {[info exists usePgp]} then {
          set localUsePgp $usePgp
        } else {
          set localUsePgp false
        }

        #
        # NOTE: Download the list of platforms associated with this package
        #       from the package repository server.  This may fail and raise
        #       a script error.
        #
        set platforms [downloadAllPlatforms \
            $language $version $localPackageName $localUsePgp]

        if {[string length $varName] > 0} then {
          upvar 1 $varName newPlatform
        }

        #
        # NOTE: Check the current platform and the neutral platform, in that
        #       order, to see if that platform is supported by the package
        #       being saught.  If so, return that platform.
        #
        foreach thisPlatform [list [getPlatform] neutral] {
          if {[lsearch -exact $platforms $thisPlatform] != -1} then {
            set newPlatform $thisPlatform
            return
          }
        }

        #
        # NOTE: If this point is reached, there are no supported platforms
        #       that are compatible with the current one for the specified
        #       package.
        #
        error "could not automatically detect platform"
      }
      neutral -
      win32-arm -
      win32-x86 -
      win64-arm64 -
      win64-ia64 -
      win64-x64 {

    } else {
      file delete -force -- $temporaryDirectory
    }

    return [expr {$compare > 0}]
  }

  #
  # NOTE: This procedure downloads a manitest from the package file server,
  #       writing its contents to the specified local file name.  It can also
  #       verify the OpenPGP signature.  The language argument must be one of
  #       the literal strings "eagle", "tcl", or "client".  The version
  #       argument must be one of the literal strings "8.4", "8.5", or "8.6"
  #       when the language is "tcl" -OR- the literal string "1.0" when the
  #       language is either "eagle" or "client".  The packageName argument
  #       is a directory name relative to the language and version-specific
  #       directory on the package file server and may be an empty string.
  #       The localFileName argument is the file name where the downloaded
  #       file should be written.  The usePgp argument should be non-zero
  #       when an OpenPGP signature needs to be verified for the downloaded
  #       file.
  #
  proc downloadAllPlatforms { language version packageName usePgp } {
    variable baseUri
    variable platformsUri
    variable platformsUrn
    variable temporaryRootDirectory

    set temporaryDirectory [file join \
        $temporaryRootDirectory [appendArgs \
        pkgd_plat_ [::PackageRepository::getUniqueSuffix]]]

    set localFileName [file join $temporaryDirectory manifest.txt]
    file mkdir [file dirname $localFileName]

    #
    # NOTE: First, build the final URI to download from the remote package
    #       repository.
    #
    set uri [subst $platformsUri]

    #
    # NOTE: Then, in one step, download the file from the package file
    #       server and write it to the specified local file.
    #
    writeFile $localFileName [getPackageFile $uri]

    #
    # NOTE: Is use of OpenPGP for signature verification enabled?  Also,
    #       did we just download an OpenPGP signature file?
    #
    if {$usePgp && [isOpenPgpSignatureFileName $localFileName true]} then {
      #
      # NOTE: Attempt to verify the OpenPGP signature.  If this fails,
      #       an error is raised.
      #
      if {![::PackageRepository::verifyOpenPgpSignature $localFileName]} then {
        error [appendArgs \
            "bad OpenPGP signature \"" $localFileName \"]
      }
    }

    #
    # NOTE: Initialize list of platforms to return.  This will be populated
    #       based on the platform directories available in the downloaded
    #       manfiest data.
    #
    set platforms [list]

    #
    # NOTE: Read the (OpenPGP verified) Fossil manifest data from the local
    #       file and split it into lines.
    #
    set data [readFile $localFileName]; set lines [split $data \n]

    foreach line $lines {
      if {[string range $line 0 1] eq "F "} then {
        set fileName [lindex [split $line " "] 1]

        if {[string match [file join \
            $language $version * $packageName *] $fileName]} then {
          set directory [lindex [file split $fileName] 2]

          if {[string length $directory] > 0} then {
            lappend platforms $directory
          }
        }
      }
    }

    return [lsort -unique $platforms]
  }

  #
  # NOTE: This procedure downloads a single file from the package file server,
  #       writing its contents to the specified local file name.  It can also
  #       verify the OpenPGP signatures.  When an OpenPGP signature file is
  #       downloaded, this procedure assumes the corresponding data file was
  #       already downloaded (i.e. since OpenPGP needs both to perform the
  #       signature checks).  The language argument must be one of the
  #       literal strings "eagle", "tcl", or "client".  The version argument
  #       must be one of the literal strings "8.4", "8.5", or "8.6" when the
  #       language is "tcl" -OR- the literal string "1.0" when the language
  #       is either "eagle" or "client".  The platform argument must be an
  #       empty string -OR- one of the literal strings "neutral", "win32-arm",
  #       "win32-x86", "win64-arm64", "win64-ia64", or "win64-x64".  An empty
  #       string means that the associated package does not require a specific
  #       platform.  The fileName argument is a file name relative to the
  #       language and version-specific directory on the package file server.
  #       The localFileName argument is the file name where the downloaded
  #       file should be written.  The usePgp argument should be non-zero when
  #       the OpenPGP signature file needs to be verified for the downloaded
  #       file.
  #
  proc downloadOneFile {
          language version platform fileName localFileName usePgp } {
    variable baseUri
    variable downloadUri
    variable downloadUrn