diff --git a/internal/core/adt/expr.go b/internal/core/adt/expr.go
index 939ef6e..44891e0 100644
--- a/internal/core/adt/expr.go
+++ b/internal/core/adt/expr.go
@@ -980,10 +980,12 @@
 	Value Value   // Could become Value later, using disjunctions for defaults.
 }
 
+// Kind returns the kind mask of this parameter.
 func (p Param) Kind() Kind {
 	return p.Value.Kind()
 }
 
+// Default reports the default value for this Param or nil if there is none.
 func (p Param) Default() Value {
 	d, ok := p.Value.(*Disjunction)
 	if !ok || d.NumDefaults != 1 {
@@ -1009,8 +1011,12 @@
 	return &BuiltinValidator{Builtin: x}
 }
 
-func (x *Builtin) IsValidator(numArgs int) bool {
-	return len(x.Params)-1 == numArgs && x.Result&^BoolKind == 0
+// IsValidator reports whether b should be interpreted as a Validator for the
+// given number of arguments.
+func (b *Builtin) IsValidator(numArgs int) bool {
+	return numArgs == len(b.Params)-1 &&
+		b.Result&^BoolKind == 0 &&
+		b.Params[numArgs].Default() == nil
 }
 
 func bottom(v Value) *Bottom {
@@ -1040,21 +1046,35 @@
 		args = append(args, v)
 	}
 	for i, a := range args {
-		if x.Params[i].Kind() != BottomKind {
-			if b := bottom(a); b != nil {
-				return b
+		if x.Params[i].Kind() == BottomKind {
+			continue
+		}
+		if b := bottom(a); b != nil {
+			return b
+		}
+		if k := kind(a); x.Params[i].Kind()&k == BottomKind {
+			code := EvalError
+			b, _ := args[i].(*Bottom)
+			if b != nil {
+				code = b.Code
 			}
-			if k := kind(a); x.Params[i].Kind()&k == BottomKind {
-				code := EvalError
-				b, _ := args[i].(*Bottom)
-				if b != nil {
-					code = b.Code
-				}
-				c.addErrf(code, pos(a),
-					"cannot use %s (type %s) as %s in argument %d to %s",
-					a, k, x.Params[i].Kind(), i+1, fun)
-				return nil
+			c.addErrf(code, pos(a),
+				"cannot use %s (type %s) as %s in argument %d to %s",
+				a, k, x.Params[i].Kind(), i+1, fun)
+			return nil
+		}
+		v := x.Params[i].Value
+		if _, ok := v.(*BasicType); !ok {
+			env := c.Env(0)
+			x := &BinaryExpr{Op: AndOp, X: v, Y: a}
+			n := &Vertex{Conjuncts: []Conjunct{{env, x, 0}}}
+			c.Unifier.Unify(c, n, Finalized)
+			if _, ok := n.BaseValue.(*Bottom); ok {
+				c.addErrf(0, pos(a),
+					"cannot use %s as %s in argument %d to %s",
+					a, v, i+1, fun)
 			}
+			args[i] = n
 		}
 	}
 	return x.Func(c, args)
diff --git a/pkg/internal/builtin.go b/pkg/internal/builtin.go
index bbd0ccb..ab23868 100644
--- a/pkg/internal/builtin.go
+++ b/pkg/internal/builtin.go
@@ -55,9 +55,8 @@
 }
 
 type Param struct {
-	Kind    adt.Kind
-	Value   adt.Value // input constraint
-	Default adt.Value // may be nil
+	Kind  adt.Kind
+	Value adt.Value // input constraint (may be nil)
 }
 
 type Package struct {
@@ -112,16 +111,9 @@
 func toBuiltin(ctx *adt.OpContext, b *Builtin) *adt.Builtin {
 	params := make([]adt.Param, len(b.Params))
 	for i, p := range b.Params {
-		// TODO: use Value.
-		params[i].Value = &adt.BasicType{K: p.Kind}
-		if p.Default != nil {
-			params[i].Value = &adt.Disjunction{
-				NumDefaults: 1,
-				Values: []*adt.Vertex{
-					adt.ToVertex(p.Default),
-					adt.ToVertex(params[i].Value),
-				},
-			}
+		params[i].Value = p.Value
+		if params[i].Value == nil {
+			params[i].Value = &adt.BasicType{K: p.Kind}
 		}
 	}
 
diff --git a/pkg/path/testdata/example_nix_test.go b/pkg/path/example_nix_test.go
similarity index 100%
rename from pkg/path/testdata/example_nix_test.go
rename to pkg/path/example_nix_test.go
diff --git a/pkg/path/testdata/example_test.go b/pkg/path/example_test.go
similarity index 100%
rename from pkg/path/testdata/example_test.go
rename to pkg/path/example_test.go
diff --git a/pkg/path/manual.go b/pkg/path/manual.go
deleted file mode 100644
index 99525a7..0000000
--- a/pkg/path/manual.go
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2018 The CUE Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package path
-
-import "path"
-
-var split = path.Split
-
-// Split splits path immediately following the final slash and returns them as
-// the list [dir, file], separating it into a directory and file name component.
-// If there is no slash in path, Split returns an empty dir and file set to
-// path. The returned values have the property that path = dir+file.
-func Split(path string) []string {
-	file, dir := split(path)
-	return []string{file, dir}
-}
diff --git a/pkg/path/testdata/match.go b/pkg/path/match.go
similarity index 100%
rename from pkg/path/testdata/match.go
rename to pkg/path/match.go
diff --git a/pkg/path/testdata/match_test.go b/pkg/path/match_test.go
similarity index 100%
rename from pkg/path/testdata/match_test.go
rename to pkg/path/match_test.go
diff --git a/pkg/path/testdata/os.go b/pkg/path/os.go
similarity index 96%
rename from pkg/path/testdata/os.go
rename to pkg/path/os.go
index d5de0be..08592c3 100644
--- a/pkg/path/testdata/os.go
+++ b/pkg/path/os.go
@@ -14,6 +14,7 @@
 
 package path
 
+// OS must be a valid runtime.GOOS value or "unix".
 type OS string
 
 const (
diff --git a/pkg/path/path.go b/pkg/path/path.go
index bd82f26..9f29dd2 100644
--- a/pkg/path/path.go
+++ b/pkg/path/path.go
@@ -1,4 +1,4 @@
-// Copyright 2020 The CUE Authors
+// Copyright 2020 CUE Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,54 +12,80 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Copyright 2018 The Go Authors. All rights reserved.
+// Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:generate go run cuelang.org/go/internal/cmd/qgo -exclude=Split,Join extract path
-
+// Package filepath implements utility routines for manipulating filename paths
+// in a way compatible with the target operating system-defined file paths.
+//
+// The filepath package uses either forward slashes or backslashes,
+// depending on the operating system. To process paths such as URLs
+// that always use forward slashes regardless of the operating
+// system, see the path package.
 package path
 
-import "path"
+import (
+	"errors"
+	"strings"
+)
 
-// Match reports whether name matches the shell pattern.
-// The pattern syntax is:
-//
-//	pattern:
-//		{ term }
-//	term:
-//		'*'         matches any sequence of non-/ characters
-//		'?'         matches any single non-/ character
-//		'[' [ '^' ] { character-range } ']'
-//		            character class (must be non-empty)
-//		c           matches character c (c != '*', '?', '\\', '[')
-//		'\\' c      matches character c
-//
-//	character-range:
-//		c           matches character c (c != '\\', '-', ']')
-//		'\\' c      matches character c
-//		lo '-' hi   matches character c for lo <= c <= hi
-//
-// Match requires pattern to match all of name, not just a substring.
-// The only possible returned error is ErrBadPattern, when pattern
-// is malformed.
-//
-func Match(pattern, name string) (matched bool, err error) {
-	return path.Match(pattern, name)
+// A lazybuf is a lazily constructed path buffer.
+// It supports append, reading previously appended bytes,
+// and retrieving the final string. It does not allocate a buffer
+// to hold the output until that output diverges.
+type lazybuf struct {
+	path       string
+	buf        []byte
+	w          int
+	volAndPath string
+	volLen     int
+}
+
+func (b *lazybuf) index(i int) byte {
+	if b.buf != nil {
+		return b.buf[i]
+	}
+	return b.path[i]
+}
+
+func (b *lazybuf) append(c byte) {
+	if b.buf == nil {
+		if b.w < len(b.path) && b.path[b.w] == c {
+			b.w++
+			return
+		}
+		b.buf = make([]byte, len(b.path))
+		copy(b.buf, b.path[:b.w])
+	}
+	b.buf[b.w] = c
+	b.w++
+}
+
+func (b *lazybuf) string() string {
+	if b.buf == nil {
+		return b.volAndPath[:b.volLen+b.w]
+	}
+	return b.volAndPath[:b.volLen] + string(b.buf[:b.w])
 }
 
 // Clean returns the shortest path name equivalent to path
-// by purely lexical processing. It applies the following rules
+// by purely lexical processing. The default value for os is Unix.
+// It applies the following rules
 // iteratively until no further processing can be done:
 //
-//	1. Replace multiple slashes with a single slash.
+//	1. Replace multiple Separator elements with a single one.
 //	2. Eliminate each . path name element (the current directory).
 //	3. Eliminate each inner .. path name element (the parent directory)
 //	   along with the non-.. element that precedes it.
 //	4. Eliminate .. elements that begin a rooted path:
-//	   that is, replace "/.." by "/" at the beginning of a path.
+//	   that is, replace "/.." by "/" at the beginning of a path,
+//	   assuming Separator is '/'.
 //
-// The returned path ends in a slash only if it is the root "/".
+// The returned path ends in a slash only if it represents a root directory,
+// such as "/" on Unix or `C:\` on Windows.
+//
+// Finally, any occurrences of slash are replaced by Separator.
 //
 // If the result of this process is an empty string, Clean
 // returns the string ".".
@@ -67,38 +93,319 @@
 // See also Rob Pike, ``Lexical File Names in Plan 9 or
 // Getting Dot-Dot Right,''
 // https://9p.io/sys/doc/lexnames.html
-func Clean(path string) string { return pathClean(path) }
+func Clean(path string, os OS) string {
+	return clean(path, getOS(os))
+}
 
-var pathClean = path.Clean
+func clean(path string, os os) string {
+	originalPath := path
+	volLen := os.volumeNameLen(path)
+	path = path[volLen:]
+	if path == "" {
+		if volLen > 1 && originalPath[1] != ':' {
+			// should be UNC
+			return fromSlash(originalPath, os)
+		}
+		return originalPath + "."
+	}
+	rooted := os.IsPathSeparator(path[0])
+
+	// Invariants:
+	//	reading from path; r is index of next byte to process.
+	//	writing to buf; w is index of next byte to write.
+	//	dotdot is index in buf where .. must stop, either because
+	//		it is the leading slash or it is a leading ../../.. prefix.
+	n := len(path)
+	out := lazybuf{path: path, volAndPath: originalPath, volLen: volLen}
+	r, dotdot := 0, 0
+	if rooted {
+		out.append(os.Separator)
+		r, dotdot = 1, 1
+	}
+
+	for r < n {
+		switch {
+		case os.IsPathSeparator(path[r]):
+			// empty path element
+			r++
+		case path[r] == '.' && (r+1 == n || os.IsPathSeparator(path[r+1])):
+			// . element
+			r++
+		case path[r] == '.' && path[r+1] == '.' && (r+2 == n || os.IsPathSeparator(path[r+2])):
+			// .. element: remove to last separator
+			r += 2
+			switch {
+			case out.w > dotdot:
+				// can backtrack
+				out.w--
+				for out.w > dotdot && !os.IsPathSeparator(out.index(out.w)) {
+					out.w--
+				}
+			case !rooted:
+				// cannot backtrack, but not rooted, so append .. element.
+				if out.w > 0 {
+					out.append(os.Separator)
+				}
+				out.append('.')
+				out.append('.')
+				dotdot = out.w
+			}
+		default:
+			// real path element.
+			// add slash if needed
+			if rooted && out.w != 1 || !rooted && out.w != 0 {
+				out.append(os.Separator)
+			}
+			// copy element
+			for ; r < n && !os.IsPathSeparator(path[r]); r++ {
+				out.append(path[r])
+			}
+		}
+	}
+
+	// Turn empty string into "."
+	if out.w == 0 {
+		out.append('.')
+	}
+
+	return fromSlash(out.string(), os)
+}
+
+// ToSlash returns the result of replacing each separator character
+// in path with a slash ('/') character. Multiple separators are
+// replaced by multiple slashes.
+func ToSlash(path string, os OS) string {
+	return toSlash(path, getOS(os))
+}
+
+func toSlash(path string, os os) string {
+	if os.Separator == '/' {
+		return path
+	}
+	return strings.ReplaceAll(path, string(os.Separator), "/")
+}
+
+// FromSlash returns the result of replacing each slash ('/') character
+// in path with a separator character. Multiple slashes are replaced
+// by multiple separators.
+func FromSlash(path string, os OS) string {
+	return fromSlash(path, getOS(os))
+}
+
+func fromSlash(path string, os os) string {
+	if os.Separator == '/' {
+		return path
+	}
+	return strings.ReplaceAll(path, "/", string(os.Separator))
+}
+
+// SplitList splits a list of paths joined by the OS-specific ListSeparator,
+// usually found in PATH or GOPATH environment variables.
+// Unlike strings.Split, SplitList returns an empty slice when passed an empty
+// string.
+func SplitList(path string, os OS) []string {
+	return getOS(os).splitList(path)
+}
+
+// Split splits path immediately following the final slash and returns them as
+// the list [dir, file], separating it into a directory and file name component.
+// If there is no slash in path, Split returns an empty dir and file set to
+// path. The returned values have the property that path = dir+file.
+// The default value for os is Unix.
+func Split(path string, os OS) []string {
+	x := getOS(os)
+	vol := volumeName(path, x)
+	i := len(path) - 1
+	for i >= len(vol) && !x.IsPathSeparator(path[i]) {
+		i--
+	}
+	return []string{path[:i+1], path[i+1:]}
+}
+
+// Join joins any number of path elements into a single path,
+// separating them with an OS specific Separator. Empty elements
+// are ignored. The result is Cleaned. However, if the argument
+// list is empty or all its elements are empty, Join returns
+// an empty string.
+// On Windows, the result will only be a UNC path if the first
+// non-empty element is a UNC path.
+// The default value for os is Unix.
+func Join(elem []string, os OS) string {
+	return getOS(os).join(elem)
+}
 
 // Ext returns the file name extension used by path.
 // The extension is the suffix beginning at the final dot
-// in the final slash-separated element of path;
-// it is empty if there is no dot.
-func Ext(path string) string { return pathExt(path) }
+// in the final element of path; it is empty if there is
+// no dot. The default value for os is Unix.
+func Ext(path string, os OS) string {
+	x := getOS(os)
+	for i := len(path) - 1; i >= 0 && !x.IsPathSeparator(path[i]); i-- {
+		if path[i] == '.' {
+			return path[i:]
+		}
+	}
+	return ""
+}
 
-var pathExt = path.Ext
+// Resolve reports the path of sub relative to dir. If sub is an absolute path,
+// or if dir is empty, it will return sub. If sub is empty, it will return dir.
+// Resolve calls Clean on the result. The default value for os is Unix.
+func Resolve(dir, sub string, os OS) string {
+	x := getOS(os)
+	if x.IsAbs(sub) {
+		return clean(sub, x)
+	}
+	dir = clean(dir, x)
+	return x.join([]string{dir, sub})
+}
+
+// Rel returns a relative path that is lexically equivalent to targpath when
+// joined to basepath with an intervening separator. That is,
+// Join(basepath, Rel(basepath, targpath)) is equivalent to targpath itself.
+// On success, the returned path will always be relative to basepath,
+// even if basepath and targpath share no elements.
+// An error is returned if targpath can't be made relative to basepath or if
+// knowing the current working directory would be necessary to compute it.
+// Rel calls Clean on the result. The default value for os is Unix.
+func Rel(basepath, targpath string, os OS) (string, error) {
+	x := getOS(os)
+	baseVol := volumeName(basepath, x)
+	targVol := volumeName(targpath, x)
+	base := clean(basepath, x)
+	targ := clean(targpath, x)
+	if x.sameWord(targ, base) {
+		return ".", nil
+	}
+	base = base[len(baseVol):]
+	targ = targ[len(targVol):]
+	if base == "." {
+		base = ""
+	}
+	// Can't use IsAbs - `\a` and `a` are both relative in Windows.
+	baseSlashed := len(base) > 0 && base[0] == x.Separator
+	targSlashed := len(targ) > 0 && targ[0] == x.Separator
+	if baseSlashed != targSlashed || !x.sameWord(baseVol, targVol) {
+		return "", errors.New("Rel: can't make " + targpath + " relative to " + basepath)
+	}
+	// Position base[b0:bi] and targ[t0:ti] at the first differing elements.
+	bl := len(base)
+	tl := len(targ)
+	var b0, bi, t0, ti int
+	for {
+		for bi < bl && base[bi] != x.Separator {
+			bi++
+		}
+		for ti < tl && targ[ti] != x.Separator {
+			ti++
+		}
+		if !x.sameWord(targ[t0:ti], base[b0:bi]) {
+			break
+		}
+		if bi < bl {
+			bi++
+		}
+		if ti < tl {
+			ti++
+		}
+		b0 = bi
+		t0 = ti
+	}
+	if base[b0:bi] == ".." {
+		return "", errors.New("Rel: can't make " + targpath + " relative to " + basepath)
+	}
+	if b0 != bl {
+		// Base elements left. Must go up before going down.
+		seps := strings.Count(base[b0:bl], string(x.Separator))
+		size := 2 + seps*3
+		if tl != t0 {
+			size += 1 + tl - t0
+		}
+		buf := make([]byte, size)
+		n := copy(buf, "..")
+		for i := 0; i < seps; i++ {
+			buf[n] = x.Separator
+			copy(buf[n+1:], "..")
+			n += 3
+		}
+		if t0 != tl {
+			buf[n] = x.Separator
+			copy(buf[n+1:], targ[t0:])
+		}
+		return string(buf), nil
+	}
+	return targ[t0:], nil
+}
 
 // Base returns the last element of path.
-// Trailing slashes are removed before extracting the last element.
+// Trailing path separators are removed before extracting the last element.
 // If the path is empty, Base returns ".".
-// If the path consists entirely of slashes, Base returns "/".
-func Base(path string) string { return pathBase(path) }
-
-var pathBase = path.Base
-
-// IsAbs reports whether the path is absolute.
-func IsAbs(path string) bool { return pathIsAbs(path) }
-
-var pathIsAbs = path.IsAbs
+// If the path consists entirely of separators, Base returns a single separator.
+// The default value for os is Unix.
+func Base(path string, os OS) string {
+	x := getOS(os)
+	if path == "" {
+		return "."
+	}
+	// Strip trailing slashes.
+	for len(path) > 0 && x.IsPathSeparator(path[len(path)-1]) {
+		path = path[0 : len(path)-1]
+	}
+	// Throw away volume name
+	path = path[x.volumeNameLen(path):]
+	// Find the last element
+	i := len(path) - 1
+	for i >= 0 && !x.IsPathSeparator(path[i]) {
+		i--
+	}
+	if i >= 0 {
+		path = path[i+1:]
+	}
+	// If empty now, it had only slashes.
+	if path == "" {
+		return string(x.Separator)
+	}
+	return path
+}
 
 // Dir returns all but the last element of path, typically the path's directory.
-// After dropping the final element using Split, the path is Cleaned and trailing
+// After dropping the final element, Dir calls Clean on the path and trailing
 // slashes are removed.
 // If the path is empty, Dir returns ".".
-// If the path consists entirely of slashes followed by non-slash bytes, Dir
-// returns a single slash. In any other case, the returned path does not end in a
-// slash.
-func Dir(path string) string { return pathDir(path) }
+// If the path consists entirely of separators, Dir returns a single separator.
+// The returned path does not end in a separator unless it is the root directory.
+// The default value for os is Unix.
+func Dir(path string, os OS) string {
+	x := getOS(os)
+	vol := volumeName(path, x)
+	i := len(path) - 1
+	for i >= len(vol) && !x.IsPathSeparator(path[i]) {
+		i--
+	}
+	dir := clean(path[len(vol):i+1], x)
+	if dir == "." && len(vol) > 2 {
+		// must be UNC
+		return vol
+	}
+	return vol + dir
+}
 
-var pathDir = path.Dir
+// IsAbs reports whether the path is absolute. The default value for os is Unix.
+// Note that because IsAbs has a default value, it cannot be used as
+// a validator.
+func IsAbs(path string, os OS) bool {
+	return getOS(os).IsAbs(path)
+}
+
+// VolumeName returns leading volume name.
+// Given "C:\foo\bar" it returns "C:" on Windows.
+// Given "\\host\share\foo" it returns "\\host\share".
+// On other platforms it returns "".
+// The default value for os is Windows.
+func VolumeName(path string, os OS) string {
+	return volumeName(path, getOS(os))
+}
+
+func volumeName(path string, os os) string {
+	return path[:os.volumeNameLen(path)]
+}
diff --git a/pkg/path/testdata/path_nix.go b/pkg/path/path_nix.go
similarity index 100%
rename from pkg/path/testdata/path_nix.go
rename to pkg/path/path_nix.go
diff --git a/pkg/path/testdata/path_p9.go b/pkg/path/path_p9.go
similarity index 100%
rename from pkg/path/testdata/path_p9.go
rename to pkg/path/path_p9.go
diff --git a/pkg/path/testdata/path_test.go b/pkg/path/path_test.go
similarity index 100%
rename from pkg/path/testdata/path_test.go
rename to pkg/path/path_test.go
diff --git a/pkg/path/testdata/path_win.go b/pkg/path/path_win.go
similarity index 100%
rename from pkg/path/testdata/path_win.go
rename to pkg/path/path_win.go
diff --git a/pkg/path/testdata/path_windows_test.go b/pkg/path/path_windows_test.go
similarity index 100%
rename from pkg/path/testdata/path_windows_test.go
rename to pkg/path/path_windows_test.go
diff --git a/pkg/path/testdata/pathtxtar_test.go b/pkg/path/pathtxtar_test.go
similarity index 100%
rename from pkg/path/testdata/pathtxtar_test.go
rename to pkg/path/pathtxtar_test.go
diff --git a/pkg/path/pkg.go b/pkg/path/pkg.go
index 5446870..dbe0f74 100644
--- a/pkg/path/pkg.go
+++ b/pkg/path/pkg.go
@@ -1,7 +1,16 @@
-// Code generated by go generate. DO NOT EDIT.
-
-//go:generate rm pkg.go
-//go:generate go run ../gen/gen.go
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 package path
 
@@ -16,90 +25,245 @@
 
 var _ = adt.TopKind // in case the adt package isn't used
 
+var (
+	osRequired = &adt.Disjunction{
+		Values: allOS,
+	}
+
+	unixDefault = &adt.Disjunction{
+		NumDefaults: 1,
+		Values:      allOS,
+	}
+
+	// windowsDefault is the default for VolumeName.
+	windowsDefault = &adt.Disjunction{
+		NumDefaults: 1,
+		Values: append([]*adt.Vertex{
+			newStr("windows"),
+			newStr("unix"),
+			newStr("plan9")}, unixOS...),
+	}
+
+	allOS = append([]*adt.Vertex{
+		newStr("unix"),
+		newStr("windows"),
+		newStr("plan9"),
+	}, unixOS...)
+
+	// These all fall back to unix
+	unixOS = []*adt.Vertex{
+		newStr("aix"),
+		newStr("android"),
+		newStr("darwin"),
+		newStr("dragonfly"),
+		newStr("freebsd"),
+		newStr("hurd"),
+		newStr("illumos"),
+		newStr("ios"),
+		newStr("js"),
+		newStr("linux"),
+		newStr("nacl"),
+		newStr("netbsd"),
+		newStr("openbsd"),
+		newStr("solaris"),
+		newStr("zos"),
+	}
+)
+
+func newStr(s string) *adt.Vertex {
+	v := &adt.Vertex{}
+	v.SetValue(nil, adt.Finalized, &adt.String{Str: s})
+	return v
+}
+
 var pkg = &internal.Package{
+	CUE: `{
+		Unix:    "unix"
+		Windows: "windows"
+		Plan9:   "plan9"
+	}`,
 	Native: []*internal.Builtin{{
 		Name: "Split",
 		Params: []internal.Param{
 			{Kind: adt.StringKind},
+			{Kind: adt.StringKind, Value: unixDefault},
 		},
 		Result: adt.ListKind,
 		Func: func(c *internal.CallCtxt) {
-			path := c.String(0)
+			path, os := c.String(0), c.String(1)
 			if c.Do() {
-				c.Ret = Split(path)
+				c.Ret = Split(path, OS(os))
+			}
+		},
+	}, {
+		Name: "SplitList",
+		Params: []internal.Param{
+			{Kind: adt.StringKind},
+			{Kind: adt.StringKind, Value: osRequired},
+		},
+		Result: adt.ListKind,
+		Func: func(c *internal.CallCtxt) {
+			path, os := c.String(0), c.String(1)
+			if c.Do() {
+				c.Ret = SplitList(path, OS(os))
+			}
+		},
+	}, {
+		Name: "Join",
+		Params: []internal.Param{
+			{Kind: adt.ListKind},
+			{Kind: adt.StringKind, Value: unixDefault},
+		},
+		Result: adt.StringKind,
+		Func: func(c *internal.CallCtxt) {
+			list, os := c.StringList(0), c.String(1)
+			if c.Do() {
+				c.Ret = Join(list, OS(os))
 			}
 		},
 	}, {
 		Name: "Match",
 		Params: []internal.Param{
 			{Kind: adt.StringKind},
-			{Kind: adt.StringKind},
+			{Kind: adt.StringKind, Value: unixDefault},
 		},
 		Result: adt.BoolKind,
 		Func: func(c *internal.CallCtxt) {
-			pattern, name := c.String(0), c.String(1)
+			pattern, name, os := c.String(0), c.String(1), c.String(2)
 			if c.Do() {
-				c.Ret, c.Err = Match(pattern, name)
+				c.Ret, c.Err = Match(pattern, name, OS(os))
 			}
 		},
 	}, {
 		Name: "Clean",
 		Params: []internal.Param{
 			{Kind: adt.StringKind},
+			{Kind: adt.StringKind, Value: unixDefault},
 		},
 		Result: adt.StringKind,
 		Func: func(c *internal.CallCtxt) {
-			path := c.String(0)
+			path, os := c.String(0), c.String(1)
 			if c.Do() {
-				c.Ret = Clean(path)
+				c.Ret = Clean(path, OS(os))
+			}
+		},
+	}, {
+		Name: "ToSlash",
+		Params: []internal.Param{
+			{Kind: adt.StringKind},
+			{Kind: adt.StringKind, Value: osRequired},
+		},
+		Result: adt.StringKind,
+		Func: func(c *internal.CallCtxt) {
+			path, os := c.String(0), c.String(1)
+			if c.Do() {
+				c.Ret = ToSlash(path, OS(os))
+			}
+		},
+	}, {
+		Name: "FromSlash",
+		Params: []internal.Param{
+			{Kind: adt.StringKind},
+			{Kind: adt.StringKind, Value: osRequired},
+		},
+		Result: adt.StringKind,
+		Func: func(c *internal.CallCtxt) {
+			path, os := c.String(0), c.String(1)
+			if c.Do() {
+				c.Ret = FromSlash(path, OS(os))
 			}
 		},
 	}, {
 		Name: "Ext",
 		Params: []internal.Param{
 			{Kind: adt.StringKind},
+			{Kind: adt.StringKind, Value: unixDefault},
 		},
 		Result: adt.StringKind,
 		Func: func(c *internal.CallCtxt) {
-			path := c.String(0)
+			path, os := c.String(0), c.String(1)
 			if c.Do() {
-				c.Ret = Ext(path)
+				c.Ret = Ext(path, OS(os))
+			}
+		},
+	}, {
+		Name: "Resolve",
+		Params: []internal.Param{
+			{Kind: adt.StringKind},
+			{Kind: adt.StringKind},
+			{Kind: adt.StringKind, Value: unixDefault},
+		},
+		Result: adt.StringKind,
+		Func: func(c *internal.CallCtxt) {
+			dir, sub, os := c.String(0), c.String(1), c.String(2)
+			if c.Do() {
+				c.Ret = Resolve(dir, sub, OS(os))
+			}
+		},
+	}, {
+		Name: "Rel",
+		Params: []internal.Param{
+			{Kind: adt.StringKind},
+			{Kind: adt.StringKind},
+			{Kind: adt.StringKind, Value: unixDefault},
+		},
+		Result: adt.StringKind,
+		Func: func(c *internal.CallCtxt) {
+			base, target, os := c.String(0), c.String(1), c.String(2)
+			if c.Do() {
+				c.Ret, c.Err = Rel(base, target, OS(os))
 			}
 		},
 	}, {
 		Name: "Base",
 		Params: []internal.Param{
 			{Kind: adt.StringKind},
+			{Kind: adt.StringKind, Value: unixDefault},
 		},
 		Result: adt.StringKind,
 		Func: func(c *internal.CallCtxt) {
-			path := c.String(0)
+			path, os := c.String(0), c.String(1)
 			if c.Do() {
-				c.Ret = Base(path)
-			}
-		},
-	}, {
-		Name: "IsAbs",
-		Params: []internal.Param{
-			{Kind: adt.StringKind},
-		},
-		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
-			path := c.String(0)
-			if c.Do() {
-				c.Ret = IsAbs(path)
+				c.Ret = Base(path, OS(os))
 			}
 		},
 	}, {
 		Name: "Dir",
 		Params: []internal.Param{
 			{Kind: adt.StringKind},
+			{Kind: adt.StringKind, Value: unixDefault},
 		},
 		Result: adt.StringKind,
 		Func: func(c *internal.CallCtxt) {
-			path := c.String(0)
+			path, os := c.String(0), c.String(1)
 			if c.Do() {
-				c.Ret = Dir(path)
+				c.Ret = Dir(path, OS(os))
+			}
+		},
+	}, {
+		Name: "IsAbs",
+		Params: []internal.Param{
+			{Kind: adt.StringKind},
+			{Kind: adt.StringKind, Value: unixDefault},
+		},
+		Result: adt.BoolKind,
+		Func: func(c *internal.CallCtxt) {
+			path, os := c.String(0), c.String(1)
+			if c.Do() {
+				c.Ret = IsAbs(path, OS(os))
+			}
+		},
+	}, {
+		Name: "VolumeName",
+		Params: []internal.Param{
+			{Kind: adt.StringKind},
+			{Kind: adt.StringKind, Value: windowsDefault},
+		},
+		Result: adt.StringKind,
+		Func: func(c *internal.CallCtxt) {
+			path, os := c.String(0), c.String(1)
+			if c.Do() {
+				c.Ret = VolumeName(path, OS(os))
 			}
 		},
 	}},
diff --git a/pkg/path/testdata/error.txtar b/pkg/path/testdata/error.txtar
new file mode 100644
index 0000000..f53048c
--- /dev/null
+++ b/pkg/path/testdata/error.txtar
@@ -0,0 +1,28 @@
+// Copyright 2020 CUE Authors
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+-- in.cue --
+import "path"
+
+joinOK: path.Join(["a", "b"], "aix")
+joinErr: path.Join(["a", "b"], "foo")
+-- out/path --
+Errors:
+joinErr: cannot use "foo" as *"unix" | "windows" | "plan9" | "aix" | "android" | "darwin" | "dragonfly" | "freebsd" | "hurd" | "illumos" | "ios" | "js" | "linux" | "nacl" | "netbsd" | "openbsd" | "solaris" | "zos" in argument 2 to path.Join:
+    ./in.cue:4:32
+
+Result:
+joinOK:  "a/b"
+joinErr: _|_ // joinErr: cannot use "foo" as *"unix" | "windows" | "plan9" | "aix" | "android" | "darwin" | "dragonfly" | "freebsd" | "hurd" | "illumos" | "ios" | "js" | "linux" | "nacl" | "netbsd" | "openbsd" | "solaris" | "zos" in argument 2 to path.Join (and 1 more errors)
+
diff --git a/pkg/path/testdata/join.txtar b/pkg/path/testdata/join.txtar
new file mode 100644
index 0000000..82b6b55
--- /dev/null
+++ b/pkg/path/testdata/join.txtar
@@ -0,0 +1,205 @@
+// Copyright 2020 CUE Authors
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+-- in.cue --
+import "path"
+
+joinSingle: path.Join(["a", "b"])
+joinSingle: "a/b"
+
+Join: unix:    _
+Join: windows: _
+
+Join: [OS=string]: [...{
+    arg: [...string]
+
+    out: path.Join(arg, OS)
+}]
+
+Join: [_]: [
+    {arg: ["a", "b"]},
+    {arg: ["a/b", "c/d"]},
+
+    {arg: ["/"]},
+    {arg: ["a"]},
+
+    {arg: ["a", "b"]},
+    {arg: ["a", ""]},
+    {arg: ["", "b"]},
+    {arg: ["/", "a"]},
+    {arg: ["/", "a/b"]},
+    {arg: ["/", ""]},
+    {arg: ["//", "a"]},
+
+    {arg: ["directory", "file"]},
+
+    {arg: [#"C:\Windows\"#, #"System32"#]},
+    {arg: [#"C:\Windows\"#, #""#]},
+    {arg: [#"C:\"#, #"Windows"#]},
+    {arg: [#"C:"#, #"a\b"#]},
+    {arg: [#"C:"#, #"a"#, #"b"#]},
+    {arg: [#"C:"#, #""#, #""#, #"b"#]},
+    {arg: [#"C:"#, #""#]},
+    {arg: [#"C:"#, #""#, #""#]},
+    {arg: [#"C:."#, #"a"#]},
+    {arg: [#"C:a"#, #"b"#]},
+    {arg: [#"\\host\share"#, #"foo"#]},
+]
+
+-- out/path --
+joinSingle: "a/b"
+Join: {
+	unix: [{
+		arg: ["a", "b"]
+		out: "a/b"
+	}, {
+		arg: ["a/b", "c/d"]
+		out: "a/b/c/d"
+	}, {
+		arg: ["/"]
+		out: "/"
+	}, {
+		arg: ["a"]
+		out: "a"
+	}, {
+		arg: ["a", "b"]
+		out: "a/b"
+	}, {
+		arg: ["a", ""]
+		out: "a"
+	}, {
+		arg: ["", "b"]
+		out: "b"
+	}, {
+		arg: ["/", "a"]
+		out: "/a"
+	}, {
+		arg: ["/", "a/b"]
+		out: "/a/b"
+	}, {
+		arg: ["/", ""]
+		out: "/"
+	}, {
+		arg: ["//", "a"]
+		out: "/a"
+	}, {
+		arg: ["directory", "file"]
+		out: "directory/file"
+	}, {
+		arg: [#"C:\Windows\"#, #"System32"#]
+		out: "C:\\Windows\\/System32"
+	}, {
+		arg: [#"C:\Windows\"#, #""#]
+		out: "C:\\Windows\\"
+	}, {
+		arg: [#"C:\"#, #"Windows"#]
+		out: "C:\\/Windows"
+	}, {
+		arg: [#"C:"#, #"a\b"#]
+		out: "C:/a\\b"
+	}, {
+		arg: [#"C:"#, #"a"#, #"b"#]
+		out: "C:/a/b"
+	}, {
+		arg: [#"C:"#, #""#, #""#, #"b"#]
+		out: "C:/b"
+	}, {
+		arg: [#"C:"#, #""#]
+		out: "C:"
+	}, {
+		arg: [#"C:"#, #""#, #""#]
+		out: "C:"
+	}, {
+		arg: [#"C:."#, #"a"#]
+		out: "C:./a"
+	}, {
+		arg: [#"C:a"#, #"b"#]
+		out: "C:a/b"
+	}, {
+		arg: [#"\\host\share"#, #"foo"#]
+		out: "\\\\host\\share/foo"
+	}]
+	windows: [{
+		arg: ["a", "b"]
+		out: "a\\b"
+	}, {
+		arg: ["a/b", "c/d"]
+		out: "a\\b\\c\\d"
+	}, {
+		arg: ["/"]
+		out: "\\"
+	}, {
+		arg: ["a"]
+		out: "a"
+	}, {
+		arg: ["a", "b"]
+		out: "a\\b"
+	}, {
+		arg: ["a", ""]
+		out: "a"
+	}, {
+		arg: ["", "b"]
+		out: "b"
+	}, {
+		arg: ["/", "a"]
+		out: "\\a"
+	}, {
+		arg: ["/", "a/b"]
+		out: "\\a\\b"
+	}, {
+		arg: ["/", ""]
+		out: "\\"
+	}, {
+		arg: ["//", "a"]
+		out: "\\a"
+	}, {
+		arg: ["directory", "file"]
+		out: "directory\\file"
+	}, {
+		arg: [#"C:\Windows\"#, #"System32"#]
+		out: "C:\\Windows\\System32"
+	}, {
+		arg: [#"C:\Windows\"#, #""#]
+		out: "C:\\Windows"
+	}, {
+		arg: [#"C:\"#, #"Windows"#]
+		out: "C:\\Windows"
+	}, {
+		arg: [#"C:"#, #"a\b"#]
+		out: "C:a\\b"
+	}, {
+		arg: [#"C:"#, #"a"#, #"b"#]
+		out: "C:a\\b"
+	}, {
+		arg: [#"C:"#, #""#, #""#, #"b"#]
+		out: "C:b"
+	}, {
+		arg: [#"C:"#, #""#]
+		out: "C:."
+	}, {
+		arg: [#"C:"#, #""#, #""#]
+		out: "C:."
+	}, {
+		arg: [#"C:."#, #"a"#]
+		out: "C:a"
+	}, {
+		arg: [#"C:a"#, #"b"#]
+		out: "C:a\\b"
+	}, {
+		arg: [#"\\host\share"#, #"foo"#]
+		out: "\\\\host\\share\\foo"
+	}]
+}
+
diff --git a/pkg/path/testdata/os.txtar b/pkg/path/testdata/os.txtar
new file mode 100644
index 0000000..ba253da
--- /dev/null
+++ b/pkg/path/testdata/os.txtar
@@ -0,0 +1,504 @@
+// Copyright 2020 CUE Authors
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+-- in.cue --
+import "path"
+
+#OSes: [path.Unix, path.Windows, path.Plan9]
+#AnyOS: or(#OSes)
+
+// Test these OSes for all tests below.
+{
+    [string]: {
+        unix:    _
+        plan9:   _
+        windows: _
+    }
+}
+
+Split: [OS=#AnyOS]: [ARG=string]: path.Split(ARG, OS)
+Split: default:     [ARG=string]: path.Split(ARG)
+Split: default:     Split.unix
+Split: [_]: {
+    "/foo/bar/baz":       _
+    "a/b":                _
+    "//host/share/foo":   _
+    #"\\host\share\foo"#: _
+    "c:/foo/bar":         _
+    #"c:\foo\bar"#:       _
+}
+
+SplitList: [OS=string]: [ARG=string]: path.SplitList(ARG, OS)
+SplitList: [_]: {
+    "a:b":      _
+    "a\u0000b": _
+    "a;b":      _
+}
+
+Clean: [OS=#AnyOS]: [ARG=string]: path.Clean(ARG, OS)
+Clean: default:     [ARG=string]: path.Clean(ARG)
+Clean: default:     Clean.unix
+Clean: [_]: {
+    "abc//def//ghi":      _
+    #"c:\abc\def\..\.."#: _
+}
+
+Slash: [OS=string]: [ARG=string]: {
+    to:   path.ToSlash(ARG, OS)
+    from: path.FromSlash(ARG, OS)
+
+    // should roundtrip
+    to:   path.ToSlash(from, OS)
+    from: path.FromSlash(to, OS)
+}
+Slash: [_]: {
+    "":      _
+    "/":     _
+    "/a/b":  _
+    "/a//b": _
+}
+
+Ext: [OS=#AnyOS]: [ARG=string]: path.Ext(ARG, OS)
+Ext: default:     [ARG=string]: path.Ext(ARG)
+Ext: default:     Ext.unix
+Ext: [_]: {
+    // Same for all OS-es
+    "path.go":    ".go"
+    "path.pb.go": ".go"
+    "a.dir/b":    ""
+    "a.dir/b.go": ".go"
+    "a.dir/":     ""
+
+    // Differs on Windows.
+    "a.dir\\foo": _
+}
+
+Resolve: [OS=#AnyOS]: [A1=_]: [A2=_]: path.Resolve(A1, A2, OS)
+Resolve: default:     [A1=_]: [A2=_]: path.Resolve(A1, A2)
+Resolve: default:     Resolve.unix
+Resolve: [_]: {
+    "a/b/c": "d/e":   _
+    "/a/b":  "/c/d":  _
+    "c:/a":  #"d:\"#: _
+
+    "//home/user/foo": "bar":             _
+    "//home/user/foo": "//other/abs/foo": _
+}
+
+IsAbs: [OS=#AnyOS]: [ARG=string]: path.IsAbs(ARG, OS)
+IsAbs: default:     [ARG=string]: path.IsAbs(ARG)
+IsAbs: default:     IsAbs.unix
+IsAbs: [_]: {
+    "":     _
+    "/a":   _
+    "a":    _
+    "c:":   _
+    "c:/":  _
+    "c:\\": _
+
+    "//home/user/foo": _
+}
+
+
+Volume: [OS=string]:   [ARG=string]: path.VolumeName(ARG, OS)
+Volume: [!="windows"]: [string]:     "" // non-windows is always ""
+Volume: [_]: {
+    "c:/foo/bar": _
+    "c:":         _
+    "2:":         _
+    "":           _
+
+    #"\\\host"#:          _
+    #"\\\host\"#:         _
+    #"\\\host\share"#:    _
+    #"\\\host\\share"#:   _
+    #"\\host"#:           _
+    #"//host"#:           _
+    #"\\host\"#:          _
+    #"//host/"#:          _
+    #"\\host\share"#:     _
+    #"//host/share"#:     _
+    #"\\host\share\"#:    _
+    #"//host/share/"#:    _
+    #"\\host\share\foo"#: _
+    #"//host/share/foo"#: _
+
+    #"\\host\share\\foo\\\bar\\\\baz"#: _
+    #"//host/share//foo///bar////baz"#: _
+    #"\\host\share\foo\..\bar"#:        _
+    #"//host/share/foo/../bar"#:        _
+}
+
+-- out/path --
+#OSes: ["unix", "windows", "plan9"]
+#AnyOS: "unix" | "windows" | "plan9"
+Split: {
+	unix: {
+		"/foo/bar/baz": ["/foo/bar/", "baz"]
+		"a/b": ["a/", "b"]
+		"//host/share/foo": ["//host/share/", "foo"]
+		"\\\\host\\share\\foo": ["", "\\\\host\\share\\foo"]
+		"c:/foo/bar": ["c:/foo/", "bar"]
+		"c:\\foo\\bar": ["", "c:\\foo\\bar"]
+	}
+	plan9: {
+		"/foo/bar/baz": ["/foo/bar/", "baz"]
+		"a/b": ["a/", "b"]
+		"//host/share/foo": ["//host/share/", "foo"]
+		"\\\\host\\share\\foo": ["", "\\\\host\\share\\foo"]
+		"c:/foo/bar": ["c:/foo/", "bar"]
+		"c:\\foo\\bar": ["", "c:\\foo\\bar"]
+	}
+	default: {
+		"/foo/bar/baz": ["/foo/bar/", "baz"]
+		"a/b": ["a/", "b"]
+		"//host/share/foo": ["//host/share/", "foo"]
+		"\\\\host\\share\\foo": ["", "\\\\host\\share\\foo"]
+		"c:/foo/bar": ["c:/foo/", "bar"]
+		"c:\\foo\\bar": ["", "c:\\foo\\bar"]
+	}
+	windows: {
+		"/foo/bar/baz": ["/foo/bar/", "baz"]
+		"a/b": ["a/", "b"]
+		"//host/share/foo": ["//host/share/", "foo"]
+		"\\\\host\\share\\foo": ["\\\\host\\share\\", "foo"]
+		"c:/foo/bar": ["c:/foo/", "bar"]
+		"c:\\foo\\bar": ["c:\\foo\\", "bar"]
+	}
+}
+SplitList: {
+	unix: {
+		"a:b": ["a", "b"]
+		"a\u0000b": ["a\u0000b"]
+		"a;b": ["a;b"]
+	}
+	plan9: {
+		"a:b": ["a:b"]
+		"a\u0000b": ["a", "b"]
+		"a;b": ["a;b"]
+	}
+	windows: {
+		"a:b": ["a:b"]
+		"a\u0000b": ["a\u0000b"]
+		"a;b": ["a", "b"]
+	}
+}
+Clean: {
+	unix: {
+		"abc//def//ghi":        "abc/def/ghi"
+		"c:\\abc\\def\\..\\..": "c:\\abc\\def\\..\\.."
+	}
+	plan9: {
+		"abc//def//ghi":        "abc/def/ghi"
+		"c:\\abc\\def\\..\\..": "c:\\abc\\def\\..\\.."
+	}
+	default: {
+		"abc//def//ghi":        "abc/def/ghi"
+		"c:\\abc\\def\\..\\..": "c:\\abc\\def\\..\\.."
+	}
+	windows: {
+		"abc//def//ghi":        "abc\\def\\ghi"
+		"c:\\abc\\def\\..\\..": "c:\\"
+	}
+}
+Slash: {
+	unix: {
+		"": {
+			// should roundtrip
+			to:   ""
+			from: ""
+		}
+		"/": {
+			// should roundtrip
+			to:   "/"
+			from: "/"
+		}
+		"/a/b": {
+			// should roundtrip
+			to:   "/a/b"
+			from: "/a/b"
+		}
+		"/a//b": {
+			// should roundtrip
+			to:   "/a//b"
+			from: "/a//b"
+		}
+	}
+	plan9: {
+		"": {
+			// should roundtrip
+			to:   ""
+			from: ""
+		}
+		"/": {
+			// should roundtrip
+			to:   "/"
+			from: "/"
+		}
+		"/a/b": {
+			// should roundtrip
+			to:   "/a/b"
+			from: "/a/b"
+		}
+		"/a//b": {
+			// should roundtrip
+			to:   "/a//b"
+			from: "/a//b"
+		}
+	}
+	windows: {
+		"": {
+			// should roundtrip
+			to:   ""
+			from: ""
+		}
+		"/": {
+			// should roundtrip
+			to:   "/"
+			from: "\\"
+		}
+		"/a/b": {
+			// should roundtrip
+			to:   "/a/b"
+			from: "\\a\\b"
+		}
+		"/a//b": {
+			// should roundtrip
+			to:   "/a//b"
+			from: "\\a\\\\b"
+		}
+	}
+}
+Ext: {
+	unix: {
+		// Same for all OS-es
+		"path.go":    ".go"
+		"path.pb.go": ".go"
+		"a.dir/b":    ""
+		"a.dir/b.go": ".go"
+		"a.dir/":     ""
+
+		// Differs on Windows.
+		"a.dir\\foo": ".dir\\foo"
+	}
+	plan9: {
+		// Same for all OS-es
+		"path.go":    ".go"
+		"path.pb.go": ".go"
+		"a.dir/b":    ""
+		"a.dir/b.go": ".go"
+		"a.dir/":     ""
+
+		// Differs on Windows.
+		"a.dir\\foo": ".dir\\foo"
+	}
+	default: {
+		// Same for all OS-es
+		"path.go":    ".go"
+		"path.pb.go": ".go"
+		"a.dir/b":    ""
+		"a.dir/b.go": ".go"
+		"a.dir/":     ""
+
+		// Differs on Windows.
+		"a.dir\\foo": ".dir\\foo"
+	}
+	windows: {
+		// Same for all OS-es
+		"path.go":    ".go"
+		"path.pb.go": ".go"
+		"a.dir/b":    ""
+		"a.dir/b.go": ".go"
+		"a.dir/":     ""
+
+		// Differs on Windows.
+		"a.dir\\foo": ""
+	}
+}
+Resolve: {
+	unix: {
+		"a/b/c": {
+			"d/e": "a/b/c/d/e"
+		}
+		"/a/b": {
+			"/c/d": "/c/d"
+		}
+		"c:/a": {
+			"d:\\": "c:/a/d:\\"
+		}
+		"//home/user/foo": {
+			bar:               "/home/user/foo/bar"
+			"//other/abs/foo": "/other/abs/foo"
+		}
+	}
+	plan9: {
+		"a/b/c": {
+			"d/e": "a/b/c/d/e"
+		}
+		"/a/b": {
+			"/c/d": "/c/d"
+		}
+		"c:/a": {
+			"d:\\": "c:/a/d:\\"
+		}
+		"//home/user/foo": {
+			bar:               "/home/user/foo/bar"
+			"//other/abs/foo": "/other/abs/foo"
+		}
+	}
+	default: {
+		"a/b/c": {
+			"d/e": "a/b/c/d/e"
+		}
+		"/a/b": {
+			"/c/d": "/c/d"
+		}
+		"c:/a": {
+			"d:\\": "c:/a/d:\\"
+		}
+		"//home/user/foo": {
+			bar:               "/home/user/foo/bar"
+			"//other/abs/foo": "/other/abs/foo"
+		}
+	}
+	windows: {
+		"a/b/c": {
+			"d/e": "a\\b\\c\\d\\e"
+		}
+		"/a/b": {
+			"/c/d": "\\a\\b\\c\\d"
+		}
+		"c:/a": {
+			"d:\\": "d:\\"
+		}
+		"//home/user/foo": {
+			bar:               "\\\\home\\user\\foo\\bar"
+			"//other/abs/foo": "\\\\other\\abs\\foo"
+		}
+	}
+}
+IsAbs: {
+	unix: {
+		"":                false
+		"/a":              true
+		a:                 false
+		"c:":              false
+		"c:/":             false
+		"c:\\":            false
+		"//home/user/foo": true
+	}
+	plan9: {
+		"":                false
+		"/a":              true
+		a:                 false
+		"c:":              false
+		"c:/":             false
+		"c:\\":            false
+		"//home/user/foo": true
+	}
+	default: {
+		"":                false
+		"/a":              true
+		a:                 false
+		"c:":              false
+		"c:/":             false
+		"c:\\":            false
+		"//home/user/foo": true
+	}
+	windows: {
+		"":                false
+		"/a":              false
+		a:                 false
+		"c:":              false
+		"c:/":             true
+		"c:\\":            true
+		"//home/user/foo": true
+	}
+}
+Volume: {
+	unix: {
+		"c:/foo/bar":                                 ""
+		"c:":                                         ""
+		"2:":                                         ""
+		"":                                           ""
+		"\\\\\\host":                                 ""
+		"\\\\\\host\\":                               ""
+		"\\\\\\host\\share":                          ""
+		"\\\\\\host\\\\share":                        ""
+		"\\\\host":                                   ""
+		"//host":                                     ""
+		"\\\\host\\":                                 ""
+		"//host/":                                    ""
+		"\\\\host\\share":                            ""
+		"//host/share":                               ""
+		"\\\\host\\share\\":                          ""
+		"//host/share/":                              ""
+		"\\\\host\\share\\foo":                       ""
+		"//host/share/foo":                           ""
+		"\\\\host\\share\\\\foo\\\\\\bar\\\\\\\\baz": ""
+		"//host/share//foo///bar////baz":             ""
+		"\\\\host\\share\\foo\\..\\bar":              ""
+		"//host/share/foo/../bar":                    ""
+	}
+	plan9: {
+		"c:/foo/bar":                                 ""
+		"c:":                                         ""
+		"2:":                                         ""
+		"":                                           ""
+		"\\\\\\host":                                 ""
+		"\\\\\\host\\":                               ""
+		"\\\\\\host\\share":                          ""
+		"\\\\\\host\\\\share":                        ""
+		"\\\\host":                                   ""
+		"//host":                                     ""
+		"\\\\host\\":                                 ""
+		"//host/":                                    ""
+		"\\\\host\\share":                            ""
+		"//host/share":                               ""
+		"\\\\host\\share\\":                          ""
+		"//host/share/":                              ""
+		"\\\\host\\share\\foo":                       ""
+		"//host/share/foo":                           ""
+		"\\\\host\\share\\\\foo\\\\\\bar\\\\\\\\baz": ""
+		"//host/share//foo///bar////baz":             ""
+		"\\\\host\\share\\foo\\..\\bar":              ""
+		"//host/share/foo/../bar":                    ""
+	}
+	windows: {
+		"c:/foo/bar":                                 "c:"
+		"c:":                                         "c:"
+		"2:":                                         ""
+		"":                                           ""
+		"\\\\\\host":                                 ""
+		"\\\\\\host\\":                               ""
+		"\\\\\\host\\share":                          ""
+		"\\\\\\host\\\\share":                        ""
+		"\\\\host":                                   ""
+		"//host":                                     ""
+		"\\\\host\\":                                 ""
+		"//host/":                                    ""
+		"\\\\host\\share":                            "\\\\host\\share"
+		"//host/share":                               "//host/share"
+		"\\\\host\\share\\":                          "\\\\host\\share"
+		"//host/share/":                              "//host/share"
+		"\\\\host\\share\\foo":                       "\\\\host\\share"
+		"//host/share/foo":                           "//host/share"
+		"\\\\host\\share\\\\foo\\\\\\bar\\\\\\\\baz": "\\\\host\\share"
+		"//host/share//foo///bar////baz":             "//host/share"
+		"\\\\host\\share\\foo\\..\\bar":              "\\\\host\\share"
+		"//host/share/foo/../bar":                    "//host/share"
+	}
+}
+
diff --git a/pkg/path/testdata/path.go b/pkg/path/testdata/path.go
deleted file mode 100644
index b18883d..0000000
--- a/pkg/path/testdata/path.go
+++ /dev/null
@@ -1,414 +0,0 @@
-// Copyright 2020 CUE Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package filepath implements utility routines for manipulating filename paths
-// in a way compatible with the target operating system-defined file paths.
-//
-// The filepath package uses either forward slashes or backslashes,
-// depending on the operating system. To process paths such as URLs
-// that always use forward slashes regardless of the operating
-// system, see the path package.
-package path
-
-import (
-	"errors"
-	"strings"
-)
-
-// A lazybuf is a lazily constructed path buffer.
-// It supports append, reading previously appended bytes,
-// and retrieving the final string. It does not allocate a buffer
-// to hold the output until that output diverges from s.
-type lazybuf struct {
-	path       string
-	buf        []byte
-	w          int
-	volAndPath string
-	volLen     int
-}
-
-func (b *lazybuf) index(i int) byte {
-	if b.buf != nil {
-		return b.buf[i]
-	}
-	return b.path[i]
-}
-
-func (b *lazybuf) append(c byte) {
-	if b.buf == nil {
-		if b.w < len(b.path) && b.path[b.w] == c {
-			b.w++
-			return
-		}
-		b.buf = make([]byte, len(b.path))
-		copy(b.buf, b.path[:b.w])
-	}
-	b.buf[b.w] = c
-	b.w++
-}
-
-func (b *lazybuf) string() string {
-	if b.buf == nil {
-		return b.volAndPath[:b.volLen+b.w]
-	}
-	return b.volAndPath[:b.volLen] + string(b.buf[:b.w])
-}
-
-// const (
-// 	Separator     = os.PathSeparator
-// 	ListSeparator = os.PathListSeparator
-// )
-
-// Clean returns the shortest path name equivalent to path
-// by purely lexical processing. The default value for os is Unix.
-// It applies the following rules
-// iteratively until no further processing can be done:
-//
-//	1. Replace multiple Separator elements with a single one.
-//	2. Eliminate each . path name element (the current directory).
-//	3. Eliminate each inner .. path name element (the parent directory)
-//	   along with the non-.. element that precedes it.
-//	4. Eliminate .. elements that begin a rooted path:
-//	   that is, replace "/.." by "/" at the beginning of a path,
-//	   assuming Separator is '/'.
-//
-// The returned path ends in a slash only if it represents a root directory,
-// such as "/" on Unix or `C:\` on Windows.
-//
-// Finally, any occurrences of slash are replaced by Separator.
-//
-// If the result of this process is an empty string, Clean
-// returns the string ".".
-//
-// See also Rob Pike, ``Lexical File Names in Plan 9 or
-// Getting Dot-Dot Right,''
-// https://9p.io/sys/doc/lexnames.html
-func Clean(path string, os OS) string {
-	return clean(path, getOS(os))
-}
-
-func clean(path string, os os) string {
-	originalPath := path
-	volLen := os.volumeNameLen(path)
-	path = path[volLen:]
-	if path == "" {
-		if volLen > 1 && originalPath[1] != ':' {
-			// should be UNC
-			return fromSlash(originalPath, os)
-		}
-		return originalPath + "."
-	}
-	rooted := os.IsPathSeparator(path[0])
-
-	// Invariants:
-	//	reading from path; r is index of next byte to process.
-	//	writing to buf; w is index of next byte to write.
-	//	dotdot is index in buf where .. must stop, either because
-	//		it is the leading slash or it is a leading ../../.. prefix.
-	n := len(path)
-	out := lazybuf{path: path, volAndPath: originalPath, volLen: volLen}
-	r, dotdot := 0, 0
-	if rooted {
-		out.append(os.Separator)
-		r, dotdot = 1, 1
-	}
-
-	for r < n {
-		switch {
-		case os.IsPathSeparator(path[r]):
-			// empty path element
-			r++
-		case path[r] == '.' && (r+1 == n || os.IsPathSeparator(path[r+1])):
-			// . element
-			r++
-		case path[r] == '.' && path[r+1] == '.' && (r+2 == n || os.IsPathSeparator(path[r+2])):
-			// .. element: remove to last separator
-			r += 2
-			switch {
-			case out.w > dotdot:
-				// can backtrack
-				out.w--
-				for out.w > dotdot && !os.IsPathSeparator(out.index(out.w)) {
-					out.w--
-				}
-			case !rooted:
-				// cannot backtrack, but not rooted, so append .. element.
-				if out.w > 0 {
-					out.append(os.Separator)
-				}
-				out.append('.')
-				out.append('.')
-				dotdot = out.w
-			}
-		default:
-			// real path element.
-			// add slash if needed
-			if rooted && out.w != 1 || !rooted && out.w != 0 {
-				out.append(os.Separator)
-			}
-			// copy element
-			for ; r < n && !os.IsPathSeparator(path[r]); r++ {
-				out.append(path[r])
-			}
-		}
-	}
-
-	// Turn empty string into "."
-	if out.w == 0 {
-		out.append('.')
-	}
-
-	return fromSlash(out.string(), os)
-}
-
-// ToSlash returns the result of replacing each separator character
-// in path with a slash ('/') character. Multiple separators are
-// replaced by multiple slashes.
-func ToSlash(path string, os OS) string {
-	return toSlash(path, getOS(os))
-}
-
-func toSlash(path string, os os) string {
-	if os.Separator == '/' {
-		return path
-	}
-	return strings.ReplaceAll(path, string(os.Separator), "/")
-}
-
-// FromSlash returns the result of replacing each slash ('/') character
-// in path with a separator character. Multiple slashes are replaced
-// by multiple separators.
-func FromSlash(path string, os OS) string {
-	return fromSlash(path, getOS(os))
-}
-
-func fromSlash(path string, os os) string {
-	if os.Separator == '/' {
-		return path
-	}
-	return strings.ReplaceAll(path, "/", string(os.Separator))
-}
-
-// SplitList splits a list of paths joined by the OS-specific ListSeparator,
-// usually found in PATH or GOPATH environment variables.
-// Unlike strings.Split, SplitList returns an empty slice when passed an empty
-// string.
-func SplitList(path string, os OS) []string {
-	return getOS(os).splitList(path)
-}
-
-// Split splits path immediately following the final slash and returns them as
-// the list [dir, file], separating it into a directory and file name component.
-// If there is no slash in path, Split returns an empty dir and file set to
-// path. The returned values have the property that path = dir+file.
-// The default value for os is Unix.
-func Split(path string, os OS) []string {
-	x := getOS(os)
-	vol := volumeName(path, x)
-	i := len(path) - 1
-	for i >= len(vol) && !x.IsPathSeparator(path[i]) {
-		i--
-	}
-	return []string{path[:i+1], path[i+1:]}
-}
-
-// Join joins any number of path elements into a single path,
-// separating them with an OS specific Separator. Empty elements
-// are ignored. The result is Cleaned. However, if the argument
-// list is empty or all its elements are empty, Join returns
-// an empty string.
-// On Windows, the result will only be a UNC path if the first
-// non-empty element is a UNC path.
-// The default value for os is Unix.
-func Join(elem []string, os OS) string {
-	return getOS(os).join(elem)
-}
-
-// Ext returns the file name extension used by path.
-// The extension is the suffix beginning at the final dot
-// in the final element of path; it is empty if there is
-// no dot. The default value for os is Unix.
-func Ext(path string, os OS) string {
-	x := getOS(os)
-	for i := len(path) - 1; i >= 0 && !x.IsPathSeparator(path[i]); i-- {
-		if path[i] == '.' {
-			return path[i:]
-		}
-	}
-	return ""
-}
-
-// Resolve reports the path of sub relative to dir. If sub is an absolute path,
-// or if dir is empty, it will return sub. If sub is empty, it will return dir.
-// Resolve calls Clean on the result. The default value for os is Unix.
-func Resolve(dir, sub string, os OS) string {
-	x := getOS(os)
-	if x.IsAbs(sub) {
-		return clean(sub, x)
-	}
-	dir = clean(dir, x)
-	return x.join([]string{dir, sub})
-}
-
-// Rel returns a relative path that is lexically equivalent to targpath when
-// joined to basepath with an intervening separator. That is,
-// Join(basepath, Rel(basepath, targpath)) is equivalent to targpath itself.
-// On success, the returned path will always be relative to basepath,
-// even if basepath and targpath share no elements.
-// An error is returned if targpath can't be made relative to basepath or if
-// knowing the current working directory would be necessary to compute it.
-// Rel calls Clean on the result. The default value for os is Unix.
-func Rel(basepath, targpath string, os OS) (string, error) {
-	x := getOS(os)
-	baseVol := volumeName(basepath, x)
-	targVol := volumeName(targpath, x)
-	base := clean(basepath, x)
-	targ := clean(targpath, x)
-	if x.sameWord(targ, base) {
-		return ".", nil
-	}
-	base = base[len(baseVol):]
-	targ = targ[len(targVol):]
-	if base == "." {
-		base = ""
-	}
-	// Can't use IsAbs - `\a` and `a` are both relative in Windows.
-	baseSlashed := len(base) > 0 && base[0] == x.Separator
-	targSlashed := len(targ) > 0 && targ[0] == x.Separator
-	if baseSlashed != targSlashed || !x.sameWord(baseVol, targVol) {
-		return "", errors.New("Rel: can't make " + targpath + " relative to " + basepath)
-	}
-	// Position base[b0:bi] and targ[t0:ti] at the first differing elements.
-	bl := len(base)
-	tl := len(targ)
-	var b0, bi, t0, ti int
-	for {
-		for bi < bl && base[bi] != x.Separator {
-			bi++
-		}
-		for ti < tl && targ[ti] != x.Separator {
-			ti++
-		}
-		if !x.sameWord(targ[t0:ti], base[b0:bi]) {
-			break
-		}
-		if bi < bl {
-			bi++
-		}
-		if ti < tl {
-			ti++
-		}
-		b0 = bi
-		t0 = ti
-	}
-	if base[b0:bi] == ".." {
-		return "", errors.New("Rel: can't make " + targpath + " relative to " + basepath)
-	}
-	if b0 != bl {
-		// Base elements left. Must go up before going down.
-		seps := strings.Count(base[b0:bl], string(x.Separator))
-		size := 2 + seps*3
-		if tl != t0 {
-			size += 1 + tl - t0
-		}
-		buf := make([]byte, size)
-		n := copy(buf, "..")
-		for i := 0; i < seps; i++ {
-			buf[n] = x.Separator
-			copy(buf[n+1:], "..")
-			n += 3
-		}
-		if t0 != tl {
-			buf[n] = x.Separator
-			copy(buf[n+1:], targ[t0:])
-		}
-		return string(buf), nil
-	}
-	return targ[t0:], nil
-}
-
-// Base returns the last element of path.
-// Trailing path separators are removed before extracting the last element.
-// If the path is empty, Base returns ".".
-// If the path consists entirely of separators, Base returns a single separator.
-// The default value for os is Unix.
-func Base(path string, os OS) string {
-	x := getOS(os)
-	if path == "" {
-		return "."
-	}
-	// Strip trailing slashes.
-	for len(path) > 0 && x.IsPathSeparator(path[len(path)-1]) {
-		path = path[0 : len(path)-1]
-	}
-	// Throw away volume name
-	path = path[x.volumeNameLen(path):]
-	// Find the last element
-	i := len(path) - 1
-	for i >= 0 && !x.IsPathSeparator(path[i]) {
-		i--
-	}
-	if i >= 0 {
-		path = path[i+1:]
-	}
-	// If empty now, it had only slashes.
-	if path == "" {
-		return string(x.Separator)
-	}
-	return path
-}
-
-// Dir returns all but the last element of path, typically the path's directory.
-// After dropping the final element, Dir calls Clean on the path and trailing
-// slashes are removed.
-// If the path is empty, Dir returns ".".
-// If the path consists entirely of separators, Dir returns a single separator.
-// The returned path does not end in a separator unless it is the root directory.
-// The default value for os is Unix.
-func Dir(path string, os OS) string {
-	x := getOS(os)
-	vol := volumeName(path, x)
-	i := len(path) - 1
-	for i >= len(vol) && !x.IsPathSeparator(path[i]) {
-		i--
-	}
-	dir := clean(path[len(vol):i+1], x)
-	if dir == "." && len(vol) > 2 {
-		// must be UNC
-		return vol
-	}
-	return vol + dir
-}
-
-// IsAbs reports whether the path is absolute. The default value for os is Unix.
-func IsAbs(path string, os OS) bool {
-	return getOS(os).IsAbs(path)
-}
-
-// VolumeName returns leading volume name.
-// Given "C:\foo\bar" it returns "C:" on Windows.
-// Given "\\host\share\foo" it returns "\\host\share".
-// On other platforms it returns "".
-// The default value for os is Windows.
-func VolumeName(path string, os OS) string {
-	return volumeName(path, getOS(os))
-}
-
-func volumeName(path string, os os) string {
-	return path[:os.volumeNameLen(path)]
-}