diff --git a/glide.lock b/glide.lock
index 592bbf0..da12611 100644
--- a/glide.lock
+++ b/glide.lock
@@ -10,7 +10,7 @@
 - name: github.com/Masterminds/vcs
   version: 7af28b64c5ec41b1558f5514fd938379822c237c
 - name: github.com/sdboyer/vsolver
-  version: 41ed3fc78392de9c882444546e038bf6724ca416
+  version: 4a1c3dd00ed484b3e87b4668b357e531b36baaa8
 - name: github.com/termie/go-shutil
   version: bcacb06fecaeec8dc42af03c87c6949f4a05c74c
 - name: gopkg.in/yaml.v2
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/locals.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/locals.go
new file mode 100644
index 0000000..3f73943
--- /dev/null
+++ b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/locals.go
@@ -0,0 +1,13 @@
+package main
+
+import (
+	"varied/otherpath"
+	"varied/namemismatch"
+	"varied/simple"
+)
+
+var (
+  _ = simple.S
+  _ = nm.V
+	_ = otherpath.O
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/m1p/a.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/m1p/a.go
new file mode 100644
index 0000000..181620f
--- /dev/null
+++ b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/m1p/a.go
@@ -0,0 +1,12 @@
+package m1p
+
+import (
+	"sort"
+
+	"github.com/sdboyer/vsolver"
+)
+
+var (
+	M = sort.Strings
+	_ = vsolver.Solve
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/m1p/b.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/m1p/b.go
new file mode 100644
index 0000000..83674b9
--- /dev/null
+++ b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/m1p/b.go
@@ -0,0 +1,11 @@
+package m1p
+
+import (
+	"os"
+	"sort"
+)
+
+var (
+	_ = sort.Strings
+	_ = os.PathSeparator
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/main.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/main.go
new file mode 100644
index 0000000..92c3dc1
--- /dev/null
+++ b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/main.go
@@ -0,0 +1,9 @@
+package main
+
+import (
+	"net/http"
+)
+
+var (
+	_ = http.Client
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/namemismatch/nm.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/namemismatch/nm.go
new file mode 100644
index 0000000..44a0abb
--- /dev/null
+++ b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/namemismatch/nm.go
@@ -0,0 +1,12 @@
+package nm
+
+import (
+	"os"
+
+	"github.com/Masterminds/semver"
+)
+
+var (
+	V = os.FileInfo
+	_ = semver.Constraint
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/otherpath/otherpath_test.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/otherpath/otherpath_test.go
new file mode 100644
index 0000000..73891e6
--- /dev/null
+++ b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/otherpath/otherpath_test.go
@@ -0,0 +1,5 @@
+package otherpath
+
+import "varied/m1p"
+
+var O = m1p.M
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/another/another.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/another/another.go
new file mode 100644
index 0000000..85368da
--- /dev/null
+++ b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/another/another.go
@@ -0,0 +1,7 @@
+package another
+
+import "hash"
+
+var (
+	H = hash.Hash
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/another/another_test.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/another/another_test.go
new file mode 100644
index 0000000..72a89ad
--- /dev/null
+++ b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/another/another_test.go
@@ -0,0 +1,7 @@
+package another
+
+import "encoding/binary"
+
+var (
+	_ = binary.PutVarint
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/another/locals.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/another/locals.go
new file mode 100644
index 0000000..d8d0316
--- /dev/null
+++ b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/another/locals.go
@@ -0,0 +1,5 @@
+package another
+
+import "varied/m1p"
+
+var _ = m1p.M
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/locals.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/locals.go
new file mode 100644
index 0000000..7717e80
--- /dev/null
+++ b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/locals.go
@@ -0,0 +1,7 @@
+package simple
+
+import "varied/simple/another"
+
+var (
+  _ = another.H
+)
diff --git a/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/simple.go b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/simple.go
new file mode 100644
index 0000000..ed4a9c0
--- /dev/null
+++ b/vendor/github.com/sdboyer/vsolver/_testdata/src/varied/simple/simple.go
@@ -0,0 +1,12 @@
+package simple
+
+import (
+	"go/parser"
+
+	"github.com/sdboyer/vsolver"
+)
+
+var (
+	_ = parser.ParseFile
+	S = vsolver.Prepare
+)
diff --git a/vendor/github.com/sdboyer/vsolver/analysis.go b/vendor/github.com/sdboyer/vsolver/analysis.go
index 4a463a8..b91d2a5 100644
--- a/vendor/github.com/sdboyer/vsolver/analysis.go
+++ b/vendor/github.com/sdboyer/vsolver/analysis.go
@@ -34,8 +34,7 @@
 	}
 }
 
-// listPackages lists info for all packages at or below the provided fileRoot,
-// optionally folding in data from test files as well.
+// listPackages lists info for all packages at or below the provided fileRoot.
 //
 // Directories without any valid Go files are excluded. Directories with
 // multiple packages are excluded.
@@ -44,13 +43,13 @@
 // the import path for each package. The obvious case is for something typical,
 // like:
 //
-// fileRoot = /home/user/go/src/github.com/foo/bar
-// importRoot = github.com/foo/bar
+//  fileRoot = "/home/user/go/src/github.com/foo/bar"
+//  importRoot = "github.com/foo/bar"
 //
-// Where the fileRoot and importRoot align. However, if you provide:
+// where the fileRoot and importRoot align. However, if you provide:
 //
-// fileRoot = /home/user/workspace/path/to/repo
-// importRoot = github.com/foo/bar
+//  fileRoot = "/home/user/workspace/path/to/repo"
+//  importRoot = "github.com/foo/bar"
 //
 // then the root package at path/to/repo will be ascribed import path
 // "github.com/foo/bar", and its subpackage "baz" will be
@@ -58,7 +57,7 @@
 //
 // A PackageTree is returned, which contains the ImportRoot and map of import path
 // to PackageOrErr - each path under the root that exists will have either a
-// Package, or an error describing why the package is not valid.
+// Package, or an error describing why the directory is not a valid package.
 func listPackages(fileRoot, importRoot string) (PackageTree, error) {
 	// Set up a build.ctx for parsing
 	ctx := build.Default
@@ -302,6 +301,11 @@
 	rt := strings.TrimSuffix(basedir, string(os.PathSeparator)) + string(os.PathSeparator)
 
 	for pkg, w := range workmap {
+		if len(w.ex) == 0 {
+			rm[strings.TrimPrefix(pkg, rt)] = nil
+			continue
+		}
+
 		edeps := make([]string, len(w.ex))
 		k := 0
 		for opkg := range w.ex {
@@ -309,6 +313,7 @@
 			k++
 		}
 
+		sort.Strings(edeps)
 		rm[strings.TrimPrefix(pkg, rt)] = edeps
 	}
 
@@ -544,19 +549,25 @@
 	return
 }
 
+// A PackageTree represents the results of recursively parsing a tree of
+// packages, starting at the ImportRoot. The results of parsing the files in the
+// directory identified by each import path - a Package or an error - are stored
+// in the Packages map, keyed by that import path.
 type PackageTree struct {
 	ImportRoot string
 	Packages   map[string]PackageOrErr
 }
 
+// PackageOrErr stores the results of attempting to parse a single directory for
+// Go source code.
 type PackageOrErr struct {
 	P   Package
 	Err error
 }
 
 // ExternalReach looks through a PackageTree and computes the list of external
-// dependencies (not under the tree at its designated import root) that are
-// imported by packages in the tree.
+// packages (not logical children of PackageTree.ImportRoot) that are
+// transitively imported by the internal packages in the tree.
 //
 // main indicates whether (true) or not (false) to include main packages in the
 // analysis. main packages should generally be excluded when analyzing the
@@ -564,9 +575,37 @@
 //
 // tests indicates whether (true) or not (false) to include imports from test
 // files in packages when computing the reach map.
-func (t PackageTree) ExternalReach(main, tests bool) (map[string][]string, error) {
+//
+// ignore is a map of import paths that, if encountered, should be excluded from
+// analysis. This exclusion applies to both internal and external packages. If
+// an external import path is ignored, it is simply omitted from the results.
+//
+// If an internal path is ignored, then it is excluded from all transitive
+// dependency chains and does not appear as a key in the final map. That is, if
+// you ignore A/foo, then the external package list for all internal packages
+// that import A/foo will not include external packages were only reachable
+// through A/foo.
+//
+// Visually, this means that, given a PackageTree with root A and packages at A,
+// A/foo, and A/bar, and the following import chain:
+//
+//  A -> A/foo -> A/bar -> B/baz
+//
+// If you ignore A/foo, then the returned map would be:
+//
+//  map[string][]string{
+// 	"A": []string{},
+// 	"A/bar": []string{"B/baz"},
+//  }
+//
+// It is safe to pass a nil map if there are no packages to ignore.
+func (t PackageTree) ExternalReach(main, tests bool, ignore map[string]bool) (map[string][]string, error) {
 	var someerrs bool
 
+	if ignore == nil {
+		ignore = make(map[string]bool)
+	}
+
 	// world's simplest adjacency list
 	workmap := make(map[string]wm)
 
@@ -581,6 +620,10 @@
 		if p.Name == "main" && !main {
 			continue
 		}
+		// Skip ignored packages
+		if ignore[ip] {
+			continue
+		}
 
 		imps = imps[:0]
 		imps = p.Imports
@@ -594,6 +637,10 @@
 		}
 
 		for _, imp := range imps {
+			if ignore[imp] {
+				continue
+			}
+
 			if !checkPrefixSlash(filepath.Clean(imp), t.ImportRoot) {
 				w.ex[imp] = struct{}{}
 			} else {
@@ -616,7 +663,7 @@
 	if len(workmap) == 0 {
 		if someerrs {
 			// TODO proper errs
-			return nil, fmt.Errorf("No packages without errors in %s", t.ImportRoot)
+			return nil, fmt.Errorf("no packages without errors in %s", t.ImportRoot)
 		}
 		return nil, nil
 	}
@@ -625,12 +672,37 @@
 	return wmToReach(workmap, "") // TODO this passes tests, but doesn't seem right
 }
 
-func (t PackageTree) ListExternalImports(main, tests bool) ([]string, error) {
+// ListExternalImports computes a sorted, deduplicated list of all the external
+// packages that are imported by all packages in the PackageTree.
+//
+// "External" is defined as anything not prefixed, after path cleaning, by the
+// PackageTree.ImportRoot. This includes stdlib.
+//
+// If an internal path is ignored, all of the external packages that it uniquely
+// imports are omitted. Note, however, that no internal transitivity checks are
+// made here - every non-ignored package in the tree is considered
+// independently. That means, given a PackageTree with root A and packages at A,
+// A/foo, and A/bar, and the following import chain:
+//
+//  A -> A/foo -> A/bar -> B/baz
+//
+// If you ignore A or A/foo, A/bar will still be visited, and B/baz will be
+// returned, because this method visits ALL packages in the tree, not only those reachable
+// from the root (or any other) packages. If your use case requires interrogating
+// external imports with respect to only specific package entry points, you need
+// ExternalReach() instead.
+//
+// It is safe to pass a nil map if there are no packages to ignore.
+func (t PackageTree) ListExternalImports(main, tests bool, ignore map[string]bool) ([]string, error) {
 	var someerrs bool
 	exm := make(map[string]struct{})
 
+	if ignore == nil {
+		ignore = make(map[string]bool)
+	}
+
 	var imps []string
-	for _, perr := range t.Packages {
+	for ip, perr := range t.Packages {
 		if perr.Err != nil {
 			someerrs = true
 			continue
@@ -641,6 +713,10 @@
 		if p.Name == "main" && !main {
 			continue
 		}
+		// Skip ignored packages
+		if ignore[ip] {
+			continue
+		}
 
 		imps = imps[:0]
 		imps = p.Imports
@@ -649,7 +725,7 @@
 		}
 
 		for _, imp := range imps {
-			if !checkPrefixSlash(filepath.Clean(imp), t.ImportRoot) {
+			if !checkPrefixSlash(filepath.Clean(imp), t.ImportRoot) && !ignore[imp] {
 				exm[imp] = struct{}{}
 			}
 		}
@@ -670,6 +746,7 @@
 		k++
 	}
 
+	sort.Strings(ex)
 	return ex, nil
 }
 
diff --git a/vendor/github.com/sdboyer/vsolver/analysis_test.go b/vendor/github.com/sdboyer/vsolver/analysis_test.go
index 5431df4..4abb537 100644
--- a/vendor/github.com/sdboyer/vsolver/analysis_test.go
+++ b/vendor/github.com/sdboyer/vsolver/analysis_test.go
@@ -5,6 +5,7 @@
 	"os"
 	"path/filepath"
 	"reflect"
+	"strings"
 	"testing"
 )
 
@@ -34,7 +35,7 @@
 				},
 			},
 			out: map[string][]string{
-				"foo": {},
+				"foo": nil,
 			},
 		},
 		"no external": {
@@ -49,8 +50,8 @@
 				},
 			},
 			out: map[string][]string{
-				"foo":     {},
-				"foo/bar": {},
+				"foo":     nil,
+				"foo/bar": nil,
 			},
 		},
 		"no external with subpkg": {
@@ -67,8 +68,8 @@
 				},
 			},
 			out: map[string][]string{
-				"foo":     {},
-				"foo/bar": {},
+				"foo":     nil,
+				"foo/bar": nil,
 			},
 		},
 		"simple base transitive": {
@@ -452,6 +453,90 @@
 				},
 			},
 		},
+		// This case mostly exists for the PackageTree methods, but it does
+		// cover a bit of range
+		"varied": {
+			fileRoot:   j("varied"),
+			importRoot: "varied",
+			out: PackageTree{
+				ImportRoot: "varied",
+				Packages: map[string]PackageOrErr{
+					"varied": PackageOrErr{
+						P: Package{
+							ImportPath:  "varied",
+							CommentPath: "",
+							Name:        "main",
+							Imports: []string{
+								"net/http",
+								"varied/namemismatch",
+								"varied/otherpath",
+								"varied/simple",
+							},
+						},
+					},
+					"varied/otherpath": PackageOrErr{
+						P: Package{
+							ImportPath:  "varied/otherpath",
+							CommentPath: "",
+							Name:        "otherpath",
+							Imports:     []string{},
+							TestImports: []string{
+								"varied/m1p",
+							},
+						},
+					},
+					"varied/simple": PackageOrErr{
+						P: Package{
+							ImportPath:  "varied/simple",
+							CommentPath: "",
+							Name:        "simple",
+							Imports: []string{
+								"github.com/sdboyer/vsolver",
+								"go/parser",
+								"varied/simple/another",
+							},
+						},
+					},
+					"varied/simple/another": PackageOrErr{
+						P: Package{
+							ImportPath:  "varied/simple/another",
+							CommentPath: "",
+							Name:        "another",
+							Imports: []string{
+								"hash",
+								"varied/m1p",
+							},
+							TestImports: []string{
+								"encoding/binary",
+							},
+						},
+					},
+					"varied/namemismatch": PackageOrErr{
+						P: Package{
+							ImportPath:  "varied/namemismatch",
+							CommentPath: "",
+							Name:        "nm",
+							Imports: []string{
+								"github.com/Masterminds/semver",
+								"os",
+							},
+						},
+					},
+					"varied/m1p": PackageOrErr{
+						P: Package{
+							ImportPath:  "varied/m1p",
+							CommentPath: "",
+							Name:        "m1p",
+							Imports: []string{
+								"github.com/sdboyer/vsolver",
+								"os",
+								"sort",
+							},
+						},
+					},
+				},
+			},
+		},
 	}
 
 	for name, fix := range table {
@@ -474,12 +559,405 @@
 
 		if fix.out.ImportRoot != "" && fix.out.Packages != nil {
 			if !reflect.DeepEqual(out, fix.out) {
-				t.Errorf("listPackages(%q): Did not receive expected package:\n\t(GOT): %s\n\t(WNT): %s", name, out, fix.out)
+				if fix.out.ImportRoot != out.ImportRoot {
+					t.Errorf("listPackages(%q): Expected ImportRoot %s, got %s", name, fix.out.ImportRoot, out.ImportRoot)
+				}
+
+				// overwrite the out one to see if we still have a real problem
+				out.ImportRoot = fix.out.ImportRoot
+
+				if !reflect.DeepEqual(out, fix.out) {
+					if len(fix.out.Packages) < 2 {
+						t.Errorf("listPackages(%q): Did not get expected PackageOrErrs:\n\t(GOT): %s\n\t(WNT): %s", name, out, fix.out)
+					} else {
+						seen := make(map[string]bool)
+						for path, perr := range fix.out.Packages {
+							seen[path] = true
+							if operr, exists := out.Packages[path]; !exists {
+								t.Errorf("listPackages(%q): Expected PackageOrErr for path %s was missing from output:\n\t%s", path, perr)
+							} else {
+								if !reflect.DeepEqual(perr, operr) {
+									t.Errorf("listPackages(%q): PkgOrErr for path %s was not as expected:\n\t(GOT): %s\n\t(WNT): %s", name, path, operr, perr)
+								}
+							}
+						}
+
+						for path, operr := range out.Packages {
+							if seen[path] {
+								continue
+							}
+
+							t.Errorf("listPackages(%q): Got PackageOrErr for path %s, but none was expected:\n\t%s", path, operr)
+						}
+					}
+				}
 			}
 		}
 	}
 }
 
