} else {
      return ""
    }
  }

  #
  # NOTE: This procedure, which is only used for native Tcl, generates a
  #       "root" package index file (i.e. "pkgIndex.tcl") suitable for
  #       use with native Tcl 8.4 (or higher).  It will recursively scan
  #       for all other native Tcl package index files that are within the
  #       configured persistent root directory and [source] them, thereby
  #       causing all packages located within them to become available.
  #       Since Eagle (by default) already performs recursive searches for
  #       its package index files, this procedure is not needed for Eagle.
  #       The return value is undefined.
  #
  proc maybeCreateRootTclPackageIndex {} {
    variable persistentRootDirectory

    verifyPersistentRootDirectory
    set persistentDirectory $persistentRootDirectory

    set fileName [file join $persistentDirectory pkgIndex.tcl]
    if {[file exists $fileName]} then {return ""}

          }

          return $::auto_path
        }
      }
    } elseif {$language eq "tcl"} then {
      if {[isEagle]} then {
        tcl eval [tcl primary] {
          if {![info exists ::auto_path]} then {
            return [list]
          }

          return $::auto_path
        }
      } else {

              [lsearch -exact $::auto_path {%directory%}] == -1} then {
            lappend ::auto_path {%directory%}
          }
        }]
      }
    } elseif {$language eq "tcl"} then {
      if {[isEagle]} then {
        tcl eval [tcl primary] [string map [list %directory% $directory] {
          if {![info exists ::auto_path] || \
              [lsearch -exact $::auto_path {%directory%}] == -1} then {
            lappend ::auto_path {%directory%}
          }
        }]
      } else {
        if {![info exists ::auto_path] || \

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

      #
      # NOTE: When the target language is native Tcl, try to create the
      #       "root" package index, if necessary.
      #
      if {$language eq "tcl"} then {
        maybeCreateRootTclPackageIndex
        set addPersistentDirectoryToAutoPath true
      }
    }

    #
    # NOTE: Sort the list of directories that downloaded files were written
    #       to, removing any duplicates in the process.
    #
    set downloadDirectories [lsort -unique $downloadDirectories]

    if {$useAutoPath} then {
      #
      # NOTE: The auto-path, for whatever language this package belongs to,
      #       needs to be modified.
      #
      if {$addPersistentDirectoryToAutoPath} then {
        #
        # NOTE: The downloaded package was persisted -AND- will be handled
        #       by the "root" package index; therefore, just make sure the
        #       package persistence root directory is in the auto-path and
        #       then return only that directory in the result.
        #
        maybeAddToAutoPath $language $persistentDirectory
        set downloadDirectories [list $persistentDirectory]
      } else {
        #

                    return [uplevel #0 $script(inner)]
                  }
                  Tcl {
                    #
                    # NOTE: The target language is Tcl; therefore, a bit of
                    #       special handling is needed here.
                    #
                    {%tclMustBeReady%}; return [tcl eval [tcl primary] [list \
                        uplevel #0 $script(inner)]]
                  }
                  default {
                    error "unsupported metadata language"
                  }
                }
              } finally {

            # NOTE: The target language is Tcl.  If the current language is
            #       also Tcl, simply evaluate the inner script block.  If
            #       the current language is Eagle, then try to use its [tcl]
            #       command in order to evaluate the inner script block in
            #       Tcl.
            #
            if {[isEagle]} then {
              tclMustBeReady; return [tcl eval [tcl primary] [list \
                  uplevel #0 $script(inner)]]
            } else {
              return [uplevel #0 $script(inner)]
            }
          }
          default {
            error "unsupported metadata language"

        eval tcl eval [list $interp] $args
      }
    }

    #
    # NOTE: This procedure attempts to load the TclDevKit remote debugger
    #       package into the specified Tcl interpreter.  By default, the
    #       "primary" Tcl interpreter will be used.  If the native Tcl
    #       interface is not ready or if the remote debugger package
    #       cannot be loaded, an error will be raised.
    #
    proc tcl_debugger_setup { {interp ""} } {
      if {![tcl ready]} then {error "native Tcl interface is not ready"}
      if {[string length $interp] == 0} then {set interp [tcl primary]}

      set directory [getTclDevKitDirectory]

      if {[string length $directory] == 0} then {
        error "the TclDevKit does not appear to be installed"
      }

      exec $applicationFileName $projectFileName &; after 5000
    }

    #
    # NOTE: This procedure attempts to initialize the TclDevKit remote
    #       debugger in the specified Tcl interpreter.  By default, the
    #       "primary" Tcl interpreter will be used.  If the native Tcl
    #       interface is not ready or if the remote debugger package
    #       cannot be initialized, an error will be raised.
    #
    proc tcl_debugger_init {
            {interp ""} {host 127.0.0.1} {port 2576} {cdata {}} } {
      if {![tcl ready]} then {error "native Tcl interface is not ready"}
      if {[string length $interp] == 0} then {set interp [tcl primary]}

      tcl_eval $interp [list debugger_init $host $port $cdata]
    }

    #
    # NOTE: This procedure attempts to evaluate a Tcl script under control
    #       of the TclDevKit remote debugger.  By default, the "primary" Tcl
    #       interpreter will be used.  If the native Tcl interface is not
    #       ready or if the remote debugger package fails to evaluate the
    #       Tcl script, an error will be raised.
    #
    proc tcl_debugger_eval { {interp ""} args } {
      if {![tcl ready]} then {error "native Tcl interface is not ready"}
      if {[string length $interp] == 0} then {set interp [tcl primary]}

      tcl_eval $interp debugger_eval $args
    }

    #
    # NOTE: This procedure attempts to tell the TclDevKit remote debugger
    #       to break the execution of the Tcl script in progress.
    #
    proc tcl_debugger_break { {interp ""} {str ""} } {
      if {![tcl ready]} then {error "native Tcl interface is not ready"}
      if {[string length $interp] == 0} then {set interp [tcl primary]}

      tcl_eval $interp [list debugger_break $str]
    }
  }

  if {![info exists tdk_path]} then {
    set tdk_path [file dirname [info script]]
  }

  package provide Eagle.TclDevKit.Integration \
    [expr {[isEagle] ? [info engine PatchLevel] : "1.0"}]
}