+func TestListExternalImports(t *testing.T) {
+	// There's enough in the 'varied' test case to test most of what matters
+	vptree, err := listPackages(filepath.Join(getwd(t), "_testdata", "src", "varied"), "varied")
+	if err != nil {
+		t.Fatalf("listPackages failed on varied test case: %s", err)
+	}
+
+	var expect []string
+	var name string
+	var ignore map[string]bool
+	var main, tests bool
+
+	validate := func() {
+		result, err := vptree.ListExternalImports(main, tests, ignore)
+		if err != nil {
+			t.Errorf("%q case returned err: %s", name, err)
+		}
+		if !reflect.DeepEqual(expect, result) {
+			t.Errorf("Wrong imports in %q case:\n\t(GOT): %s\n\t(WNT): %s", name, result, expect)
+		}
+	}
+
+	all := []string{
+		"encoding/binary",
+		"github.com/Masterminds/semver",
+		"github.com/sdboyer/vsolver",
+		"go/parser",
+		"hash",
+		"net/http",
+		"os",
+		"sort",
+	}
+
+	// helper to rewrite expect, except for a couple packages
+	//
+	// this makes it easier to see what we're taking out on each test
+	except := func(not ...string) {
+		expect = make([]string, len(all)-len(not))
+
+		drop := make(map[string]bool)
+		for _, npath := range not {
+			drop[npath] = true
+		}
+
+		k := 0
+		for _, path := range all {
+			if !drop[path] {
+				expect[k] = path
+				k++
+			}
+		}
+	}
+
+	// everything on
+	name = "simple"
+	except()
+	main, tests = true, true
+	validate()
+
+	// Now without tests, which should just cut one
+	name = "no tests"
+	tests = false
+	except("encoding/binary")
+	validate()
+
+	// Now skip main, which still just cuts out one
+	name = "no main"
+	main, tests = false, true
+	except("net/http")
+	validate()
+
+	// No test and no main, which should be additive
+	name = "no test, no main"
+	main, tests = false, false
+	except("net/http", "encoding/binary")
+	validate()
+
+	// now, the ignore tests. turn main and tests back on
+	main, tests = true, true
+
+	// start with non-matching
+	name = "non-matching ignore"
+	ignore = map[string]bool{
+		"nomatch": true,
+	}
+	except()
+	validate()
+
+	// should have the same effect as ignoring main
+	name = "ignore the root"
+	ignore = map[string]bool{
+		"varied": true,
+	}
+	except("net/http")
+	validate()
+
+	// now drop a more interesting one
+	name = "ignore simple"
+	ignore = map[string]bool{
+		"varied/simple": true,
+	}
+	// we get github.com/sdboyer/vsolver from m1p, too, so it should still be
+	// there
+	except("go/parser")
+	validate()
+
+	// now drop two
+	name = "ignore simple and namemismatch"
+	ignore = map[string]bool{
+		"varied/simple":       true,
+		"varied/namemismatch": true,
+	}
+	except("go/parser", "github.com/Masterminds/semver")
+	validate()
+
+	// make sure tests and main play nice with ignore
+	name = "ignore simple and namemismatch, and no tests"
+	tests = false
+	except("go/parser", "github.com/Masterminds/semver", "encoding/binary")
+	validate()
+	name = "ignore simple and namemismatch, and no main"
+	main, tests = false, true
+	except("go/parser", "github.com/Masterminds/semver", "net/http")
+	validate()
+	name = "ignore simple and namemismatch, and no main or tests"
+	main, tests = false, false
+	except("go/parser", "github.com/Masterminds/semver", "net/http", "encoding/binary")
+	validate()
+
+	main, tests = true, true
+
+	// ignore two that should knock out vsolver
+	name = "ignore both importers"
+	ignore = map[string]bool{
+		"varied/simple": true,
+		"varied/m1p":    true,
+	}
+	except("sort", "github.com/sdboyer/vsolver", "go/parser")
+	validate()
+
+	// finally, directly ignore some external packages
+	name = "ignore external"
+	ignore = map[string]bool{
+		"github.com/sdboyer/vsolver": true,
+		"go/parser":                  true,
+		"sort":                       true,
+	}
+	except("sort", "github.com/sdboyer/vsolver", "go/parser")
+	validate()
+}
+
+func TestExternalReach(t *testing.T) {
+	// There's enough in the 'varied' test case to test most of what matters
+	vptree, err := listPackages(filepath.Join(getwd(t), "_testdata", "src", "varied"), "varied")
+	if err != nil {
+		t.Fatalf("listPackages failed on varied test case: %s", err)
+	}
+
+	// Set up vars for validate closure
+	var expect map[string][]string
+	var name string
+	var main, tests bool
+	var ignore map[string]bool
+
+	validate := func() {
+		result, err := vptree.ExternalReach(main, tests, ignore)
+		if err != nil {
+			t.Errorf("ver(%q): case returned err: %s", name, err)
+		}
+		if !reflect.DeepEqual(expect, result) {
+			seen := make(map[string]bool)
+			for ip, epkgs := range expect {
+				seen[ip] = true
+				if pkgs, exists := result[ip]; !exists {
+					t.Errorf("ver(%q): expected import path %s was not present in result", name, ip)
+				} else {
+					if !reflect.DeepEqual(pkgs, epkgs) {
+						t.Errorf("ver(%q): did not get expected package set for import path %s:\n\t(GOT): %s\n\t(WNT): %s", name, ip, pkgs, epkgs)
+					}
+				}
+			}
+
+			for ip, pkgs := range result {
+				if seen[ip] {
+					continue
+				}
+				t.Errorf("ver(%q): Got packages for import path %s, but none were expected:\n\t%s", name, ip, pkgs)
+			}
+		}
+	}
+
+	all := map[string][]string{
+		"varied":                {"encoding/binary", "github.com/Masterminds/semver", "github.com/sdboyer/vsolver", "go/parser", "hash", "net/http", "os", "sort"},
+		"varied/m1p":            {"github.com/sdboyer/vsolver", "os", "sort"},
+		"varied/namemismatch":   {"github.com/Masterminds/semver", "os"},
+		"varied/otherpath":      {"github.com/sdboyer/vsolver", "os", "sort"},
+		"varied/simple":         {"encoding/binary", "github.com/sdboyer/vsolver", "go/parser", "hash", "os", "sort"},
+		"varied/simple/another": {"encoding/binary", "github.com/sdboyer/vsolver", "hash", "os", "sort"},
+	}
+	// build a map to validate the exception inputs. do this because shit is
+	// hard enough to keep track of that it's preferable not to have silent
+	// success if a typo creeps in and we're trying to except an import that
+	// isn't in a pkg in the first place
+	valid := make(map[string]map[string]bool)
+	for ip, expkgs := range all {
+		m := make(map[string]bool)
+		for _, pkg := range expkgs {
+			m[pkg] = true
+		}
+		valid[ip] = m
+	}
+
+	// helper to compose expect, excepting specific packages
+	//
+	// this makes it easier to see what we're taking out on each test
+	except := func(pkgig ...string) {
+		// reinit expect with everything from all
+		expect = make(map[string][]string)
+		for ip, expkgs := range all {
+			sl := make([]string, len(expkgs))
+			copy(sl, expkgs)
+			expect[ip] = sl
+		}
+
+		// now build the dropmap
+		drop := make(map[string]map[string]bool)
+		for _, igstr := range pkgig {
+			// split on space; first elem is import path to pkg, the rest are
+			// the imports to drop.
+			not := strings.Split(igstr, " ")
+			var ip string
+			ip, not = not[0], not[1:]
+			if _, exists := valid[ip]; !exists {
+				t.Fatalf("%s is not a package name we're working with, doofus", ip)
+			}
+
+			// if only a single elem was passed, though, drop the whole thing
+			if len(not) == 0 {
+				delete(expect, ip)
+				continue
+			}
+
+			m := make(map[string]bool)
+			for _, imp := range not {
+				if !valid[ip][imp] {
+					t.Fatalf("%s is not a reachable import of %s, even in the all case", imp, ip)
+				}
+				m[imp] = true
+			}
+
+			drop[ip] = m
+		}
+
+		for ip, pkgs := range expect {
+			var npkgs []string
+			for _, imp := range pkgs {
+				if !drop[ip][imp] {
+					npkgs = append(npkgs, imp)
+				}
+			}
+
+			expect[ip] = npkgs
+		}
+	}
+
+	// first, validate all
+	name = "all"
+	main, tests = true, true
+	except()
+	validate()
+
+	// turn off main pkgs, which necessarily doesn't affect anything else
+	name = "no main"
+	main = false
+	except("varied")
+	validate()
+
+	// ignoring the "varied" pkg has same effect as disabling main pkgs
+	name = "ignore root"
+	ignore = map[string]bool{
+		"varied": true,
+	}
+	main = true
+	validate()
+
+	// when we drop tests, varied/otherpath loses its link to varied/m1p and
+	// varied/simple/another loses its test import, which has a fairly big
+	// cascade
+	name = "no tests"
+	tests = false
+	ignore = nil
+	except(
+		"varied encoding/binary",
+		"varied/simple encoding/binary",
+		"varied/simple/another encoding/binary",
+		"varied/otherpath github.com/sdboyer/vsolver os sort",
+	)
+
+	// almost the same as previous, but varied just goes away completely
+	name = "no main or tests"
+	main = false
+	except(
+		"varied",
+		"varied/simple encoding/binary",
+		"varied/simple/another encoding/binary",
+		"varied/otherpath github.com/sdboyer/vsolver os sort",
+	)
+	validate()
+
+	// focus on ignores now, so reset main and tests
+	main, tests = true, true
+
+	// now, the fun stuff. punch a hole in the middle by cutting out
+	// varied/simple
+	name = "ignore varied/simple"
+	ignore = map[string]bool{
+		"varied/simple": true,
+	}
+	except(
+		// root pkg loses on everything in varied/simple/another
+		"varied hash encoding/binary go/parser",
+		"varied/simple",
+	)
+	validate()
+
+	// widen the hole by excluding otherpath
+	name = "ignore varied/{otherpath,simple}"
+	ignore = map[string]bool{
+		"varied/otherpath": true,
+		"varied/simple":    true,
+	}
+	except(
+		// root pkg loses on everything in varied/simple/another and varied/m1p
+		"varied hash encoding/binary go/parser github.com/sdboyer/vsolver sort",
+		"varied/otherpath",
+		"varied/simple",
+	)
+	validate()
+
+	// remove namemismatch, though we're mostly beating a dead horse now
+	name = "ignore varied/{otherpath,simple,namemismatch}"
+	ignore["varied/namemismatch"] = true
+	except(
+		// root pkg loses on everything in varied/simple/another and varied/m1p
+		"varied hash encoding/binary go/parser github.com/sdboyer/vsolver sort os github.com/Masterminds/semver",
+		"varied/otherpath",
+		"varied/simple",
+		"varied/namemismatch",
+	)
+	validate()
+
+}
+
+var _ = map[string][]string{
+	"varied":                {"encoding/binary", "github.com/Masterminds/semver", "github.com/sdboyer/vsolver", "go/parser", "hash", "net/http", "os", "sort"},
+	"varied/m1p":            {"github.com/sdboyer/vsolver", "os", "sort"},
+	"varied/namemismatch":   {"github.com/Masterminds/semver", "os"},
+	"varied/otherpath":      {"github.com/sdboyer/vsolver", "os", "sort"},
+	"varied/simple":         {"encoding/binary", "github.com/sdboyer/vsolver", "go/parser", "hash", "os", "sort"},
+	"varied/simple/another": {"encoding/binary", "github.com/sdboyer/vsolver", "hash", "os", "sort"},
+}
+
 func getwd(t *testing.T) string {
 	cwd, err := os.Getwd()
 	if err != nil {
diff --git a/vendor/github.com/sdboyer/vsolver/bridge.go b/vendor/github.com/sdboyer/vsolver/bridge.go
index 7cf67ec..7f57f15 100644
--- a/vendor/github.com/sdboyer/vsolver/bridge.go
+++ b/vendor/github.com/sdboyer/vsolver/bridge.go
@@ -9,7 +9,7 @@
 // sourceBridges provide an adapter to SourceManagers that tailor operations
 // for a single solve run.
 type sourceBridge interface {
-	getProjectInfo(pa ProjectAtom) (ProjectInfo, error)
+	getProjectInfo(pa atom) (Manifest, Lock, error)
 	listVersions(id ProjectIdentifier) ([]Version, error)
 	pairRevision(id ProjectIdentifier, r Revision) []Version
 	pairVersion(id ProjectIdentifier, v UnpairedVersion) PairedVersion
@@ -19,21 +19,11 @@
 	matchesAny(id ProjectIdentifier, c1, c2 Constraint) bool
 	intersect(id ProjectIdentifier, c1, c2 Constraint) Constraint
 	listPackages(id ProjectIdentifier, v Version) (PackageTree, error)
-	computeRootReach(path string) ([]string, error)
+	computeRootReach() ([]string, error)
 	verifyRoot(path string) error
 	deduceRemoteRepo(path string) (*remoteRepo, error)
 }
 
-func newBridge(name ProjectName, root string, sm SourceManager, downgrade bool) sourceBridge {
-	return &bridge{
-		sm:       sm,
-		sortdown: downgrade,
-		name:     name,
-		root:     root,
-		vlists:   make(map[ProjectName][]Version),
-	}
-}
-
 // bridge is an adapter around a proper SourceManager. It provides localized
 // caching that's tailored to the requirements of a particular solve run.
 //
@@ -69,6 +59,9 @@
 		err   error
 	}
 
+	// A map of packages to ignore.
+	ignore map[string]bool
+
 	// Map of project root name to their available version list. This cache is
 	// layered on top of the proper SourceManager's cache; the only difference
 	// is that this keeps the versions sorted in the direction required by the
@@ -76,8 +69,8 @@
 	vlists map[ProjectName][]Version
 }
 
-func (b *bridge) getProjectInfo(pa ProjectAtom) (ProjectInfo, error) {
-	return b.sm.GetProjectInfo(ProjectName(pa.Ident.netName()), pa.Version)
+func (b *bridge) getProjectInfo(pa atom) (Manifest, Lock, error) {
+	return b.sm.GetProjectInfo(ProjectName(pa.id.netName()), pa.v)
 }
 
 func (b *bridge) key(id ProjectIdentifier) ProjectName {
@@ -355,13 +348,22 @@
 // analysis be in any permanent cache, and we want to read directly from our
 // potentially messy root project source location on disk. Together, this means
 // that we can't ask the real SourceManager to do it.
-func (b *bridge) computeRootReach(path string) ([]string, error) {
+func (b *bridge) computeRootReach() ([]string, error) {
 	// TODO i now cannot remember the reasons why i thought being less stringent
-	// in the analysis was OK. so, for now, we just compute list of
-	// externally-touched packages.
+	// in the analysis was OK. so, for now, we just compute a bog-standard list
+	// of externally-touched packages, including mains and test.
+	ptree, err := b.listRootPackages()
+	if err != nil {
+		return nil, err
+	}
 
+	return ptree.ListExternalImports(true, true, b.ignore)
+}
+
+func (b *bridge) listRootPackages() (PackageTree, error) {
 	if b.crp == nil {
 		ptree, err := listPackages(b.root, string(b.name))
+
 		b.crp = &struct {
 			ptree PackageTree
 			err   error
@@ -371,10 +373,10 @@
 		}
 	}
 	if b.crp.err != nil {
-		return nil, b.crp.err
+		return PackageTree{}, b.crp.err
 	}
 
-	return b.crp.ptree.ListExternalImports(true, true)
+	return b.crp.ptree, nil
 }
 
 // listPackages lists all the packages contained within the given project at a
@@ -383,23 +385,13 @@
 // The root project is handled separately, as the source manager isn't
 // responsible for that code.
 func (b *bridge) listPackages(id ProjectIdentifier, v Version) (PackageTree, error) {
-	if id.LocalName != b.name {
-		// FIXME if we're aliasing here, the returned PackageTree will have
-		// unaliased import paths, which is super not correct
-		return b.sm.ListPackages(b.key(id), v)
-	}
-	if b.crp == nil {
-		ptree, err := listPackages(b.root, string(b.name))
-		b.crp = &struct {
-			ptree PackageTree
-			err   error
-		}{
-			ptree: ptree,
-			err:   err,
-		}
+	if id.LocalName == b.name {
+		return b.listRootPackages()
 	}
 
-	return b.crp.ptree, b.crp.err
+	// FIXME if we're aliasing here, the returned PackageTree will have
+	// unaliased import paths, which is super not correct
+	return b.sm.ListPackages(b.key(id), v)
 }
 
 // verifyRoot ensures that the provided path to the project root is in good
@@ -407,9 +399,9 @@
 // run.
 func (b *bridge) verifyRoot(path string) error {
 	if fi, err := os.Stat(path); err != nil {
-		return BadOptsFailure(fmt.Sprintf("Could not read project root (%s): %s", path, err))
+		return badOptsFailure(fmt.Sprintf("Could not read project root (%s): %s", path, err))
 	} else if !fi.IsDir() {
-		return BadOptsFailure(fmt.Sprintf("Project root (%s) is a file, not a directory.", path))
+		return badOptsFailure(fmt.Sprintf("Project root (%s) is a file, not a directory.", path))
 	}
 
 	return nil
diff --git a/vendor/github.com/sdboyer/vsolver/errors.go b/vendor/github.com/sdboyer/vsolver/errors.go
index 58e0952..18f50fb 100644
--- a/vendor/github.com/sdboyer/vsolver/errors.go
+++ b/vendor/github.com/sdboyer/vsolver/errors.go
@@ -17,11 +17,6 @@
 	cannotResolve
 )
 
-type SolveError interface {
-	error
-	Children() []error
-}
-
 type traceError interface {
 	traceString() string
 }
@@ -77,35 +72,35 @@
 }
 
 type disjointConstraintFailure struct {
-	goal      Dependency
-	failsib   []Dependency
-	nofailsib []Dependency
+	goal      dependency
+	failsib   []dependency
+	nofailsib []dependency
 	c         Constraint
 }
 
 func (e *disjointConstraintFailure) Error() string {
 	if len(e.failsib) == 1 {
 		str := "Could not introduce %s at %s, as it has a dependency on %s with constraint %s, which has no overlap with existing constraint %s from %s at %s"
-		return fmt.Sprintf(str, e.goal.Depender.Ident.errString(), e.goal.Depender.Version, e.goal.Dep.Ident.errString(), e.goal.Dep.Constraint.String(), e.failsib[0].Dep.Constraint.String(), e.failsib[0].Depender.Ident.errString(), e.failsib[0].Depender.Version)
+		return fmt.Sprintf(str, e.goal.depender.id.errString(), e.goal.depender.v, e.goal.dep.Ident.errString(), e.goal.dep.Constraint.String(), e.failsib[0].dep.Constraint.String(), e.failsib[0].depender.id.errString(), e.failsib[0].depender.v)
 	}
 
 	var buf bytes.Buffer
 
-	var sibs []Dependency
+	var sibs []dependency
 	if len(e.failsib) > 1 {
 		sibs = e.failsib
 
 		str := "Could not introduce %s at %s, as it has a dependency on %s with constraint %s, which has no overlap with the following existing constraints:\n"
-		fmt.Fprintf(&buf, str, e.goal.Depender.Ident.errString(), e.goal.Depender.Version, e.goal.Dep.Ident.errString(), e.goal.Dep.Constraint.String())
+		fmt.Fprintf(&buf, str, e.goal.depender.id.errString(), e.goal.depender.v, e.goal.dep.Ident.errString(), e.goal.dep.Constraint.String())
 	} else {
 		sibs = e.nofailsib
 
 		str := "Could not introduce %s at %s, as it has a dependency on %s with constraint %s, which does not overlap with the intersection of existing constraints from other currently selected packages:\n"
-		fmt.Fprintf(&buf, str, e.goal.Depender.Ident.errString(), e.goal.Depender.Version, e.goal.Dep.Ident.errString(), e.goal.Dep.Constraint.String())
+		fmt.Fprintf(&buf, str, e.goal.depender.id.errString(), e.goal.depender.v, e.goal.dep.Ident.errString(), e.goal.dep.Constraint.String())
 	}
 
 	for _, c := range sibs {
-		fmt.Fprintf(&buf, "\t%s from %s at %s\n", c.Dep.Constraint.String(), c.Depender.Ident.errString(), c.Depender.Version)
+		fmt.Fprintf(&buf, "\t%s from %s at %s\n", c.dep.Constraint.String(), c.depender.id.errString(), c.depender.v)
 	}
 
 	return buf.String()
@@ -113,12 +108,12 @@
 
 func (e *disjointConstraintFailure) traceString() string {
 	var buf bytes.Buffer
-	fmt.Fprintf(&buf, "constraint %s on %s disjoint with other dependers:\n", e.goal.Dep.Constraint.String(), e.goal.Dep.Ident.errString())
+	fmt.Fprintf(&buf, "constraint %s on %s disjoint with other dependers:\n", e.goal.dep.Constraint.String(), e.goal.dep.Ident.errString())
 	for _, f := range e.failsib {
-		fmt.Fprintf(&buf, "%s from %s at %s (no overlap)\n", f.Dep.Constraint.String(), f.Depender.Ident.LocalName, f.Depender.Version)
+		fmt.Fprintf(&buf, "%s from %s at %s (no overlap)\n", f.dep.Constraint.String(), f.depender.id.LocalName, f.depender.v)
 	}
 	for _, f := range e.nofailsib {
-		fmt.Fprintf(&buf, "%s from %s at %s (some overlap)\n", f.Dep.Constraint.String(), f.Depender.Ident.LocalName, f.Depender.Version)
+		fmt.Fprintf(&buf, "%s from %s at %s (some overlap)\n", f.dep.Constraint.String(), f.depender.id.LocalName, f.depender.v)
 	}
 
 	return buf.String()
@@ -128,39 +123,39 @@
 // constraints does not admit the currently-selected version of the target
 // project.
 type constraintNotAllowedFailure struct {
-	goal Dependency
+	goal dependency
 	v    Version
 }
 
 func (e *constraintNotAllowedFailure) Error() string {
 	str := "Could not introduce %s at %s, as it has a dependency on %s with constraint %s, which does not allow the currently selected version of %s"
-	return fmt.Sprintf(str, e.goal.Depender.Ident.errString(), e.goal.Depender.Version, e.goal.Dep.Ident.errString(), e.goal.Dep.Constraint, e.v)
+	return fmt.Sprintf(str, e.goal.depender.id.errString(), e.goal.depender.v, e.goal.dep.Ident.errString(), e.goal.dep.Constraint, e.v)
 }
 
 func (e *constraintNotAllowedFailure) traceString() string {
 	str := "%s at %s depends on %s with %s, but that's already selected at %s"
-	return fmt.Sprintf(str, e.goal.Depender.Ident.LocalName, e.goal.Depender.Version, e.goal.Dep.Ident.LocalName, e.goal.Dep.Constraint, e.v)
+	return fmt.Sprintf(str, e.goal.depender.id.LocalName, e.goal.depender.v, e.goal.dep.Ident.LocalName, e.goal.dep.Constraint, e.v)
 }
 
 type versionNotAllowedFailure struct {
-	goal       ProjectAtom
-	failparent []Dependency
+	goal       atom
+	failparent []dependency
 	c          Constraint
 }
 
 func (e *versionNotAllowedFailure) Error() string {
 	if len(e.failparent) == 1 {
 		str := "Could not introduce %s at %s, as it is not allowed by constraint %s from project %s."
-		return fmt.Sprintf(str, e.goal.Ident.errString(), e.goal.Version, e.failparent[0].Dep.Constraint.String(), e.failparent[0].Depender.Ident.errString())
+		return fmt.Sprintf(str, e.goal.id.errString(), e.goal.v, e.failparent[0].dep.Constraint.String(), e.failparent[0].depender.id.errString())
 	}
 
 	var buf bytes.Buffer
 
 	str := "Could not introduce %s at %s, as it is not allowed by constraints from the following projects:\n"
-	fmt.Fprintf(&buf, str, e.goal.Ident.errString(), e.goal.Version)
+	fmt.Fprintf(&buf, str, e.goal.id.errString(), e.goal.v)
 
 	for _, f := range e.failparent {
-		fmt.Fprintf(&buf, "\t%s from %s at %s\n", f.Dep.Constraint.String(), f.Depender.Ident.errString(), f.Depender.Version)
+		fmt.Fprintf(&buf, "\t%s from %s at %s\n", f.dep.Constraint.String(), f.depender.id.errString(), f.depender.v)
 	}
 
 	return buf.String()
@@ -169,9 +164,9 @@
 func (e *versionNotAllowedFailure) traceString() string {
 	var buf bytes.Buffer
 
-	fmt.Fprintf(&buf, "%s at %s not allowed by constraint %s:\n", e.goal.Ident.LocalName, e.goal.Version, e.c.String())
+	fmt.Fprintf(&buf, "%s at %s not allowed by constraint %s:\n", e.goal.id.LocalName, e.goal.v, e.c.String())
 	for _, f := range e.failparent {
-		fmt.Fprintf(&buf, "  %s from %s at %s\n", f.Dep.Constraint.String(), f.Depender.Ident.LocalName, f.Depender.Version)
+		fmt.Fprintf(&buf, "  %s from %s at %s\n", f.dep.Constraint.String(), f.depender.id.LocalName, f.depender.v)
 	}
 
 	return buf.String()
@@ -186,36 +181,36 @@
 	return fmt.Sprintf(e.prob, e.goal)
 }
 
-type BadOptsFailure string
+type badOptsFailure string
 
-func (e BadOptsFailure) Error() string {
+func (e badOptsFailure) Error() string {
 	return string(e)
 }
 
 type sourceMismatchFailure struct {
 	shared            ProjectName
-	sel               []Dependency
+	sel               []dependency
 	current, mismatch string
-	prob              ProjectAtom
+	prob              atom
 }
 
 func (e *sourceMismatchFailure) Error() string {
 	var cur []string
 	for _, c := range e.sel {
-		cur = append(cur, string(c.Depender.Ident.LocalName))
+		cur = append(cur, string(c.depender.id.LocalName))
 	}
 
 	str := "Could not introduce %s at %s, as it depends on %s from %s, but %s is already marked as coming from %s by %s"
-	return fmt.Sprintf(str, e.prob.Ident.errString(), e.prob.Version, e.shared, e.mismatch, e.shared, e.current, strings.Join(cur, ", "))
+	return fmt.Sprintf(str, e.prob.id.errString(), e.prob.v, e.shared, e.mismatch, e.shared, e.current, strings.Join(cur, ", "))
 }
 
 func (e *sourceMismatchFailure) traceString() string {
 	var buf bytes.Buffer
 	fmt.Fprintf(&buf, "disagreement on network addr for %s:\n", e.shared)
 
-	fmt.Fprintf(&buf, "  %s from %s\n", e.mismatch, e.prob.Ident.errString())
+	fmt.Fprintf(&buf, "  %s from %s\n", e.mismatch, e.prob.id.errString())
 	for _, dep := range e.sel {
-		fmt.Fprintf(&buf, "  %s from %s\n", e.current, dep.Depender.Ident.errString())
+		fmt.Fprintf(&buf, "  %s from %s\n", e.current, dep.depender.id.errString())
 	}
 
 	return buf.String()
@@ -223,10 +218,10 @@
 
 type errDeppers struct {
 	err     error
-	deppers []ProjectAtom
+	deppers []atom
 }
 type checkeeHasProblemPackagesFailure struct {
-	goal    ProjectAtom
+	goal    atom
 	failpkg map[string]errDeppers
 }
 
@@ -238,8 +233,8 @@
 		indent = "\t"
 		fmt.Fprintf(
 			&buf, "Could not introduce %s at %s due to multiple problematic subpackages:\n",
-			e.goal.Ident.errString(),
-			e.goal.Version,
+			e.goal.id.errString(),
+			e.goal.v,
 		)
 	}
 
@@ -254,8 +249,8 @@
 		if len(e.failpkg) == 1 {
 			fmt.Fprintf(
 				&buf, "Could not introduce %s at %s, as its subpackage %s %s.",
-				e.goal.Ident.errString(),
-				e.goal.Version,
+				e.goal.id.errString(),
+				e.goal.v,
 				pkg,
 				cause,
 			)
@@ -266,13 +261,13 @@
 		if len(errdep.deppers) == 1 {
 			fmt.Fprintf(
 				&buf, " (Package is required by %s at %s.)",
-				errdep.deppers[0].Ident.errString(),
-				errdep.deppers[0].Version,
+				errdep.deppers[0].id.errString(),
+				errdep.deppers[0].v,
 			)
 		} else {
 			fmt.Fprintf(&buf, " Package is required by:")
 			for _, pa := range errdep.deppers {
-				fmt.Fprintf(&buf, "\n%s\t%s at %s", indent, pa.Ident.errString(), pa.Version)
+				fmt.Fprintf(&buf, "\n%s\t%s at %s", indent, pa.id.errString(), pa.v)
 			}
 		}
 	}
@@ -283,7 +278,7 @@
 func (e *checkeeHasProblemPackagesFailure) traceString() string {
 	var buf bytes.Buffer
 
-	fmt.Fprintf(&buf, "%s at %s has problem subpkg(s):\n", e.goal.Ident.LocalName, e.goal.Version)
+	fmt.Fprintf(&buf, "%s at %s has problem subpkg(s):\n", e.goal.id.LocalName, e.goal.v)
 	for pkg, errdep := range e.failpkg {
 		if errdep.err == nil {
 			fmt.Fprintf(&buf, "\t%s is missing; ", pkg)
@@ -294,13 +289,13 @@
 		if len(errdep.deppers) == 1 {
 			fmt.Fprintf(
 				&buf, "required by %s at %s.",
-				errdep.deppers[0].Ident.errString(),
-				errdep.deppers[0].Version,
+				errdep.deppers[0].id.errString(),
+				errdep.deppers[0].v,
 			)
 		} else {
 			fmt.Fprintf(&buf, " required by:")
 			for _, pa := range errdep.deppers {
-				fmt.Fprintf(&buf, "\n\t\t%s at %s", pa.Ident.errString(), pa.Version)
+				fmt.Fprintf(&buf, "\n\t\t%s at %s", pa.id.errString(), pa.v)
 			}
 		}
 	}
@@ -309,7 +304,7 @@
 }
 
 type depHasProblemPackagesFailure struct {
-	goal Dependency
+	goal dependency
 	v    Version
 	pl   []string
 	prob map[string]error
@@ -329,10 +324,10 @@
 	if len(e.pl) == 1 {
 		return fmt.Sprintf(
 			"Could not introduce %s at %s, as it requires package %s from %s, but in version %s that package %s",
-			e.goal.Depender.Ident.errString(),
-			e.goal.Depender.Version,
+			e.goal.depender.id.errString(),
+			e.goal.depender.v,
 			e.pl[0],
-			e.goal.Dep.Ident.errString(),
+			e.goal.dep.Ident.errString(),
 			e.v,
 			fcause(e.pl[0]),
 		)
@@ -341,9 +336,9 @@
 	var buf bytes.Buffer
 	fmt.Fprintf(
 		&buf, "Could not introduce %s at %s, as it requires problematic packages from %s (current version %s):",
-		e.goal.Depender.Ident.errString(),
-		e.goal.Depender.Version,
-		e.goal.Dep.Ident.errString(),
+		e.goal.depender.id.errString(),
+		e.goal.depender.v,
+		e.goal.dep.Ident.errString(),
 		e.v,
 	)
 
@@ -368,9 +363,9 @@
 
 	fmt.Fprintf(
 		&buf, "%s at %s depping on %s at %s has problem subpkg(s):",
-		e.goal.Depender.Ident.errString(),
-		e.goal.Depender.Version,
-		e.goal.Dep.Ident.errString(),
+		e.goal.depender.id.errString(),
+		e.goal.depender.v,
+		e.goal.dep.Ident.errString(),
 		e.v,
 	)
 
diff --git a/vendor/github.com/sdboyer/vsolver/flags.go b/vendor/github.com/sdboyer/vsolver/flags.go
index 1e9cc5e..8a7880f 100644
--- a/vendor/github.com/sdboyer/vsolver/flags.go
+++ b/vendor/github.com/sdboyer/vsolver/flags.go
@@ -1,20 +1,9 @@
 package vsolver
 
-// ProjectExistence values represent the extent to which a project "exists."
-type ProjectExistence uint8
+// projectExistence values represent the extent to which a project "exists."
+type projectExistence uint8
 
 const (
-	// ExistsInLock indicates that a project exists (i.e., is mentioned in) a
-	// lock file.
-	// TODO not sure if it makes sense to have this IF it's just the source
-	// manager's responsibility for putting this together - the implication is
-	// that this is the root lock file, right?
-	ExistsInLock = 1 << iota
-
-	// ExistsInManifest indicates that a project exists (i.e., is mentioned in)
-	// a manifest.
-	ExistsInManifest
-
 	// ExistsInVendorRoot indicates that a project exists in a vendor directory
 	// at the predictable location based on import path. It does NOT imply, much
 	// less guarantee, any of the following:
@@ -30,7 +19,7 @@
 	//
 	// In short, the information encoded in this flag should not be construed as
 	// exhaustive.
-	ExistsInVendorRoot
+	existsInVendorRoot projectExistence = 1 << iota
 
 	// ExistsInCache indicates that a project exists on-disk in the local cache.
 	// It does not guarantee that an upstream exists, thus it cannot imply
@@ -40,16 +29,9 @@
 	// Additionally, this refers only to the existence of the local repository
 	// itself; it says nothing about the existence or completeness of the
 	// separate metadata cache.
-	ExistsInCache
+	existsInCache
 
 	// ExistsUpstream indicates that a project repository was locatable at the
 	// path provided by a project's URI (a base import path).
-	ExistsUpstream
-)
-
-const (
-	// Bitmask for existence levels that are managed by the ProjectManager
-	pmexLvls ProjectExistence = ExistsInVendorRoot | ExistsInCache | ExistsUpstream
-	// Bitmask for existence levels that are managed by the SourceManager
-	smexLvls ProjectExistence = ExistsInLock | ExistsInManifest
+	existsUpstream
 )
diff --git a/vendor/github.com/sdboyer/vsolver/hash.go b/vendor/github.com/sdboyer/vsolver/hash.go
index 570c943..5fe87aa 100644
--- a/vendor/github.com/sdboyer/vsolver/hash.go
+++ b/vendor/github.com/sdboyer/vsolver/hash.go
@@ -25,12 +25,12 @@
 	}
 
 	// Pass in magic root values, and the bridge will analyze the right thing
-	ptree, err := s.b.listPackages(ProjectIdentifier{LocalName: s.args.N}, nil)
+	ptree, err := s.b.listPackages(ProjectIdentifier{LocalName: s.args.Name}, nil)
 	if err != nil {
-		return nil, BadOptsFailure(fmt.Sprintf("Error while parsing imports under %s: %s", s.args.Root, err.Error()))
+		return nil, badOptsFailure(fmt.Sprintf("Error while parsing imports under %s: %s", s.args.Root, err.Error()))
 	}
 
-	d, dd := s.args.M.GetDependencies(), s.args.M.GetDevDependencies()
+	d, dd := s.args.Manifest.DependencyConstraints(), s.args.Manifest.TestDependencyConstraints()
 	p := make(sortedDeps, len(d))
 	copy(p, d)
 	p = append(p, dd...)
@@ -72,9 +72,24 @@
 		}
 	}
 
+	// Add the package ignores, if any.
+	if len(s.ig) > 0 {
+		// Dump and sort the ignores
+		ig := make([]string, len(s.ig))
+		k := 0
+		for pkg := range s.ig {
+			ig[k] = pkg
+			k++
+		}
+		sort.Strings(ig)
+
+		for _, igp := range ig {
+			h.Write([]byte(igp))
+		}
+	}
+
 	// TODO overrides
 	// TODO aliases
-	// TODO ignores
 	return h.Sum(nil), nil
 }
 
diff --git a/vendor/github.com/sdboyer/vsolver/hash_test.go b/vendor/github.com/sdboyer/vsolver/hash_test.go
index b0f49bb..4bbb7d2 100644
--- a/vendor/github.com/sdboyer/vsolver/hash_test.go
+++ b/vendor/github.com/sdboyer/vsolver/hash_test.go
@@ -10,13 +10,14 @@
 	fix := basicFixtures[2]
 
 	args := SolveArgs{
-		Root: string(fix.ds[0].Name()),
-		N:    fix.ds[0].Name(),
-		M:    fix.ds[0],
+		Root:     string(fix.ds[0].Name()),
+		Name:     fix.ds[0].Name(),
+		Manifest: fix.ds[0],
+		Ignore:   []string{"foo", "bar"},
 	}
 
 	// prep a fixture-overridden solver
-	si, err := Prepare(args, SolveOpts{}, newdepspecSM(fix.ds))
+	si, err := Prepare(args, SolveOpts{}, newdepspecSM(fix.ds, nil))
 	s := si.(*solver)
 	if err != nil {
 		t.Fatalf("Could not prepare solver due to err: %s", err)
@@ -33,7 +34,7 @@
 	}
 
 	h := sha256.New()
-	for _, v := range []string{"a", "a", "1.0.0", "b", "b", "1.0.0", stdlibPkgs, "root", "", "root", "a", "b"} {
+	for _, v := range []string{"a", "a", "1.0.0", "b", "b", "1.0.0", stdlibPkgs, "root", "", "root", "a", "b", "bar", "foo"} {
 		h.Write([]byte(v))
 	}
 	correct := h.Sum(nil)
diff --git a/vendor/github.com/sdboyer/vsolver/lock.go b/vendor/github.com/sdboyer/vsolver/lock.go
index b906981..19a75d3 100644
--- a/vendor/github.com/sdboyer/vsolver/lock.go
+++ b/vendor/github.com/sdboyer/vsolver/lock.go
@@ -116,17 +116,17 @@
 	return lp.path
 }
 
-func (lp LockedProject) toAtom() ProjectAtom {
-	pa := ProjectAtom{
-		Ident: lp.Ident(),
+func (lp LockedProject) toAtom() atom {
+	pa := atom{
+		id: lp.Ident(),
 	}
 
 	if lp.v == nil {
-		pa.Version = lp.r
+		pa.v = lp.r
 	} else if lp.r != "" {
-		pa.Version = lp.v.Is(lp.r)
+		pa.v = lp.v.Is(lp.r)
 	} else {
-		pa.Version = lp.v
+		pa.v = lp.v
 	}
 
 	return pa
diff --git a/vendor/github.com/sdboyer/vsolver/manager_test.go b/vendor/github.com/sdboyer/vsolver/manager_test.go
index 38bc0d7..98e0e38 100644
--- a/vendor/github.com/sdboyer/vsolver/manager_test.go
+++ b/vendor/github.com/sdboyer/vsolver/manager_test.go
@@ -40,7 +40,7 @@
 	if err != nil {
 		t.Errorf("Failed to create temp dir: %s", err)
 	}
-	_, err = NewSourceManager(cpath, bd, false, dummyAnalyzer{})
+	_, err = NewSourceManager(dummyAnalyzer{}, cpath, bd, false)
 
 	if err != nil {
 		t.Errorf("Unexpected error on SourceManager creation: %s", err)
@@ -52,12 +52,12 @@
 		}
 	}()
 
-	_, err = NewSourceManager(cpath, bd, false, dummyAnalyzer{})
+	_, err = NewSourceManager(dummyAnalyzer{}, cpath, bd, false)
 	if err == nil {
 		t.Errorf("Creating second SourceManager should have failed due to file lock contention")
 	}
 
-	sm, err := NewSourceManager(cpath, bd, true, dummyAnalyzer{})
+	sm, err := NewSourceManager(dummyAnalyzer{}, cpath, bd, true)
 	defer sm.Release()
 	if err != nil {
 		t.Errorf("Creating second SourceManager should have succeeded when force flag was passed, but failed with err %s", err)
@@ -78,7 +78,7 @@
 	if err != nil {
 		t.Errorf("Failed to create temp dir: %s", err)
 	}
-	sm, err := NewSourceManager(cpath, bd, false, dummyAnalyzer{})
+	sm, err := NewSourceManager(dummyAnalyzer{}, cpath, bd, false)
 
 	if err != nil {
 		t.Errorf("Unexpected error on SourceManager creation: %s", err)
@@ -186,7 +186,7 @@
 	}
 
 	// Check upstream existence flag
-	if !pms.pm.CheckExistence(ExistsUpstream) {
+	if !pms.pm.CheckExistence(existsUpstream) {
 		t.Errorf("ExistsUpstream flag not being correctly set the project")
 	}
 }
@@ -202,7 +202,7 @@
 		t.Errorf("Failed to create temp dir: %s", err)
 	}
 
-	smi, err := NewSourceManager(cpath, bd, false, dummyAnalyzer{})
+	smi, err := NewSourceManager(dummyAnalyzer{}, cpath, bd, false)
 	if err != nil {
 		t.Errorf("Unexpected error on SourceManager creation: %s", err)
 		t.FailNow()
@@ -224,7 +224,7 @@
 			t.Errorf("Unexpected error on ProjectManager creation: %s", err)
 			t.FailNow()
 		}
-		pms[k] = pmi.pm.(*projectManager)
+		pms[k] = pmi.pm
 	}
 
 	defer func() {
@@ -240,7 +240,7 @@
 	if err != nil {
 		t.Errorf("Unexpected error getting version pairs from git repo: %s", err)
 	}
-	if exbits != ExistsUpstream {
+	if exbits != existsUpstream {
 		t.Errorf("git pair fetch should only set upstream existence bits, but got %v", exbits)
 	}
 	if len(vlist) != 3 {
@@ -267,7 +267,7 @@
 	if err != nil {
 		t.Errorf("Unexpected error getting version pairs from hg repo: %s", err)
 	}
-	if exbits != ExistsUpstream|ExistsInCache {
+	if exbits != existsUpstream|existsInCache {
 		t.Errorf("hg pair fetch should set upstream and cache existence bits, but got %v", exbits)
 	}
 	if len(vlist) != 2 {
@@ -289,7 +289,7 @@
 	if err != nil {
 		t.Errorf("Unexpected error getting version pairs from bzr repo: %s", err)
 	}
-	if exbits != ExistsUpstream|ExistsInCache {
+	if exbits != existsUpstream|existsInCache {
 		t.Errorf("bzr pair fetch should set upstream and cache existence bits, but got %v", exbits)
 	}
 	if len(vlist) != 1 {
@@ -314,7 +314,7 @@
 	if err != nil {
 		t.Errorf("Failed to create temp dir: %s", err)
 	}
-	sm, err := NewSourceManager(cpath, bd, false, dummyAnalyzer{})
+	sm, err := NewSourceManager(dummyAnalyzer{}, cpath, bd, false)
 
 	if err != nil {
 		t.Errorf("Unexpected error on SourceManager creation: %s", err)
@@ -332,7 +332,7 @@
 
 	pn := ProjectName("github.com/Masterminds/VCSTestRepo")
 
-	_, err = sm.GetProjectInfo(pn, NewVersion("1.0.0"))
+	_, _, err = sm.GetProjectInfo(pn, NewVersion("1.0.0"))
 	if err != nil {
 		t.Errorf("Unexpected error from GetInfoAt %s", err)
 	}
diff --git a/vendor/github.com/sdboyer/vsolver/manifest.go b/vendor/github.com/sdboyer/vsolver/manifest.go
index 89dd0da..51dac26 100644
--- a/vendor/github.com/sdboyer/vsolver/manifest.go
+++ b/vendor/github.com/sdboyer/vsolver/manifest.go
@@ -2,11 +2,8 @@
 
 // Manifest represents the data from a manifest file (or however the
 // implementing tool chooses to store it) at a particular version that is
-// relevant to the satisfiability solving process:
-//
-// - A list of dependencies: project name, and a constraint
-// - A list of development-time dependencies (e.g. for testing - only
-// the root project's are incorporated)
+// relevant to the satisfiability solving process. That means constraints on
+// dependencies, both for normal dependencies and for tests.
 //
 // Finding a solution that satisfies the constraints expressed by all of these
 // dependencies (and those from all other projects, transitively), is what the
@@ -18,8 +15,8 @@
 // from consideration in the solving algorithm.
 type Manifest interface {
 	Name() ProjectName
-	GetDependencies() []ProjectDep
-	GetDevDependencies() []ProjectDep
+	DependencyConstraints() []ProjectDep
+	TestDependencyConstraints() []ProjectDep
 }
 
 // SimpleManifest is a helper for tools to enumerate manifest data. It's
@@ -27,9 +24,9 @@
 // the fly for projects with no manifest metadata, or metadata through a foreign
 // tool's idioms.
 type SimpleManifest struct {
-	N  ProjectName
-	P  []ProjectDep
-	DP []ProjectDep
+	N        ProjectName
+	Deps     []ProjectDep
+	TestDeps []ProjectDep
 }
 
 var _ Manifest = SimpleManifest{}
@@ -40,13 +37,13 @@
 }
 
 // GetDependencies returns the project's dependencies.
-func (m SimpleManifest) GetDependencies() []ProjectDep {
-	return m.P
+func (m SimpleManifest) DependencyConstraints() []ProjectDep {
+	return m.Deps
 }
 
 // GetDependencies returns the project's test dependencies.
-func (m SimpleManifest) GetDevDependencies() []ProjectDep {
-	return m.DP
+func (m SimpleManifest) TestDependencyConstraints() []ProjectDep {
+	return m.TestDeps
 }
 
 // prepManifest ensures a manifest is prepared and safe for use by the solver.
@@ -67,22 +64,22 @@
 		}
 	}
 
-	deps := m.GetDependencies()
-	ddeps := m.GetDevDependencies()
+	deps := m.DependencyConstraints()
+	ddeps := m.TestDependencyConstraints()
 
 	rm := SimpleManifest{
-		N:  m.Name(),
-		P:  make([]ProjectDep, len(deps)),
-		DP: make([]ProjectDep, len(ddeps)),
+		N:        m.Name(),
+		Deps:     make([]ProjectDep, len(deps)),
+		TestDeps: make([]ProjectDep, len(ddeps)),
 	}
 
 	for k, d := range deps {
 		d.Ident = d.Ident.normalize()
-		rm.P[k] = d
+		rm.Deps[k] = d
 	}
 	for k, d := range ddeps {
 		d.Ident = d.Ident.normalize()
-		rm.DP[k] = d
+		rm.TestDeps[k] = d
 	}
 
 	return rm
diff --git a/vendor/github.com/sdboyer/vsolver/project_manager.go b/vendor/github.com/sdboyer/vsolver/project_manager.go
index bd92a7f..dd10e6a 100644
--- a/vendor/github.com/sdboyer/vsolver/project_manager.go
+++ b/vendor/github.com/sdboyer/vsolver/project_manager.go
@@ -15,18 +15,6 @@
 	"github.com/termie/go-shutil"
 )
 
-type ProjectManager interface {
-	GetInfoAt(Version) (ProjectInfo, error)
-	ListVersions() ([]Version, error)
-	CheckExistence(ProjectExistence) bool
-	ExportVersionTo(Version, string) error
-	ListPackages(Version) (PackageTree, error)
-}
-
-type ProjectAnalyzer interface {
-	GetInfo(build.Context, ProjectName) (Manifest, Lock, error)
-}
-
 type projectManager struct {
 	// The identifier of the project. At this level, corresponds to the
 	// '$GOPATH/src'-relative path, *and* the network name.
@@ -59,20 +47,26 @@
 
 type existence struct {
 	// The existence levels for which a search/check has been performed
-	s ProjectExistence
+	s projectExistence
 
 	// The existence levels verified to be present through searching
-	f ProjectExistence
+	f projectExistence
 }
 
 // TODO figure out shape of versions, then implement marshaling/unmarshaling
 type projectDataCache struct {
 	Version string                   `json:"version"` // TODO use this
-	Infos   map[Revision]ProjectInfo `json:"infos"`
+	Infos   map[Revision]projectInfo `json:"infos"`
 	VMap    map[Version]Revision     `json:"vmap"`
 	RMap    map[Revision][]Version   `json:"rmap"`
 }
 
+// projectInfo holds manifest and lock
+type projectInfo struct {
+	Manifest
+	Lock
+}
+
 type repo struct {
 	// Path to the root of the default working copy (NOT the repo itself)
 	rpath string
@@ -87,14 +81,14 @@
 	synced bool
 }
 
-func (pm *projectManager) GetInfoAt(v Version) (ProjectInfo, error) {
+func (pm *projectManager) GetInfoAt(v Version) (Manifest, Lock, error) {
 	if err := pm.ensureCacheExistence(); err != nil {
-		return ProjectInfo{}, err
+		return nil, nil, err
 	}
 
 	if r, exists := pm.dc.VMap[v]; exists {
 		if pi, exists := pm.dc.Infos[r]; exists {
-			return pi, nil
+			return pi.Manifest, pi.Lock, nil
 		}
 	}
 
@@ -103,7 +97,7 @@
 	if !pm.crepo.synced {
 		err = pm.crepo.r.Update()
 		if err != nil {
-			return ProjectInfo{}, fmt.Errorf("Could not fetch latest updates into repository")
+			return nil, nil, fmt.Errorf("Could not fetch latest updates into repository")
 		}
 		pm.crepo.synced = true
 	}
@@ -131,17 +125,19 @@
 		}
 
 		// If m is nil, prepManifest will provide an empty one.
-		return ProjectInfo{
-			// TODO disagreement between the manifest's name and N is still
-			// scary
-			V:        v,
-			N:        pm.n,
+		pi := projectInfo{
 			Manifest: prepManifest(m, pm.n),
 			Lock:     l,
-		}, nil
+		}
+
+		if r, exists := pm.dc.VMap[v]; exists {
+			pm.dc.Infos[r] = pi
+		}
+
+		return pi.Manifest, pi.Lock, nil
 	}
 
-	return ProjectInfo{}, err
+	return nil, nil, err
 }
 
 func (pm *projectManager) ListPackages(v Version) (PackageTree, error) {
@@ -180,14 +176,14 @@
 	// would allow weird state inconsistencies (cache exists, but no repo...how
 	// does that even happen?) that it'd be better to just not allow so that we
 	// don't have to think about it elsewhere
-	if !pm.CheckExistence(ExistsInCache) {
-		if pm.CheckExistence(ExistsUpstream) {
+	if !pm.CheckExistence(existsInCache) {
+		if pm.CheckExistence(existsUpstream) {
 			err := pm.crepo.r.Get()
 			if err != nil {
 				return fmt.Errorf("Failed to create repository cache for %s", pm.n)
 			}
-			pm.ex.s |= ExistsInCache
-			pm.ex.f |= ExistsInCache
+			pm.ex.s |= existsInCache
+			pm.ex.f |= existsInCache
 		} else {
 			return fmt.Errorf("Project repository cache for %s does not exist", pm.n)
 		}
@@ -199,7 +195,7 @@
 func (pm *projectManager) ListVersions() (vlist []Version, err error) {
 	if !pm.cvsync {
 		// This check only guarantees that the upstream exists, not the cache
-		pm.ex.s |= ExistsUpstream
+		pm.ex.s |= existsUpstream
 		vpairs, exbits, err := pm.crepo.getCurrentVersionPairs()
 		// But it *may* also check the local existence
 		pm.ex.s |= exbits
@@ -213,7 +209,7 @@
 
 		vlist = make([]Version, len(vpairs))
 		// mark our cache as synced if we got ExistsUpstream back
-		if exbits&ExistsUpstream == ExistsUpstream {
+		if exbits&existsUpstream == existsUpstream {
 			pm.cvsync = true
 		}
 
@@ -245,29 +241,29 @@
 // Note that this may perform read-ish operations on the cache repo, and it
 // takes a lock accordingly. Deadlock may result from calling it during a
 // segment where the cache repo mutex is already write-locked.
-func (pm *projectManager) CheckExistence(ex ProjectExistence) bool {
+func (pm *projectManager) CheckExistence(ex projectExistence) bool {
 	if pm.ex.s&ex != ex {
-		if ex&ExistsInVendorRoot != 0 && pm.ex.s&ExistsInVendorRoot == 0 {
-			pm.ex.s |= ExistsInVendorRoot
+		if ex&existsInVendorRoot != 0 && pm.ex.s&existsInVendorRoot == 0 {
+			pm.ex.s |= existsInVendorRoot
 
 			fi, err := os.Stat(path.Join(pm.vendordir, string(pm.n)))
 			if err == nil && fi.IsDir() {
-				pm.ex.f |= ExistsInVendorRoot
+				pm.ex.f |= existsInVendorRoot
 			}
 		}
-		if ex&ExistsInCache != 0 && pm.ex.s&ExistsInCache == 0 {
+		if ex&existsInCache != 0 && pm.ex.s&existsInCache == 0 {
 			pm.crepo.mut.RLock()
-			pm.ex.s |= ExistsInCache
+			pm.ex.s |= existsInCache
 			if pm.crepo.r.CheckLocal() {
-				pm.ex.f |= ExistsInCache
+				pm.ex.f |= existsInCache
 			}
 			pm.crepo.mut.RUnlock()
 		}
-		if ex&ExistsUpstream != 0 && pm.ex.s&ExistsUpstream == 0 {
+		if ex&existsUpstream != 0 && pm.ex.s&existsUpstream == 0 {
 			pm.crepo.mut.RLock()
-			pm.ex.s |= ExistsUpstream
+			pm.ex.s |= existsUpstream
 			if pm.crepo.r.Ping() {
-				pm.ex.f |= ExistsUpstream
+				pm.ex.f |= existsUpstream
 			}
 			pm.crepo.mut.RUnlock()
 		}
@@ -280,7 +276,7 @@
 	return pm.crepo.exportVersionTo(v, to)
 }
 
-func (r *repo) getCurrentVersionPairs() (vlist []PairedVersion, exbits ProjectExistence, err error) {
+func (r *repo) getCurrentVersionPairs() (vlist []PairedVersion, exbits projectExistence, err error) {
 	r.mut.Lock()
 	defer r.mut.Unlock()
 
@@ -307,7 +303,7 @@
 			}
 
 			// Upstream and cache must exist, so add that to exbits
-			exbits |= ExistsUpstream | ExistsInCache
+			exbits |= existsUpstream | existsInCache
 			// Also, local is definitely now synced
 			r.synced = true
 
@@ -319,7 +315,7 @@
 			all = bytes.Split(bytes.TrimSpace(out), []byte("\n"))
 		}
 		// Local cache may not actually exist here, but upstream definitely does
-		exbits |= ExistsUpstream
+		exbits |= existsUpstream
 
 		tmap := make(map[string]PairedVersion)
 		for _, pair := range all {
@@ -358,7 +354,7 @@
 			return
 		}
 		// Upstream and cache must exist, so add that to exbits
-		exbits |= ExistsUpstream | ExistsInCache
+		exbits |= existsUpstream | existsInCache
 		// Also, local is definitely now synced
 		r.synced = true
 
@@ -383,7 +379,7 @@
 		}
 
 		// Upstream and cache must exist, so add that to exbits
-		exbits |= ExistsUpstream | ExistsInCache
+		exbits |= existsUpstream | existsInCache
 		// Also, local is definitely now synced
 		r.synced = true
 
diff --git a/vendor/github.com/sdboyer/vsolver/remote.go b/vendor/github.com/sdboyer/vsolver/remote.go
index 37d95e4..b04b9ce 100644
--- a/vendor/github.com/sdboyer/vsolver/remote.go
+++ b/vendor/github.com/sdboyer/vsolver/remote.go
@@ -2,6 +2,8 @@
 
 import (
 	"fmt"
+	"io"
+	"net/http"
 	"net/url"
 	"regexp"
 	"strings"
@@ -218,6 +220,87 @@
 		}
 	}
 
-	// TODO use HTTP metadata to resolve vanity imports
-	return nil, fmt.Errorf("unable to deduce repository and source type for: %q", path)
+	// No luck so far. maybe it's one of them vanity imports?
+	importroot, vcs, reporoot, err := parseMetadata(path)
+	if err != nil {
+		return nil, fmt.Errorf("unable to deduce repository and source type for: %q", path)
+	}
+
+	// If we got something back at all, then it supercedes the actual input for
+	// the real URL to hit
+	rr.CloneURL, err = url.Parse(reporoot)
+	if err != nil {
+		return nil, fmt.Errorf("server returned bad URL when searching for vanity import: %q", reporoot)
+	}
+
+	// We have a real URL. Set the other values and return.
+	rr.Base = importroot
+	rr.RelPkg = strings.TrimPrefix(path[len(importroot):], "/")
+
+	rr.VCS = []string{vcs}
+	if rr.CloneURL.Scheme != "" {
+		rr.Schemes = []string{rr.CloneURL.Scheme}
+	}
+
+	return rr, nil
+}
+
+// fetchMetadata fetchs the remote metadata for path.
+func fetchMetadata(path string) (rc io.ReadCloser, err error) {
+	defer func() {
+		if err != nil {
+			err = fmt.Errorf("unable to determine remote metadata protocol: %s", err)
+		}
+	}()
+
+	// try https first
+	rc, err = doFetchMetadata("https", path)
+	if err == nil {
+		return
+	}
+
+	rc, err = doFetchMetadata("http", path)
+	return
+}
+
+func doFetchMetadata(scheme, path string) (io.ReadCloser, error) {
+	url := fmt.Sprintf("%s://%s?go-get=1", scheme, path)
+	switch scheme {
+	case "https", "http":
+		resp, err := http.Get(url)
+		if err != nil {
+			return nil, fmt.Errorf("failed to access url %q", url)
+		}
+		return resp.Body, nil
+	default:
+		return nil, fmt.Errorf("unknown remote protocol scheme: %q", scheme)
+	}
+}
+
+// parseMetadata fetches and decodes remote metadata for path.
+func parseMetadata(path string) (string, string, string, error) {
+	rc, err := fetchMetadata(path)
+	if err != nil {
+		return "", "", "", err
+	}
+	defer rc.Close()
+
+	imports, err := parseMetaGoImports(rc)
+	if err != nil {
+		return "", "", "", err
+	}
+	match := -1
+	for i, im := range imports {
+		if !strings.HasPrefix(path, im.Prefix) {
+			continue
+		}
+		if match != -1 {
+			return "", "", "", fmt.Errorf("multiple meta tags match import path %q", path)
+		}
+		match = i
+	}
+	if match == -1 {
+		return "", "", "", fmt.Errorf("go-import metadata not found")
+	}
+	return imports[match].Prefix, imports[match].VCS, imports[match].RepoRoot, nil
 }
diff --git a/vendor/github.com/sdboyer/vsolver/remote_test.go b/vendor/github.com/sdboyer/vsolver/remote_test.go
index 10537ca..3bac9ae 100644
--- a/vendor/github.com/sdboyer/vsolver/remote_test.go
+++ b/vendor/github.com/sdboyer/vsolver/remote_test.go
@@ -8,6 +8,10 @@
 )
 
 func TestDeduceRemotes(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping remote deduction test in short mode")
+	}
+
 	fixtures := []struct {
 		path string
 		want *remoteRepo
@@ -365,7 +369,50 @@
 				VCS: []string{"git"},
 			},
 		},
-		// Regression - gh does allow 2-letter usernames
+		// Vanity imports
+		{
+			"golang.org/x/exp",
+			&remoteRepo{
+				Base:   "golang.org/x/exp",
+				RelPkg: "",
+				CloneURL: &url.URL{
+					Scheme: "https",
+					Host:   "go.googlesource.com",
+					Path:   "/exp",
+				},
+				Schemes: []string{"https"},
+				VCS:     []string{"git"},
+			},
+		},
+		{
+			"golang.org/x/exp/inotify",
+			&remoteRepo{
+				Base:   "golang.org/x/exp",
+				RelPkg: "inotify",
+				CloneURL: &url.URL{
+					Scheme: "https",
+					Host:   "go.googlesource.com",
+					Path:   "/exp",
+				},
+				Schemes: []string{"https"},
+				VCS:     []string{"git"},
+			},
+		},
+		{
+			"rsc.io/pdf",
+			&remoteRepo{
+				Base:   "rsc.io/pdf",
+				RelPkg: "",
+				CloneURL: &url.URL{
+					Scheme: "https",
+					Host:   "github.com",
+					Path:   "/rsc/pdf",
+				},
+				Schemes: []string{"https"},
+				VCS:     []string{"git"},
+			},
+		},
+		// Regression - gh does allow two-letter usernames
 		{
 			"github.com/kr/pretty",
 			&remoteRepo{
diff --git a/vendor/github.com/sdboyer/vsolver/result.go b/vendor/github.com/sdboyer/vsolver/result.go
index 426be6a..e6e929e 100644
--- a/vendor/github.com/sdboyer/vsolver/result.go
+++ b/vendor/github.com/sdboyer/vsolver/result.go
@@ -7,6 +7,8 @@
 	"path/filepath"
 )
 
+// A Result is returned by a solver run. It is mostly just a Lock, with some
+// additional methods that report information about the solve run.
 type Result interface {
 	Lock
 	Attempts() int
diff --git a/vendor/github.com/sdboyer/vsolver/result_test.go b/vendor/github.com/sdboyer/vsolver/result_test.go
index 605328e..5419d32 100644
--- a/vendor/github.com/sdboyer/vsolver/result_test.go
+++ b/vendor/github.com/sdboyer/vsolver/result_test.go
@@ -8,7 +8,7 @@
 )
 
 var basicResult result
-var kub ProjectAtom
+var kub atom
 
 // An analyzer that passes nothing back, but doesn't error. This expressly
 // creates a situation that shouldn't be able to happen from a general solver
@@ -29,21 +29,21 @@
 	basicResult = result{
 		att: 1,
 		p: []LockedProject{
-			pa2lp(ProjectAtom{
-				Ident:   pi("github.com/sdboyer/testrepo"),
-				Version: NewBranch("master").Is(Revision("4d59fb584b15a94d7401e356d2875c472d76ef45")),
+			pa2lp(atom{
+				id: pi("github.com/sdboyer/testrepo"),
+				v:  NewBranch("master").Is(Revision("4d59fb584b15a94d7401e356d2875c472d76ef45")),
 			}, nil),
-			pa2lp(ProjectAtom{
-				Ident:   pi("github.com/Masterminds/VCSTestRepo"),
-				Version: NewVersion("1.0.0").Is(Revision("30605f6ac35fcb075ad0bfa9296f90a7d891523e")),
+			pa2lp(atom{
+				id: pi("github.com/Masterminds/VCSTestRepo"),
+				v:  NewVersion("1.0.0").Is(Revision("30605f6ac35fcb075ad0bfa9296f90a7d891523e")),
 			}, nil),
 		},
 	}
 
 	// just in case something needs punishing, kubernetes is happy to oblige
-	kub = ProjectAtom{
-		Ident:   pi("github.com/kubernetes/kubernetes"),
-		Version: NewVersion("1.0.0").Is(Revision("528f879e7d3790ea4287687ef0ab3f2a01cc2718")),
+	kub = atom{
+		id: pi("github.com/kubernetes/kubernetes"),
+		v:  NewVersion("1.0.0").Is(Revision("528f879e7d3790ea4287687ef0ab3f2a01cc2718")),
 	}
 }
 
@@ -58,7 +58,7 @@
 	tmp := path.Join(os.TempDir(), "vsolvtest")
 	os.RemoveAll(tmp)
 
-	sm, err := NewSourceManager(path.Join(tmp, "cache"), path.Join(tmp, "base"), false, passthruAnalyzer{})
+	sm, err := NewSourceManager(passthruAnalyzer{}, path.Join(tmp, "cache"), path.Join(tmp, "base"), false)
 	if err != nil {
 		t.Errorf("NewSourceManager errored unexpectedly: %q", err)
 	}
@@ -79,7 +79,7 @@
 	tmp := path.Join(os.TempDir(), "vsolvtest")
 
 	clean := true
-	sm, err := NewSourceManager(path.Join(tmp, "cache"), path.Join(tmp, "base"), true, passthruAnalyzer{})
+	sm, err := NewSourceManager(passthruAnalyzer{}, path.Join(tmp, "cache"), path.Join(tmp, "base"), true)
 	if err != nil {
 		b.Errorf("NewSourceManager errored unexpectedly: %q", err)
 		clean = false
@@ -87,7 +87,7 @@
 
 	// Prefetch the projects before timer starts
 	for _, lp := range r.p {
-		_, err := sm.GetProjectInfo(lp.Ident().LocalName, lp.Version())
+		_, _, err := sm.GetProjectInfo(lp.Ident().LocalName, lp.Version())
 		if err != nil {
 			b.Errorf("failed getting project info during prefetch: %s", err)
 			clean = false
diff --git a/vendor/github.com/sdboyer/vsolver/satisfy.go b/vendor/github.com/sdboyer/vsolver/satisfy.go
index 174d95c..c431cdc 100644
--- a/vendor/github.com/sdboyer/vsolver/satisfy.go
+++ b/vendor/github.com/sdboyer/vsolver/satisfy.go
@@ -4,7 +4,7 @@
 // that we want to select. It determines if selecting the atom would result in
 // a state where all solver requirements are still satisfied.
 func (s *solver) checkProject(a atomWithPackages) error {
-	pa := a.atom
+	pa := a.a
 	if nilpa == pa {
 		// This shouldn't be able to happen, but if it does, it unequivocally
 		// indicates a logical bug somewhere, so blowing up is preferable
@@ -49,7 +49,7 @@
 // already-selected project. It determines if selecting the packages would
 // result in a state where all solver requirements are still satisfied.
 func (s *solver) checkPackage(a atomWithPackages) error {
-	if nilpa == a.atom {
+	if nilpa == a.a {
 		// This shouldn't be able to happen, but if it does, it unequivocally
 		// indicates a logical bug somewhere, so blowing up is preferable
 		panic("canary - checking version of empty ProjectAtom")
@@ -83,18 +83,18 @@
 
 // checkAtomAllowable ensures that an atom itself is acceptable with respect to
 // the constraints established by the current solution.
-func (s *solver) checkAtomAllowable(pa ProjectAtom) error {
-	constraint := s.sel.getConstraint(pa.Ident)
-	if s.b.matches(pa.Ident, constraint, pa.Version) {
+func (s *solver) checkAtomAllowable(pa atom) error {
+	constraint := s.sel.getConstraint(pa.id)
+	if s.b.matches(pa.id, constraint, pa.v) {
 		return nil
 	}
 	// TODO collect constraint failure reason (wait...aren't we, below?)
 
-	deps := s.sel.getDependenciesOn(pa.Ident)
-	var failparent []Dependency
+	deps := s.sel.getDependenciesOn(pa.id)
+	var failparent []dependency
 	for _, dep := range deps {
-		if !s.b.matches(pa.Ident, dep.Dep.Constraint, pa.Version) {
-			s.fail(dep.Depender.Ident)
+		if !s.b.matches(pa.id, dep.dep.Constraint, pa.v) {
+			s.fail(dep.depender.id)
 			failparent = append(failparent, dep)
 		}
 	}
@@ -112,28 +112,28 @@
 // checkRequiredPackagesExist ensures that all required packages enumerated by
 // existing dependencies on this atom are actually present in the atom.
 func (s *solver) checkRequiredPackagesExist(a atomWithPackages) error {
-	ptree, err := s.b.listPackages(a.atom.Ident, a.atom.Version)
+	ptree, err := s.b.listPackages(a.a.id, a.a.v)
 	if err != nil {
 		// TODO handle this more gracefully
 		return err
 	}
 
-	deps := s.sel.getDependenciesOn(a.atom.Ident)
+	deps := s.sel.getDependenciesOn(a.a.id)
 	fp := make(map[string]errDeppers)
 	// We inspect these in a bit of a roundabout way, in order to incrementally
 	// build up the failure we'd return if there is, indeed, a missing package.
 	// TODO rechecking all of these every time is wasteful. Is there a shortcut?
 	for _, dep := range deps {
-		for _, pkg := range dep.Dep.pl {
+		for _, pkg := range dep.dep.pl {
 			if errdep, seen := fp[pkg]; seen {
-				errdep.deppers = append(errdep.deppers, dep.Depender)
+				errdep.deppers = append(errdep.deppers, dep.depender)
 				fp[pkg] = errdep
 			} else {
 				perr, has := ptree.Packages[pkg]
 				if !has || perr.Err != nil {
 					fp[pkg] = errDeppers{
 						err:     perr.Err,
-						deppers: []ProjectAtom{dep.Depender},
+						deppers: []atom{dep.depender},
 					}
 				}
 			}
@@ -142,7 +142,7 @@
 
 	if len(fp) > 0 {
 		e := &checkeeHasProblemPackagesFailure{
-			goal:    a.atom,
+			goal:    a.a,
 			failpkg: fp,
 		}
 		s.logSolve(e)
@@ -164,11 +164,11 @@
 
 	siblings := s.sel.getDependenciesOn(dep.Ident)
 	// No admissible versions - visit all siblings and identify the disagreement(s)
-	var failsib []Dependency
-	var nofailsib []Dependency
+	var failsib []dependency
+	var nofailsib []dependency
 	for _, sibling := range siblings {
-		if !s.b.matchesAny(dep.Ident, sibling.Dep.Constraint, dep.Constraint) {
-			s.fail(sibling.Depender.Ident)
+		if !s.b.matchesAny(dep.Ident, sibling.dep.Constraint, dep.Constraint) {
+			s.fail(sibling.depender.id)
 			failsib = append(failsib, sibling)
 		} else {
 			nofailsib = append(nofailsib, sibling)
@@ -176,7 +176,7 @@
 	}
 
 	err := &disjointConstraintFailure{
-		goal:      Dependency{Depender: a.atom, Dep: cdep},
+		goal:      dependency{depender: a.a, dep: cdep},
 		failsib:   failsib,
 		nofailsib: nofailsib,
 		c:         constraint,
@@ -191,12 +191,12 @@
 func (s *solver) checkDepsDisallowsSelected(a atomWithPackages, cdep completeDep) error {
 	dep := cdep.ProjectDep
 	selected, exists := s.sel.selected(dep.Ident)
-	if exists && !s.b.matches(dep.Ident, dep.Constraint, selected.atom.Version) {
+	if exists && !s.b.matches(dep.Ident, dep.Constraint, selected.a.v) {
 		s.fail(dep.Ident)
 
 		err := &constraintNotAllowedFailure{
-			goal: Dependency{Depender: a.atom, Dep: cdep},
-			v:    selected.atom.Version,
+			goal: dependency{depender: a.a, dep: cdep},
+			v:    selected.a.v,
 		}
 		s.logSolve(err)
 		return err
@@ -215,11 +215,11 @@
 	dep := cdep.ProjectDep
 	if cur, exists := s.names[dep.Ident.LocalName]; exists {
 		if cur != dep.Ident.netName() {
-			deps := s.sel.getDependenciesOn(a.atom.Ident)
+			deps := s.sel.getDependenciesOn(a.a.id)
 			// Fail all the other deps, as there's no way atom can ever be
 			// compatible with them
 			for _, d := range deps {
-				s.fail(d.Depender.Ident)
+				s.fail(d.depender.id)
 			}
 
 			err := &sourceMismatchFailure{
@@ -227,7 +227,7 @@
 				sel:      deps,
 				current:  cur,
 				mismatch: dep.Ident.netName(),
-				prob:     a.atom,
+				prob:     a.a,
 			}
 			s.logSolve(err)
 			return err
@@ -246,18 +246,18 @@
 		return nil
 	}
 
-	ptree, err := s.b.listPackages(sel.atom.Ident, sel.atom.Version)
+	ptree, err := s.b.listPackages(sel.a.id, sel.a.v)
 	if err != nil {
 		// TODO handle this more gracefully
 		return err
 	}
 
 	e := &depHasProblemPackagesFailure{
-		goal: Dependency{
-			Depender: a.atom,
-			Dep:      cdep,
+		goal: dependency{
+			depender: a.a,
+			dep:      cdep,
 		},
-		v:    sel.atom.Version,
+		v:    sel.a.v,
 		prob: make(map[string]error),
 	}
 
diff --git a/vendor/github.com/sdboyer/vsolver/selection.go b/vendor/github.com/sdboyer/vsolver/selection.go
index cfff305..9aaac4d 100644
--- a/vendor/github.com/sdboyer/vsolver/selection.go
+++ b/vendor/github.com/sdboyer/vsolver/selection.go
@@ -2,7 +2,7 @@
 
 type selection struct {
 	projects []selected
-	deps     map[ProjectIdentifier][]Dependency
+	deps     map[ProjectIdentifier][]dependency
 	sm       sourceBridge
 }
 
@@ -11,7 +11,7 @@
 	first bool
 }
 
-func (s *selection) getDependenciesOn(id ProjectIdentifier) []Dependency {
+func (s *selection) getDependenciesOn(id ProjectIdentifier) []dependency {
 	if deps, exists := s.deps[id]; exists {
 		return deps
 	}
@@ -39,11 +39,11 @@
 	return sel.a, sel.first
 }
 
-func (s *selection) pushDep(dep Dependency) {
-	s.deps[dep.Dep.Ident] = append(s.deps[dep.Dep.Ident], dep)
+func (s *selection) pushDep(dep dependency) {
+	s.deps[dep.dep.Ident] = append(s.deps[dep.dep.Ident], dep)
 }
 
-func (s *selection) popDep(id ProjectIdentifier) (dep Dependency) {
+func (s *selection) popDep(id ProjectIdentifier) (dep dependency) {
 	deps := s.deps[id]
 	dep, s.deps[id] = deps[len(deps)-1], deps[:len(deps)-1]
 	return dep
@@ -53,7 +53,7 @@
 	return len(s.deps[id])
 }
 
-func (s *selection) setDependenciesOn(id ProjectIdentifier, deps []Dependency) {
+func (s *selection) setDependenciesOn(id ProjectIdentifier, deps []dependency) {
 	s.deps[id] = deps
 }
 
@@ -65,7 +65,7 @@
 	// structure so that we can pop with zero cost.
 	uniq := make(map[string]int)
 	for _, dep := range s.deps[id] {
-		for _, pkg := range dep.Dep.pl {
+		for _, pkg := range dep.dep.pl {
 			if count, has := uniq[pkg]; has {
 				count++
 				uniq[pkg] = count
@@ -87,7 +87,7 @@
 	// structure so that we can pop with zero cost.
 	uniq := make(map[string]int)
 	for _, p := range s.projects {
-		if p.a.atom.Ident.eq(id) {
+		if p.a.a.id.eq(id) {
 			for _, pkg := range p.a.pl {
 				if count, has := uniq[pkg]; has {
 					count++
@@ -118,7 +118,7 @@
 	// Start with the open set
 	var ret Constraint = any
 	for _, dep := range deps {
-		ret = s.sm.intersect(id, ret, dep.Dep.Constraint)
+		ret = s.sm.intersect(id, ret, dep.dep.Constraint)
 	}
 
 	return ret
@@ -133,12 +133,12 @@
 // have happened later.
 func (s *selection) selected(id ProjectIdentifier) (atomWithPackages, bool) {
 	for _, p := range s.projects {
-		if p.a.atom.Ident.eq(id) {
+		if p.a.a.id.eq(id) {
 			return p.a, true
 		}
 	}
 
-	return atomWithPackages{atom: nilpa}, false
+	return atomWithPackages{a: nilpa}, false
 }
 
 // TODO take a ProjectName, but optionally also a preferred version. This will
diff --git a/vendor/github.com/sdboyer/vsolver/solve_basic_test.go b/vendor/github.com/sdboyer/vsolver/solve_basic_test.go
index c4c4cb3..910cd05 100644
--- a/vendor/github.com/sdboyer/vsolver/solve_basic_test.go
+++ b/vendor/github.com/sdboyer/vsolver/solve_basic_test.go
@@ -68,7 +68,7 @@
 //
 // Splits the input string on a space, and uses the first two elements as the
 // project name and constraint body, respectively.
-func mksvpa(info string) ProjectAtom {
+func mksvpa(info string) atom {
 	id, ver, rev := nsvrSplit(info)
 
 	_, err := semver.NewVersion(ver)
@@ -83,9 +83,9 @@
 		v = v.(UnpairedVersion).Is(rev)
 	}
 
-	return ProjectAtom{
-		Ident:   id,
-		Version: v,
+	return atom{
+		id: id,
+		v:  v,
 	}
 }
 
@@ -132,13 +132,13 @@
 // First string is broken out into the name/semver of the main package.
 func dsv(pi string, deps ...string) depspec {
 	pa := mksvpa(pi)
-	if string(pa.Ident.LocalName) != pa.Ident.NetworkName {
+	if string(pa.id.LocalName) != pa.id.NetworkName {
 		panic("alternate source on self makes no sense")
 	}
 
 	ds := depspec{
-		n: pa.Ident.LocalName,
-		v: pa.Version,
+		n: pa.id.LocalName,
+		v: pa.v,
 	}
 
 	for _, dep := range deps {
@@ -161,7 +161,7 @@
 	l := make(fixLock, 0)
 	for _, s := range pairs {
 		pa := mksvpa(s)
-		l = append(l, NewLockedProject(pa.Ident.LocalName, pa.Version, pa.Ident.netName(), "", nil))
+		l = append(l, NewLockedProject(pa.id.LocalName, pa.v, pa.id.netName(), "", nil))
 	}
 
 	return l
@@ -173,7 +173,7 @@
 	l := make(fixLock, 0)
 	for _, s := range pairs {
 		pa := mksvpa(s)
-		l = append(l, NewLockedProject(pa.Ident.LocalName, pa.Version.(PairedVersion).Underlying(), pa.Ident.netName(), "", nil))
+		l = append(l, NewLockedProject(pa.id.LocalName, pa.v.(PairedVersion).Underlying(), pa.id.netName(), "", nil))
 	}
 
 	return l
@@ -863,37 +863,42 @@
 type depspecSourceManager struct {
 	specs []depspec
 	rm    reachMap
+	ig    map[string]bool
 }
 
 type fixSM interface {
 	SourceManager
 	rootSpec() depspec
 	allSpecs() []depspec
+	ignore() map[string]bool
 }
 
 var _ fixSM = &depspecSourceManager{}
 
-func newdepspecSM(ds []depspec) *depspecSourceManager {
+func newdepspecSM(ds []depspec, ignore []string) *depspecSourceManager {
+	ig := make(map[string]bool)
+	if len(ignore) > 0 {
+		for _, pkg := range ignore {
+			ig[pkg] = true
+		}
+	}
+
 	return &depspecSourceManager{
 		specs: ds,
 		rm:    computeBasicReachMap(ds),
+		ig:    ig,
 	}
 }
 
-func (sm *depspecSourceManager) GetProjectInfo(n ProjectName, v Version) (ProjectInfo, error) {
+func (sm *depspecSourceManager) GetProjectInfo(n ProjectName, v Version) (Manifest, Lock, error) {
 	for _, ds := range sm.specs {
 		if n == ds.n && v.Matches(ds.v) {
-			return ProjectInfo{
-				N:        ds.n,
-				V:        ds.v,
-				Manifest: ds,
-				Lock:     dummyLock{},
-			}, nil
+			return ds, dummyLock{}, nil
 		}
 	}
 
 	// TODO proper solver-type errors
-	return ProjectInfo{}, fmt.Errorf("Project '%s' at version '%s' could not be found", n, v)
+	return nil, nil, fmt.Errorf("Project '%s' at version '%s' could not be found", n, v)
 }
 
 func (sm *depspecSourceManager) ExternalReach(n ProjectName, v Version) (map[string][]string, error) {
@@ -976,25 +981,27 @@
 	return sm.specs
 }
 
+func (sm *depspecSourceManager) ignore() map[string]bool {
+	return sm.ig
+}
+
 type depspecBridge struct {
 	*bridge
 }
 
 // override computeRootReach() on bridge to read directly out of the depspecs
-func (b *depspecBridge) computeRootReach(path string) ([]string, error) {
+func (b *depspecBridge) computeRootReach() ([]string, error) {
 	// This only gets called for the root project, so grab that one off the test
 	// source manager
 	dsm := b.sm.(fixSM)
 	root := dsm.rootSpec()
-	if string(root.n) != path {
-		return nil, fmt.Errorf("Expected only root project %q to computeRootReach(), got %q", root.n, path)
-	}
 
 	ptree, err := dsm.ListPackages(root.n, nil)
 	if err != nil {
 		return nil, err
 	}
-	return ptree.ListExternalImports(true, true)
+
+	return ptree.ListExternalImports(true, true, dsm.ignore())
 }
 
 // override verifyRoot() on bridge to prevent any filesystem interaction
@@ -1008,7 +1015,7 @@
 }
 
 func (b *depspecBridge) listPackages(id ProjectIdentifier, v Version) (PackageTree, error) {
-	return b.sm.ListPackages(b.key(id), v)
+	return b.sm.(fixSM).ListPackages(b.key(id), v)
 }
 
 // override deduceRemoteRepo on bridge to make all our pkg/project mappings work
@@ -1032,12 +1039,12 @@
 var _ Lock = fixLock{}
 
 // impl Spec interface
-func (ds depspec) GetDependencies() []ProjectDep {
+func (ds depspec) DependencyConstraints() []ProjectDep {
 	return ds.deps
 }
 
 // impl Spec interface
-func (ds depspec) GetDevDependencies() []ProjectDep {
+func (ds depspec) TestDependencyConstraints() []ProjectDep {
 	return ds.devdeps
 }
 
diff --git a/vendor/github.com/sdboyer/vsolver/solve_bimodal_test.go b/vendor/github.com/sdboyer/vsolver/solve_bimodal_test.go
index 119ced0..21df3cb 100644
--- a/vendor/github.com/sdboyer/vsolver/solve_bimodal_test.go
+++ b/vendor/github.com/sdboyer/vsolver/solve_bimodal_test.go
@@ -347,6 +347,46 @@
 		},
 		errp: []string{"d", "a", "d"},
 	},
+	// Check ignores on the root project
+	"ignore in double-subpkg": {
+		ds: []depspec{
+			dsp(dsv("root 0.0.0"),
+				pkg("root", "root/foo"),
+				pkg("root/foo", "root/bar", "b"),
+				pkg("root/bar", "a"),
+			),
+			dsp(dsv("a 1.0.0"),
+				pkg("a"),
+			),
+			dsp(dsv("b 1.0.0"),
+				pkg("b"),
+			),
+		},
+		ignore: []string{"root/bar"},
+		r: mkresults(
+			"b 1.0.0",
+		),
+	},
+	// Ignores on a dep pkg
+	"ignore through dep pkg": {
+		ds: []depspec{
+			dsp(dsv("root 0.0.0"),
+				pkg("root", "root/foo"),
+				pkg("root/foo", "a"),
+			),
+			dsp(dsv("a 1.0.0"),
+				pkg("a", "a/bar"),
+				pkg("a/bar", "b"),
+			),
+			dsp(dsv("b 1.0.0"),
+				pkg("b"),
+			),
+		},
+		ignore: []string{"a/bar"},
+		r: mkresults(
+			"a 1.0.0",
+		),
+	},
 }
 
 // tpkg is a representation of a single package. It has its own import path, as
@@ -375,6 +415,8 @@
 	errp []string
 	// request up/downgrade to all projects
 	changeall bool
+	// pkgs to ignore
+	ignore []string
 }
 
 func (f bimodalFixture) name() string {
@@ -406,9 +448,10 @@
 
 var _ SourceManager = &bmSourceManager{}
 
-func newbmSM(ds []depspec) *bmSourceManager {
-	sm := &bmSourceManager{}
-	sm.specs = ds
+func newbmSM(ds []depspec, ignore []string) *bmSourceManager {
+	sm := &bmSourceManager{
+		depspecSourceManager: *newdepspecSM(ds, ignore),
+	}
 	sm.rm = computeBimodalExternalMap(ds)
 
 	return sm
diff --git a/vendor/github.com/sdboyer/vsolver/solve_test.go b/vendor/github.com/sdboyer/vsolver/solve_test.go
index 66dcd91..5c54683 100644
--- a/vendor/github.com/sdboyer/vsolver/solve_test.go
+++ b/vendor/github.com/sdboyer/vsolver/solve_test.go
@@ -6,6 +6,7 @@
 	"io/ioutil"
 	"log"
 	"os"
+	"reflect"
 	"sort"
 	"strings"
 	"testing"
@@ -59,13 +60,13 @@
 	if testing.Verbose() {
 		stderrlog.Printf("[[fixture %q]]", fix.n)
 	}
-	sm := newdepspecSM(fix.ds)
+	sm := newdepspecSM(fix.ds, nil)
 
 	args := SolveArgs{
-		Root: string(fix.ds[0].Name()),
-		N:    ProjectName(fix.ds[0].Name()),
-		M:    fix.ds[0],
-		L:    dummyLock{},
+		Root:     string(fix.ds[0].Name()),
+		Name:     ProjectName(fix.ds[0].Name()),
+		Manifest: fix.ds[0],
+		Lock:     dummyLock{},
 	}
 
 	o := SolveOpts{
@@ -74,7 +75,7 @@
 	}
 
 	if fix.l != nil {
-		args.L = fix.l
+		args.Lock = fix.l
 	}
 
 	res, err = fixSolve(args, o, sm)
@@ -112,13 +113,14 @@
 	if testing.Verbose() {
 		stderrlog.Printf("[[fixture %q]]", fix.n)
 	}
-	sm := newbmSM(fix.ds)
+	sm := newbmSM(fix.ds, fix.ignore)
 
 	args := SolveArgs{
-		Root: string(fix.ds[0].Name()),
-		N:    ProjectName(fix.ds[0].Name()),
-		M:    fix.ds[0],
-		L:    dummyLock{},
+		Root:     string(fix.ds[0].Name()),
+		Name:     ProjectName(fix.ds[0].Name()),
+		Manifest: fix.ds[0],
+		Lock:     dummyLock{},
+		Ignore:   fix.ignore,
 	}
 
 	o := SolveOpts{
@@ -127,7 +129,7 @@
 	}
 
 	if fix.l != nil {
-		args.L = fix.l
+		args.Lock = fix.l
 	}
 
 	res, err = fixSolve(args, o, sm)
@@ -144,7 +146,7 @@
 		}
 
 		switch fail := err.(type) {
-		case *BadOptsFailure:
+		case *badOptsFailure:
 			t.Errorf("(fixture: %q) Unexpected bad opts failure solve error: %s", fix.name(), err)
 		case *noVersionError:
 			if errp[0] != string(fail.pn.LocalName) { // TODO identifierify
@@ -191,7 +193,7 @@
 		t.Errorf("(fixture: %q) Solver succeeded, but expected failure", fix.name())
 	} else {
 		r := res.(result)
-		if fix.maxTries() > 0 && r.att > fix.maxTries() {
+		if fix.maxTries() > 0 && r.Attempts() > fix.maxTries() {
 			t.Errorf("(fixture: %q) Solver completed in %v attempts, but expected %v or fewer", fix.name(), r.att, fix.maxTries())
 		}
 
@@ -199,7 +201,7 @@
 		rp := make(map[string]Version)
 		for _, p := range r.p {
 			pa := p.toAtom()
-			rp[string(pa.Ident.LocalName)] = pa.Version
+			rp[string(pa.id.LocalName)] = pa.v
 		}
 
 		fixlen, rlen := len(fix.result()), len(rp)
@@ -265,17 +267,17 @@
 	pd.Constraint = Revision("foorev")
 	fix.ds[0].deps[0] = pd
 
-	sm := newdepspecSM(fix.ds)
+	sm := newdepspecSM(fix.ds, nil)
 
 	l2 := make(fixLock, 1)
 	copy(l2, fix.l)
 	l2[0].v = nil
 
 	args := SolveArgs{
-		Root: string(fix.ds[0].Name()),
-		N:    ProjectName(fix.ds[0].Name()),
-		M:    fix.ds[0],
-		L:    l2,
+		Root:     string(fix.ds[0].Name()),
+		Name:     ProjectName(fix.ds[0].Name()),
+		Manifest: fix.ds[0],
+		Lock:     l2,
 	}
 
 	res, err := fixSolve(args, SolveOpts{}, sm)
@@ -289,29 +291,29 @@
 		projs = append(projs, string(e.pn.LocalName)) // TODO identifierify
 	case *disjointConstraintFailure:
 		for _, f := range e.failsib {
-			projs = append(projs, string(f.Depender.Ident.LocalName))
+			projs = append(projs, string(f.depender.id.LocalName))
 		}
 	case *versionNotAllowedFailure:
 		for _, f := range e.failparent {
-			projs = append(projs, string(f.Depender.Ident.LocalName))
+			projs = append(projs, string(f.depender.id.LocalName))
 		}
 	case *constraintNotAllowedFailure:
 		// No sane way of knowing why the currently selected version is
 		// selected, so do nothing
 	case *sourceMismatchFailure:
-		projs = append(projs, string(e.prob.Ident.LocalName))
+		projs = append(projs, string(e.prob.id.LocalName))
 		for _, c := range e.sel {
-			projs = append(projs, string(c.Depender.Ident.LocalName))
+			projs = append(projs, string(c.depender.id.LocalName))
 		}
 	case *checkeeHasProblemPackagesFailure:
-		projs = append(projs, string(e.goal.Ident.LocalName))
+		projs = append(projs, string(e.goal.id.LocalName))
 		for _, errdep := range e.failpkg {
 			for _, atom := range errdep.deppers {
-				projs = append(projs, string(atom.Ident.LocalName))
+				projs = append(projs, string(atom.id.LocalName))
 			}
 		}
 	case *depHasProblemPackagesFailure:
-		projs = append(projs, string(e.goal.Depender.Ident.LocalName), string(e.goal.Dep.Ident.LocalName))
+		projs = append(projs, string(e.goal.depender.id.LocalName), string(e.goal.dep.Ident.LocalName))
 	default:
 		panic("unknown failtype")
 	}
@@ -320,7 +322,7 @@
 }
 
 func TestBadSolveOpts(t *testing.T) {
-	sm := newdepspecSM(basicFixtures[0].ds)
+	sm := newdepspecSM(basicFixtures[0].ds, nil)
 
 	o := SolveOpts{}
 	args := SolveArgs{}
@@ -329,8 +331,8 @@
 		t.Errorf("Should have errored on missing manifest")
 	}
 
-	p, _ := sm.GetProjectInfo(basicFixtures[0].ds[0].n, basicFixtures[0].ds[0].v)
-	args.M = p.Manifest
+	m, _, _ := sm.GetProjectInfo(basicFixtures[0].ds[0].n, basicFixtures[0].ds[0].v)
+	args.Manifest = m
 	_, err = Prepare(args, o, sm)
 	if err == nil {
 		t.Errorf("Should have errored on empty root")
@@ -342,7 +344,7 @@
 		t.Errorf("Should have errored on empty name")
 	}
 
-	args.N = "root"
+	args.Name = "root"
 	_, err = Prepare(args, o, sm)
 	if err != nil {
 		t.Errorf("Basic conditions satisfied, solve should have gone through, err was %s", err)
@@ -360,3 +362,27 @@
 		t.Errorf("Basic conditions re-satisfied, solve should have gone through, err was %s", err)
 	}
 }
+
+func TestIgnoreDedupe(t *testing.T) {
+	fix := basicFixtures[0]
+
+	ig := []string{"foo", "foo", "bar"}
+	args := SolveArgs{
+		Root:     string(fix.ds[0].Name()),
+		Name:     ProjectName(fix.ds[0].Name()),
+		Manifest: fix.ds[0],
+		Ignore:   ig,
+	}
+
+	s, _ := Prepare(args, SolveOpts{}, newdepspecSM(basicFixtures[0].ds, nil))
+	ts := s.(*solver)
+
+	expect := map[string]bool{
+		"foo": true,
+		"bar": true,
+	}
+
+	if !reflect.DeepEqual(ts.ig, expect) {
+		t.Errorf("Expected solver's ignore list to be deduplicated map, got %s", ts.ig)
+	}
+}
diff --git a/vendor/github.com/sdboyer/vsolver/solver.go b/vendor/github.com/sdboyer/vsolver/solver.go
index 9b3782a..0ea3dbe 100644
--- a/vendor/github.com/sdboyer/vsolver/solver.go
+++ b/vendor/github.com/sdboyer/vsolver/solver.go
@@ -15,8 +15,8 @@
 
 var (
 	// With a random revision and no name, collisions are unlikely
-	nilpa = ProjectAtom{
-		Version: Revision(strconv.FormatInt(rand.Int63(), 36)),
+	nilpa = atom{
+		v: Revision(strconv.FormatInt(rand.Int63(), 36)),
 	}
 )
 
@@ -27,17 +27,22 @@
 
 	// The 'name' of the project. Required. This should (must?) correspond to subpath of
 	// Root that exists under a GOPATH.
-	N ProjectName
+	Name ProjectName
 
 	// The root manifest. Required. This contains all the dependencies, constraints, and
 	// other controls available to the root project.
-	M Manifest
+	Manifest Manifest
 
 	// The root lock. Optional. Generally, this lock is the output of a previous solve run.
 	//
 	// If provided, the solver will attempt to preserve the versions specified
 	// in the lock, unless ToChange or ChangeAll settings indicate otherwise.
-	L Lock
+	Lock Lock
+
+	// A list of packages (import paths) to ignore. These can be in the root
+	// project, or from elsewhere. Ignoring a package means that both it and its
+	// imports will be disregarded by all relevant solver operations.
+	Ignore []string
 }
 
 // SolveOpts holds additional options that govern solving behavior.
@@ -115,11 +120,15 @@
 	// removal.
 	unsel *unselected
 
+	// Map of packages to ignore. This is derived by converting SolveArgs.Ignore
+	// into a map during solver prep - which also, nicely, deduplicates it.
+	ig map[string]bool
+
 	// A list of all the currently active versionQueues in the solver. The set
 	// of projects represented here corresponds closely to what's in s.sel,
 	// although s.sel will always contain the root project, and s.versions never
 	// will.
-	versions []*versionQueue // TODO rename to pvq
+	versions []*versionQueue // TODO rename to vq
 
 	// A map of the ProjectName (local names) that should be allowed to change
 	chng map[ProjectName]struct{}
@@ -143,32 +152,49 @@
 	Solve() (Result, error)
 }
 
-// Prepare reads and validates the provided SolveArgs and SolveOpts.
+// Prepare readies a Solver for use.
 //
-// If a problem with the inputs is detected, an error is returned. Otherwise, a
+// This function reads and validates the provided SolveArgs and SolveOpts. If a
+// problem with the inputs is detected, an error is returned. Otherwise, a
 // Solver is returned, ready to hash and check inputs or perform a solving run.
-func Prepare(in SolveArgs, opts SolveOpts, sm SourceManager) (Solver, error) {
+func Prepare(args SolveArgs, opts SolveOpts, sm SourceManager) (Solver, error) {
 	// local overrides would need to be handled first.
 	// TODO local overrides! heh
 
-	if in.M == nil {
-		return nil, BadOptsFailure("Opts must include a manifest.")
+	if args.Manifest == nil {
+		return nil, badOptsFailure("Opts must include a manifest.")
 	}
-	if in.Root == "" {
-		return nil, BadOptsFailure("Opts must specify a non-empty string for the project root directory. If cwd is desired, use \".\"")
+	if args.Root == "" {
+		return nil, badOptsFailure("Opts must specify a non-empty string for the project root directory. If cwd is desired, use \".\"")
 	}
-	if in.N == "" {
-		return nil, BadOptsFailure("Opts must include a project name. This should be the intended root import path of the project.")
+	if args.Name == "" {
+		return nil, badOptsFailure("Opts must include a project name. This should be the intended root import path of the project.")
 	}
 	if opts.Trace && opts.TraceLogger == nil {
-		return nil, BadOptsFailure("Trace requested, but no logger provided.")
+		return nil, badOptsFailure("Trace requested, but no logger provided.")
+	}
+
+	// Ensure the ignore map is at least initialized
+	ig := make(map[string]bool)
+	if len(args.Ignore) > 0 {
+		for _, pkg := range args.Ignore {
+			ig[pkg] = true
+		}
 	}
 
 	s := &solver{
-		args: in,
+		args: args,
 		o:    opts,
-		b:    newBridge(in.N, in.Root, sm, opts.Downgrade),
-		tl:   opts.TraceLogger,
+		ig:   ig,
+		b: &bridge{
+			sm:       sm,
+			sortdown: opts.Downgrade,
+			name:     args.Name,
+			root:     args.Root,
+			ignore:   ig,
+			vlists:   make(map[ProjectName][]Version),
+		},
+		tl: opts.TraceLogger,
 	}
 
 	// Initialize maps
@@ -178,7 +204,7 @@
 
 	// Initialize stacks and queues
 	s.sel = &selection{
-		deps: make(map[ProjectIdentifier][]Dependency),
+		deps: make(map[ProjectIdentifier][]dependency),
 		sm:   s.b,
 	}
 	s.unsel = &unselected{
@@ -202,10 +228,10 @@
 	}
 
 	// Prep safe, normalized versions of root manifest and lock data
-	s.rm = prepManifest(s.args.M, s.args.N)
+	s.rm = prepManifest(s.args.Manifest, s.args.Name)
 
-	if s.args.L != nil {
-		for _, lp := range s.args.L.Projects() {
+	if s.args.Lock != nil {
+		for _, lp := range s.args.Lock.Projects() {
 			s.rlm[lp.Ident().normalize()] = lp
 		}
 	}
@@ -250,7 +276,7 @@
 }
 
 // solve is the top-level loop for the SAT solving process.
-func (s *solver) solve() (map[ProjectAtom]map[string]struct{}, error) {
+func (s *solver) solve() (map[atom]map[string]struct{}, error) {
 	// Main solving loop
 	for {
 		bmi, has := s.nextUnselected()
@@ -286,9 +312,9 @@
 			}
 
 			s.selectAtomWithPackages(atomWithPackages{
-				atom: ProjectAtom{
-					Ident:   queue.id,
-					Version: queue.current(),
+				a: atom{
+					id: queue.id,
+					v:  queue.current(),
 				},
 				pl: bmi.pl,
 			})
@@ -307,9 +333,9 @@
 			// queue and just use the version given in what came back from
 			// s.sel.selected().
 			nawp := atomWithPackages{
-				atom: ProjectAtom{
-					Ident:   bmi.id,
-					Version: awp.atom.Version,
+				a: atom{
+					id: bmi.id,
+					v:  awp.a.v,
 				},
 				pl: bmi.pl,
 			}
@@ -334,15 +360,15 @@
 
 	// Getting this far means we successfully found a solution. Combine the
 	// selected projects and packages.
-	projs := make(map[ProjectAtom]map[string]struct{})
+	projs := make(map[atom]map[string]struct{})
 
 	// Skip the first project. It's always the root, and that shouldn't be
 	// included in results.
 	for _, sel := range s.sel.projects[1:] {
-		pm, exists := projs[sel.a.atom]
+		pm, exists := projs[sel.a.a]
 		if !exists {
 			pm = make(map[string]struct{})
-			projs[sel.a.atom] = pm
+			projs[sel.a.a] = pm
 		}
 
 		for _, path := range sel.a.pl {
@@ -355,18 +381,18 @@
 // selectRoot is a specialized selectAtomWithPackages, used solely to initially
 // populate the queues at the beginning of a solve run.
 func (s *solver) selectRoot() error {
-	pa := ProjectAtom{
-		Ident: ProjectIdentifier{
-			LocalName: s.args.N,
+	pa := atom{
+		id: ProjectIdentifier{
+			LocalName: s.args.Name,
 		},
 		// This is a hack so that the root project doesn't have a nil version.
 		// It's sort of OK because the root never makes it out into the results.
 		// We may need a more elegant solution if we discover other side
 		// effects, though.
-		Version: Revision(""),
+		v: Revision(""),
 	}
 
-	ptree, err := s.b.listPackages(pa.Ident, nil)
+	ptree, err := s.b.listPackages(pa.id, nil)
 	if err != nil {
 		return err
 	}
@@ -379,8 +405,8 @@
 	}
 
 	a := atomWithPackages{
-		atom: pa,
-		pl:   list,
+		a:  pa,
+		pl: list,
 	}
 
 	// Push the root project onto the queue.
@@ -389,8 +415,8 @@
 
 	// If we're looking for root's deps, get it from opts and local root
 	// analysis, rather than having the sm do it
-	mdeps := append(s.rm.GetDependencies(), s.rm.GetDevDependencies()...)
-	reach, err := s.b.computeRootReach(s.args.Root)
+	mdeps := append(s.rm.DependencyConstraints(), s.rm.TestDependencyConstraints()...)
+	reach, err := s.b.computeRootReach()
 	if err != nil {
 		return err
 	}
@@ -402,7 +428,7 @@
 	}
 
 	for _, dep := range deps {
-		s.sel.pushDep(Dependency{Depender: pa, Dep: dep})
+		s.sel.pushDep(dependency{depender: pa, dep: dep})
 		// Add all to unselected queue
 		s.names[dep.Ident.LocalName] = dep.Ident.netName()
 		heap.Push(s.unsel, bimodalIdentifier{id: dep.Ident, pl: dep.pl})
@@ -414,23 +440,23 @@
 func (s *solver) getImportsAndConstraintsOf(a atomWithPackages) ([]completeDep, error) {
 	var err error
 
-	if s.rm.Name() == a.atom.Ident.LocalName {
+	if s.rm.Name() == a.a.id.LocalName {
 		panic("Should never need to recheck imports/constraints from root during solve")
 	}
 
 	// Work through the source manager to get project info and static analysis
 	// information.
-	info, err := s.b.getProjectInfo(a.atom)
+	m, _, err := s.b.getProjectInfo(a.a)
 	if err != nil {
 		return nil, err
 	}
 
-	ptree, err := s.b.listPackages(a.atom.Ident, a.atom.Version)
+	ptree, err := s.b.listPackages(a.a.id, a.a.v)
 	if err != nil {
 		return nil, err
 	}
 
-	allex, err := ptree.ExternalReach(false, false)
+	allex, err := ptree.ExternalReach(false, false, s.ig)
 	if err != nil {
 		return nil, err
 	}
@@ -441,7 +467,7 @@
 	// the list
 	for _, pkg := range a.pl {
 		if expkgs, exists := allex[pkg]; !exists {
-			return nil, fmt.Errorf("Package %s does not exist within project %s", pkg, a.atom.Ident.errString())
+			return nil, fmt.Errorf("package %s does not exist within project %s", pkg, a.a.id.errString())
 		} else {
 			for _, ex := range expkgs {
 				exmap[ex] = struct{}{}
@@ -456,7 +482,7 @@
 		k++
 	}
 
-	deps := info.GetDependencies()
+	deps := m.DependencyConstraints()
 	// TODO add overrides here...if we impl the concept (which we should)
 
 	return s.intersectConstraintsWithImports(deps, reach)
@@ -615,9 +641,9 @@
 	for {
 		cur := q.current()
 		err := s.checkProject(atomWithPackages{
-			atom: ProjectAtom{
-				Ident:   q.id,
-				Version: cur,
+			a: atom{
+				id: q.id,
+				v:  cur,
 			},
 			pl: pl,
 		})
@@ -636,7 +662,7 @@
 		}
 	}
 
-	s.fail(s.sel.getDependenciesOn(q.id)[0].Depender.Ident)
+	s.fail(s.sel.getDependenciesOn(q.id)[0].depender.id)
 
 	// Return a compound error of all the new errors encountered during this
 	// attempt to find a new, valid version
@@ -655,7 +681,7 @@
 //
 // If any of these three conditions are true (or if the id cannot be found in
 // the root lock), then no atom will be returned.
-func (s *solver) getLockVersionIfValid(id ProjectIdentifier) (ProjectAtom, error) {
+func (s *solver) getLockVersionIfValid(id ProjectIdentifier) (atom, error) {
 	// If the project is specifically marked for changes, then don't look for a
 	// locked version.
 	if _, explicit := s.chng[id.LocalName]; explicit || s.o.ChangeAll {
@@ -719,9 +745,9 @@
 
 	s.logSolve("using root lock's version of %s", id.errString())
 
-	return ProjectAtom{
-		Ident:   id,
-		Version: v,
+	return atom{
+		id: id,
+		v:  v,
 	}, nil
 }
 
@@ -762,7 +788,7 @@
 			awp, proj = s.unselectLast()
 		}
 
-		if !q.id.eq(awp.atom.Ident) {
+		if !q.id.eq(awp.a.id) {
 			panic("canary - version queue stack and selected project stack are out of alignment")
 		}
 
@@ -776,9 +802,9 @@
 				// Found one! Put it back on the selected queue and stop
 				// backtracking
 				s.selectAtomWithPackages(atomWithPackages{
-					atom: ProjectAtom{
-						Ident:   q.id,
-						Version: q.current(),
+					a: atom{
+						id: q.id,
+						v:  q.current(),
 					},
 					pl: awp.pl,
 				})
@@ -912,7 +938,7 @@
 // new resultant deps to the unselected queue.
 func (s *solver) selectAtomWithPackages(a atomWithPackages) {
 	s.unsel.remove(bimodalIdentifier{
-		id: a.atom.Ident,
+		id: a.a.id,
 		pl: a.pl,
 	})
 
@@ -926,7 +952,7 @@
 	}
 
 	for _, dep := range deps {
-		s.sel.pushDep(Dependency{Depender: a.atom, Dep: dep})
+		s.sel.pushDep(dependency{depender: a.a, dep: dep})
 		// Go through all the packages introduced on this dep, selecting only
 		// the ones where the only depper on them is what we pushed in. Then,
 		// put those into the unselected queue.
@@ -956,7 +982,7 @@
 // order to enqueue the selection.
 func (s *solver) selectPackages(a atomWithPackages) {
 	s.unsel.remove(bimodalIdentifier{
-		id: a.atom.Ident,
+		id: a.a.id,
 		pl: a.pl,
 	})
 
@@ -970,7 +996,7 @@
 	}
 
 	for _, dep := range deps {
-		s.sel.pushDep(Dependency{Depender: a.atom, Dep: dep})
+		s.sel.pushDep(dependency{depender: a.a, dep: dep})
 		// Go through all the packages introduced on this dep, selecting only
 		// the ones where the only depper on them is what we pushed in. Then,
 		// put those into the unselected queue.
@@ -994,7 +1020,7 @@
 
 func (s *solver) unselectLast() (atomWithPackages, bool) {
 	awp, first := s.sel.popSelection()
-	heap.Push(s.unsel, bimodalIdentifier{id: awp.atom.Ident, pl: awp.pl})
+	heap.Push(s.unsel, bimodalIdentifier{id: awp.a.id, pl: awp.pl})
 
 	deps, err := s.getImportsAndConstraintsOf(awp)
 	if err != nil {
@@ -1078,15 +1104,15 @@
 }
 
 // simple (temporary?) helper just to convert atoms into locked projects
-func pa2lp(pa ProjectAtom, pkgs map[string]struct{}) LockedProject {
+func pa2lp(pa atom, pkgs map[string]struct{}) LockedProject {
 	lp := LockedProject{
-		pi: pa.Ident.normalize(), // shouldn't be necessary, but normalize just in case
+		pi: pa.id.normalize(), // shouldn't be necessary, but normalize just in case
 		// path is unnecessary duplicate information now, but if we ever allow
 		// nesting as a conflict resolution mechanism, it will become valuable
-		path: string(pa.Ident.LocalName),
+		path: string(pa.id.LocalName),
 	}
 
-	switch v := pa.Version.(type) {
+	switch v := pa.v.(type) {
 	case UnpairedVersion:
 		lp.v = v
 	case Revision:
@@ -1099,7 +1125,7 @@
 	}
 
 	for pkg := range pkgs {
-		lp.pkgs = append(lp.pkgs, strings.TrimPrefix(pkg, string(pa.Ident.LocalName)+string(os.PathSeparator)))
+		lp.pkgs = append(lp.pkgs, strings.TrimPrefix(pkg, string(pa.id.LocalName)+string(os.PathSeparator)))
 	}
 	sort.Strings(lp.pkgs)
 
diff --git a/vendor/github.com/sdboyer/vsolver/source_manager.go b/vendor/github.com/sdboyer/vsolver/source_manager.go
index 6ab9c01..3100b37 100644
--- a/vendor/github.com/sdboyer/vsolver/source_manager.go
+++ b/vendor/github.com/sdboyer/vsolver/source_manager.go
@@ -10,15 +10,48 @@
 	"github.com/Masterminds/vcs"
 )
 
+// A SourceManager is responsible for retrieving, managing, and interrogating
+// source repositories. Its primary purpose is to serve the needs of a Solver,
+// but it is handy for other purposes, as well.
+//
+// vsolver's built-in SourceManager, accessible via NewSourceManager(), is
+// intended to be generic and sufficient for any purpose. It provides some
+// additional semantics around the methods defined here.
 type SourceManager interface {
-	GetProjectInfo(ProjectName, Version) (ProjectInfo, error)
-	ListVersions(ProjectName) ([]Version, error)
+	// RepoExists checks if a repository exists, either upstream or in the
+	// SourceManager's central repository cache.
 	RepoExists(ProjectName) (bool, error)
+
+	// VendorCodeExists checks if a code tree exists within the stored vendor
+	// directory for the the provided import path name.
 	VendorCodeExists(ProjectName) (bool, error)
+
+	// ListVersions retrieves a list of the available versions for a given
+	// repository name.
+	ListVersions(ProjectName) ([]Version, error)
+
+	// ListPackages retrieves a tree of the Go packages at or below the provided
+	// import path, at the provided version.
 	ListPackages(ProjectName, Version) (PackageTree, error)
+
+	// GetProjectInfo returns manifest and lock information for the provided
+	// import path. vsolver currently requires that projects be rooted at their
+	// repository root, which means that this ProjectName must also be a
+	// repository root.
+	GetProjectInfo(ProjectName, Version) (Manifest, Lock, error)
+
+	// ExportProject writes out the tree of the provided import path, at the
+	// provided version, to the provided directory.
 	ExportProject(ProjectName, Version, string) error
+
+	// Release lets go of any locks held by the SourceManager.
 	Release()
-	// Flush()
+}
+
+// A ProjectAnalyzer is responsible for analyzing a path for Manifest and Lock
+// information. Tools relying on vsolver must implement one.
+type ProjectAnalyzer interface {
+	GetInfo(build.Context, ProjectName) (Manifest, Lock, error)
 }
 
 // ExistenceError is a specialized error type that, in addition to the standard
@@ -45,15 +78,33 @@
 	//pme               map[ProjectName]error
 }
 
-// Holds a ProjectManager, caches of the managed project's data, and information
+// Holds a projectManager, caches of the managed project's data, and information
 // about the freshness of those caches
 type pmState struct {
-	pm   ProjectManager
+	pm   *projectManager
 	cf   *os.File // handle for the cache file
 	vcur bool     // indicates that we've called ListVersions()
 }
 
-func NewSourceManager(cachedir, basedir string, force bool, an ProjectAnalyzer) (SourceManager, error) {
+// NewSourceManager produces an instance of vsolver's built-in SourceManager. It
+// takes a cache directory (where local instances of upstream repositories are
+// stored), a base directory for the project currently being worked on, and a
+// force flag indicating whether to overwrite the global cache lock file (if
+// present).
+//
+// The returned SourceManager aggressively caches
+// information wherever possible. It is recommended that, if tools need to do preliminary,
+// work involving upstream repository analysis prior to invoking a solve run,
+// that they create this SourceManager as early as possible and use it to their
+// ends. That way, the solver can benefit from any caches that may have already
+// been warmed.
+//
+// vsolver's SourceManager is intended to be threadsafe (if it's not, please
+// file a bug!). It should certainly be safe to reuse from one solving run to
+// the next; however, the fact that it takes a basedir as an argument makes it
+// much less useful for simultaneous use by separate solvers operating on
+// different root projects. This architecture may change in the future.
+func NewSourceManager(an ProjectAnalyzer, cachedir, basedir string, force bool) (SourceManager, error) {
 	if an == nil {
 		return nil, fmt.Errorf("A ProjectAnalyzer must be provided to the SourceManager.")
 	}
@@ -84,22 +135,32 @@
 		ctx:      ctx,
 		an:       an,
 	}, nil
-	// recovery in a defer to be really proper, though
 }
 
+// Release lets go of any locks held by the SourceManager.
+//
+// This will also call Flush(), which will write any relevant caches to disk.
 func (sm *sourceManager) Release() {
 	os.Remove(path.Join(sm.cachedir, "sm.lock"))
 }
 
-func (sm *sourceManager) GetProjectInfo(n ProjectName, v Version) (ProjectInfo, error) {
+// GetProjectInfo returns manifest and lock information for the provided import
+// path. vsolver currently requires that projects be rooted at their repository
+// root, which means that this ProjectName must also be a repository root.
+//
+// The work of producing the manifest and lock information is delegated to the
+// injected ProjectAnalyzer.
+func (sm *sourceManager) GetProjectInfo(n ProjectName, v Version) (Manifest, Lock, error) {
 	pmc, err := sm.getProjectManager(n)
 	if err != nil {
-		return ProjectInfo{}, err
+		return nil, nil, err
 	}
 
 	return pmc.pm.GetInfoAt(v)
 }
 
+// ListPackages retrieves a tree of the Go packages at or below the provided
+// import path, at the provided version.
 func (sm *sourceManager) ListPackages(n ProjectName, v Version) (PackageTree, error) {
 	pmc, err := sm.getProjectManager(n)
 	if err != nil {
@@ -109,6 +170,17 @@
 	return pmc.pm.ListPackages(v)
 }
 
+// ListVersions retrieves a list of the available versions for a given
+// repository name.
+//
+// The list is not sorted; while it may be retuend in the order that the
+// underlying VCS reports version information, no guarantee is made. It is
+// expected that the caller either not care about order, or sort the result
+// themselves.
+//
+// This list is always retrieved from upstream; if upstream is not accessible
+// (network outage, access issues, or the resource actually went away), an error
+// will be returned.
 func (sm *sourceManager) ListVersions(n ProjectName) ([]Version, error) {
 	pmc, err := sm.getProjectManager(n)
 	if err != nil {
@@ -119,13 +191,15 @@
 	return pmc.pm.ListVersions()
 }
 
+// VendorCodeExists checks if a code tree exists within the stored vendor
+// directory for the the provided import path name.
 func (sm *sourceManager) VendorCodeExists(n ProjectName) (bool, error) {
 	pms, err := sm.getProjectManager(n)
 	if err != nil {
 		return false, err
 	}
 
-	return pms.pm.CheckExistence(ExistsInVendorRoot), nil
+	return pms.pm.CheckExistence(existsInVendorRoot), nil
 }
 
 func (sm *sourceManager) RepoExists(n ProjectName) (bool, error) {
@@ -134,9 +208,11 @@
 		return false, err
 	}
 
-	return pms.pm.CheckExistence(ExistsInCache) || pms.pm.CheckExistence(ExistsUpstream), nil
+	return pms.pm.CheckExistence(existsInCache) || pms.pm.CheckExistence(existsUpstream), nil
 }
 
+// ExportProject writes out the tree of the provided import path, at the
+// provided version, to the provided directory.
 func (sm *sourceManager) ExportProject(n ProjectName, v Version, to string) error {
 	pms, err := sm.getProjectManager(n)
 	if err != nil {
@@ -207,7 +283,7 @@
 		//}
 
 		dc = &projectDataCache{
-			Infos: make(map[Revision]ProjectInfo),
+			Infos: make(map[Revision]projectInfo),
 			VMap:  make(map[Version]Revision),
 			RMap:  make(map[Revision][]Version),
 		}
diff --git a/vendor/github.com/sdboyer/vsolver/types.go b/vendor/github.com/sdboyer/vsolver/types.go
index ed15bf0..0cb54e7 100644
--- a/vendor/github.com/sdboyer/vsolver/types.go
+++ b/vendor/github.com/sdboyer/vsolver/types.go
@@ -64,14 +64,14 @@
 
 type ProjectName string
 
-type ProjectAtom struct {
-	Ident   ProjectIdentifier
-	Version Version
+type atom struct {
+	id ProjectIdentifier
+	v  Version
 }
 
 type atomWithPackages struct {
-	atom ProjectAtom
-	pl   []string
+	a  atom
+	pl []string
 }
 
 type ProjectDep struct {
@@ -105,15 +105,7 @@
 	pl []string
 }
 
-type Dependency struct {
-	Depender ProjectAtom
-	Dep      completeDep
-}
-
-// ProjectInfo holds manifest and lock for a ProjectName at a Version
-type ProjectInfo struct {
-	N ProjectName
-	V Version
-	Manifest
-	Lock
+type dependency struct {
+	depender atom
+	dep      completeDep
 }
diff --git a/vendor/github.com/sdboyer/vsolver/version.go b/vendor/github.com/sdboyer/vsolver/version.go
index 804402f..bb30631 100644
--- a/vendor/github.com/sdboyer/vsolver/version.go
+++ b/vendor/github.com/sdboyer/vsolver/version.go
@@ -10,11 +10,10 @@
 //
 // Version is an interface, but it contains private methods, which restricts it
 // to vsolver's own internal implementations. We do this for the confluence of
-// two reasons:
-// - the implementation of Versions is complete (there is no case in which we'd
-//   need other types)
-// - the implementation relies on type magic under the hood, which would
-//   be unsafe to do if other dynamic types could be hiding behind the interface.
+// two reasons: the implementation of Versions is complete (there is no case in
+// which we'd need other types), and the implementation relies on type magic
+// under the hood, which would be unsafe to do if other dynamic types could be
+// hiding behind the interface.
 type Version interface {
 	Constraint
 	// Indicates the type of version - Revision, Branch, Version, or Semver
@@ -36,7 +35,7 @@
 // VersionPair by indicating the version's corresponding, underlying Revision.
 type UnpairedVersion interface {
 	Version
-	// Is takes the underlying Revision that this (Unpaired)Version corresponds
+	// Is takes the underlying Revision that this UnpairedVersion corresponds
 	// to and unites them into a PairedVersion.
 	Is(Revision) PairedVersion
 	// Ensures it is impossible to be both a PairedVersion and an
diff --git a/vendor/github.com/sdboyer/vsolver/version_queue.go b/vendor/github.com/sdboyer/vsolver/version_queue.go
index 34382fc..22e7b0c 100644
--- a/vendor/github.com/sdboyer/vsolver/version_queue.go
+++ b/vendor/github.com/sdboyer/vsolver/version_queue.go
@@ -19,7 +19,7 @@
 	hasLock, allLoaded bool
 }
 
-func newVersionQueue(id ProjectIdentifier, lockv ProjectAtom, sm sourceBridge) (*versionQueue, error) {
+func newVersionQueue(id ProjectIdentifier, lockv atom, sm sourceBridge) (*versionQueue, error) {
 	vq := &versionQueue{
 		id: id,
 		sm: sm,
@@ -27,7 +27,7 @@
 
 	if lockv != nilpa {
 		vq.hasLock = true
-		vq.pi = append(vq.pi, lockv.Version)
+		vq.pi = append(vq.pi, lockv.v)
 	} else {
 		var err error
 		vq.pi, err = vq.sm.listVersions(vq.id)