diff --git a/internal/core/convert/go.go b/internal/core/convert/go.go
index 8aeca32..f84ff9f 100644
--- a/internal/core/convert/go.go
+++ b/internal/core/convert/go.go
@@ -33,8 +33,10 @@
 	"cuelang.org/go/cue/errors"
 	"cuelang.org/go/cue/parser"
 	"cuelang.org/go/cue/token"
+	"cuelang.org/go/internal"
 	"cuelang.org/go/internal/core/adt"
 	"cuelang.org/go/internal/core/compile"
+	"cuelang.org/go/internal/core/runtime"
 )
 
 // This file contains functionality for converting Go to CUE.
@@ -220,6 +222,15 @@
 }
 
 func convertRec(ctx *adt.OpContext, nilIsTop bool, x interface{}) adt.Value {
+	if internal.CoreValue != nil {
+		if ii, iv := internal.CoreValue(x); ii != nil {
+			i := ii.(*runtime.Index)
+			v := iv.(*adt.Vertex)
+			// TODO: panic if nto the same runtime.
+			_ = i
+			return v
+		}
+	}
 	src := ctx.Source()
 	switch v := x.(type) {
 	case nil:
diff --git a/internal/core/convert/go_test.go b/internal/core/convert/go_test.go
index 21492c2..88db590 100644
--- a/internal/core/convert/go_test.go
+++ b/internal/core/convert/go_test.go
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package convert
+package convert_test
 
 import (
 	"math/big"
@@ -25,9 +25,11 @@
 
 	"cuelang.org/go/cue/errors"
 	"cuelang.org/go/internal/core/adt"
+	"cuelang.org/go/internal/core/convert"
 	"cuelang.org/go/internal/core/debug"
 	"cuelang.org/go/internal/core/eval"
 	"cuelang.org/go/internal/core/runtime"
+	_ "cuelang.org/go/internal/legacy/cue" // set internal.CoreValue
 )
 
 func mkBigInt(a int64) (v apd.Decimal) { v.SetInt64(a); return }
@@ -187,7 +189,7 @@
 		e := eval.New(r)
 		ctx := adt.NewContext(r, e, &adt.Vertex{})
 		t.Run("", func(t *testing.T) {
-			v := GoValueToValue(ctx, tc.goVal, true)
+			v := convert.GoValueToValue(ctx, tc.goVal, true)
 			got := debug.NodeString(ctx, v, nil)
 			if got != tc.want {
 				t.Error(cmp.Diff(got, tc.want))
@@ -205,7 +207,7 @@
 	e := eval.New(r)
 	ctx := adt.NewContext(r, e, &adt.Vertex{})
 
-	v := GoValueToValue(ctx, x, false)
+	v := convert.GoValueToValue(ctx, x, false)
 	// if err != nil {
 	// 	t.Fatal(err)
 	// }
@@ -327,7 +329,7 @@
 		t.Run("", func(t *testing.T) {
 			e := eval.New(r)
 			ctx := adt.NewContext(r, e, &adt.Vertex{})
-			v, _ := GoTypeToExpr(ctx, tc.goTyp)
+			v, _ := convert.GoTypeToExpr(ctx, tc.goTyp)
 			got := debug.NodeString(ctx, v, nil)
 			if got != tc.want {
 				t.Errorf("\n got %q;\nwant %q", got, tc.want)
diff --git a/internal/internal.go b/internal/internal.go
index 8585992..d4e31dc 100644
--- a/internal/internal.go
+++ b/internal/internal.go
@@ -77,6 +77,10 @@
 // GetRuntime reports the runtime for an Instance or Value.
 var GetRuntimeNew func(instance interface{}) interface{}
 
+// CoreValue returns an *runtime.Index and *adt.Vertex for a cue.Value.
+// It returns nil if value is not a cue.Value.
+var CoreValue func(value interface{}) (runtime, vertex interface{})
+
 // MakeInstance makes a new instance from a value.
 var MakeInstance func(value interface{}) (instance interface{})
 
diff --git a/internal/legacy/cue/alias.go b/internal/legacy/cue/alias.go
index ee438fc..83146a6 100644
--- a/internal/legacy/cue/alias.go
+++ b/internal/legacy/cue/alias.go
@@ -19,34 +19,34 @@
 type (
 	bottom    = adt.Bottom
 	source    = adt.Node
-	errCode   = adt.ErrorCode
 	kind      = adt.Kind
 	nullLit   = adt.Null
 	boolLit   = adt.Bool
 	numLit    = adt.Num
 	stringLit = adt.String
 	bytesLit  = adt.Bytes
-	context   = adt.OpContext
 	structLit = adt.Vertex
 
 	arc       = *adt.Vertex
 	value     = adt.Expr
 	evaluated = adt.Value
 	label     = adt.Feature
-	Op        = adt.Op
 
-	listLit       = adt.ListLit
-	top           = adt.Top
-	basicType     = adt.BasicType
-	boundExpr     = adt.BoundExpr
-	boundValue    = adt.BoundValue
-	selectorExpr  = adt.SelectorExpr
-	indexExpr     = adt.IndexExpr
-	sliceExpr     = adt.SliceExpr
-	interpolation = adt.Interpolation
-	unaryExpr     = adt.UnaryExpr
-	binaryExpr    = adt.BinaryExpr
-	callExpr      = adt.CallExpr
+	listLit         = adt.ListLit
+	top             = adt.Top
+	basicType       = adt.BasicType
+	boundExpr       = adt.BoundExpr
+	boundValue      = adt.BoundValue
+	selectorExpr    = adt.SelectorExpr
+	indexExpr       = adt.IndexExpr
+	sliceExpr       = adt.SliceExpr
+	interpolation   = adt.Interpolation
+	unaryExpr       = adt.UnaryExpr
+	binaryExpr      = adt.BinaryExpr
+	callExpr        = adt.CallExpr
+	disjunction     = adt.DisjunctionExpr
+	dValue          = adt.Disjunct
+	customValidator = adt.BuiltinValidator
 )
 
 const (
@@ -61,9 +61,4 @@
 	listKind   = adt.ListKind
 	structKind = adt.StructKind
 	bottomKind = adt.BottomKind
-
-	NoOp = adt.NoOp
-
-	codeIncomplete = adt.IncompleteError
-	codeNotExist   = adt.IncompleteError
 )
diff --git a/internal/legacy/cue/build.go b/internal/legacy/cue/build.go
index 9f86daf..65f0932 100644
--- a/internal/legacy/cue/build.go
+++ b/internal/legacy/cue/build.go
@@ -15,6 +15,7 @@
 package cue
 
 import (
+	"strings"
 	"sync"
 
 	"cuelang.org/go/cue/ast"
@@ -23,6 +24,8 @@
 	"cuelang.org/go/cue/errors"
 	"cuelang.org/go/cue/token"
 	"cuelang.org/go/internal"
+	"cuelang.org/go/internal/core/adt"
+	"cuelang.org/go/internal/core/compile"
 	"cuelang.org/go/internal/core/runtime"
 )
 
@@ -38,7 +41,7 @@
 }
 
 func init() {
-	internal.GetRuntime = func(instance interface{}) interface{} {
+	internal.GetRuntimeNew = func(instance interface{}) interface{} {
 		switch x := instance.(type) {
 		case Value:
 			return &Runtime{idx: x.idx}
@@ -51,7 +54,7 @@
 		}
 	}
 
-	internal.CheckAndForkRuntime = func(runtime, value interface{}) interface{} {
+	internal.CheckAndForkRuntimeNew = func(runtime, value interface{}) interface{} {
 		r := runtime.(*Runtime)
 		idx := value.(Value).ctx().index
 		if idx != r.idx {
@@ -59,6 +62,13 @@
 		}
 		return &Runtime{idx: newIndex(idx)}
 	}
+
+	internal.CoreValue = func(value interface{}) (runtime, vertex interface{}) {
+		if v, ok := value.(Value); ok && v.v != nil {
+			return v.idx.Index, v.v
+		}
+		return nil, nil
+	}
 }
 
 func dummyLoad(token.Pos, string) *build.Instance { return nil }
@@ -192,6 +202,7 @@
 //
 // All instances belonging to the same package should share this index.
 type index struct {
+	adt.Runtime
 	*runtime.Index
 
 	loaded map[*build.Instance]*Instance
@@ -201,16 +212,35 @@
 // sharedIndex is used for indexing builtins and any other labels common to
 // all instances.
 var sharedIndex = &index{
-	Index:  runtime.SharedIndex,
-	loaded: map[*build.Instance]*Instance{},
+	Runtime: runtime.SharedRuntimeNew,
+	Index:   runtime.SharedIndexNew,
+	loaded:  map[*build.Instance]*Instance{},
+}
+
+// NewRuntime creates a *runtime.Runtime with builtins preloaded.
+func NewRuntime() *runtime.Runtime {
+	idx := runtime.NewIndex(sharedIndex.Index)
+	r := runtime.NewWithIndex(idx)
+	i := &index{
+		Runtime: r,
+		Index:   idx,
+		loaded:  map[*build.Instance]*Instance{},
+	}
+	r.Data = i
+	return r
 }
 
 // newIndex creates a new index.
 func newIndex(parent *index) *index {
-	return &index{
-		Index:  runtime.NewIndex(parent.Index),
-		loaded: map[*build.Instance]*Instance{},
+	idx := runtime.NewIndex(parent.Index)
+	r := runtime.NewWithIndex(idx)
+	i := &index{
+		Runtime: r,
+		Index:   idx,
+		loaded:  map[*build.Instance]*Instance{},
 	}
+	r.Data = i
+	return i
 }
 
 func isBuiltin(s string) bool {
@@ -219,30 +249,93 @@
 }
 
 func (idx *index) loadInstance(p *build.Instance) *Instance {
-	if inst := idx.loaded[p]; inst != nil {
-		if !inst.complete {
-			// cycles should be detected by the builder and it should not be
-			// possible to construct a build.Instance that has them.
-			panic("cue: cycle")
+	_ = visitInstances(p, func(p *build.Instance, errs errors.Error) errors.Error {
+		if inst := idx.loaded[p]; inst != nil {
+			if !inst.complete {
+				// cycles should be detected by the builder and it should not be
+				// possible to construct a build.Instance that has them.
+				panic("cue: cycle")
+			}
+			return inst.Err
 		}
-		return inst
-	}
-	errs := runtime.ResolveFiles(idx.Index, p, isBuiltin)
-	files := p.Files
-	inst := newInstance(idx, p)
-	idx.loaded[p] = inst
 
-	if inst.Err == nil {
-		// inst.instance.index.state = s
-		// inst.instance.inst = p
+		err := runtime.ResolveFiles(idx.Index, p, isBuiltin)
+		errs = errors.Append(errs, err)
+
+		v, err := compile.Files(nil, idx.Runtime, p.Files...)
+		errs = errors.Append(errs, err)
+
+		inst := newInstance(idx, p, v)
+		idx.loaded[p] = inst
 		inst.Err = errs
-		for _, f := range files {
-			err := inst.insertFile(f)
-			inst.Err = errors.Append(inst.Err, err)
+
+		inst.ImportPath = p.ImportPath
+		inst.complete = true
+
+		return inst.Err
+	})
+
+	return idx.loaded[p]
+}
+
+// TODO: runtime.Runtime has a similar, much simpler, implementation. This
+// code should go.
+
+type visitFunc func(b *build.Instance, err errors.Error) (errs errors.Error)
+
+// visitInstances calls f for each transitive dependency.
+//
+// It passes any errors that occur in transitive dependencies to the visitFunc.
+// visitFunc must return the errors it is passed or return nil to ignore it.
+func visitInstances(b *build.Instance, f visitFunc) (errs errors.Error) {
+	v := visitor{b: b, f: f, errs: b.Err}
+	for _, file := range b.Files {
+		v.file(file)
+	}
+	return v.f(b, v.errs)
+}
+
+type visitor struct {
+	b    *build.Instance
+	f    visitFunc
+	errs errors.Error
+}
+
+func (v *visitor) addErr(e errors.Error) {
+	v.errs = errors.Append(v.errs, e)
+}
+
+func (v *visitor) file(file *ast.File) {
+	for _, d := range file.Decls {
+		switch x := d.(type) {
+		case *ast.Package:
+		case *ast.ImportDecl:
+			for _, s := range x.Specs {
+				v.spec(s)
+			}
+		case *ast.CommentGroup:
+		default:
+			return
 		}
 	}
-	inst.ImportPath = p.ImportPath
+}
 
-	inst.complete = true
-	return inst
+func (v *visitor) spec(spec *ast.ImportSpec) {
+	info, err := astutil.ParseImportSpec(spec)
+	if err != nil {
+		v.addErr(errors.Promote(err, "invalid import path"))
+		return
+	}
+
+	pkg := v.b.LookupImport(info.ID)
+	if pkg == nil {
+		if strings.Contains(info.ID, ".") {
+			v.addErr(errors.Newf(spec.Pos(),
+				"package %q imported but not defined in %s",
+				info.ID, v.b.ImportPath))
+		}
+		return
+	}
+
+	v.addErr(visitInstances(pkg, v.f))
 }
diff --git a/internal/legacy/cue/build_test.go b/internal/legacy/cue/build_test.go
index 7817ec7..4cf0ccb 100644
--- a/internal/legacy/cue/build_test.go
+++ b/internal/legacy/cue/build_test.go
@@ -16,12 +16,12 @@
 
 import (
 	"fmt"
-	"strings"
 	"testing"
 
 	"cuelang.org/go/cue/ast"
 	"cuelang.org/go/cue/build"
 	"cuelang.org/go/cue/token"
+	"cuelang.org/go/internal/core/debug"
 )
 
 func TestFromExpr(t *testing.T) {
@@ -36,7 +36,7 @@
 			ast.NewString("Hello"),
 			ast.NewString("World"),
 		),
-		out: `["Hello","World"]`,
+		out: `["Hello", "World"]`,
 	}}
 	for _, tc := range testCases {
 		t.Run("", func(t *testing.T) {
@@ -45,8 +45,7 @@
 			if err != nil {
 				t.Fatal(err)
 			}
-			ctx := inst.newContext()
-			if got := debugStr(ctx, inst.eval(ctx)); got != tc.out {
+			if got := fmt.Sprint(inst.Value()); got != tc.out {
 				t.Errorf("\n got: %v; want %v", got, tc.out)
 			}
 		})
@@ -86,7 +85,7 @@
 		emit      string
 	}{{
 		insts(&bimport{"", files(`test: "ok"`)}),
-		`{test: "ok"}`,
+		`{test:"ok"}`,
 	}, {
 		insts(&bimport{"",
 			files(
@@ -200,7 +199,8 @@
 			if err := insts[0].Err; err != nil {
 				got = err.Error()
 			} else {
-				got = strings.TrimSpace(fmt.Sprintf("%s\n", insts[0].Value()))
+				cfg := &debug.Config{Compact: true}
+				got = debug.NodeString(insts[0].Index, insts[0].Value().v, cfg)
 			}
 			if got != tc.emit {
 				t.Errorf("\n got: %s\nwant: %s", got, tc.emit)
diff --git a/internal/legacy/cue/builtin.go b/internal/legacy/cue/builtin.go
index cfd98a6..79b4a75 100644
--- a/internal/legacy/cue/builtin.go
+++ b/internal/legacy/cue/builtin.go
@@ -33,6 +33,10 @@
 	"cuelang.org/go/cue/parser"
 	"cuelang.org/go/cue/token"
 	"cuelang.org/go/internal"
+	"cuelang.org/go/internal/core/adt"
+	"cuelang.org/go/internal/core/compile"
+	"cuelang.org/go/internal/core/convert"
+	"cuelang.org/go/internal/core/runtime"
 )
 
 // A builtin is a builtin function or constant.
@@ -54,7 +58,6 @@
 //   map[string]T
 //
 type builtin struct {
-	baseValue
 	Name   string
 	pkg    label
 	Params []kind
@@ -69,21 +72,27 @@
 	cue    string
 }
 
-func mustCompileBuiltins(ctx *context, p *builtinPkg, pkgName string) *structLit {
-	obj := &structLit{}
+func mustCompileBuiltins(ctx *context, p *builtinPkg, pkgName string) *adt.Vertex {
+	obj := &adt.Vertex{}
 	pkgLabel := ctx.Label(pkgName, false)
+	st := &adt.StructLit{}
+	if len(p.native) > 0 {
+		obj.AddConjunct(adt.MakeConjunct(nil, st))
+	}
 	for _, b := range p.native {
 		b.pkg = pkgLabel
 
 		f := ctx.Label(b.Name, false) // never starts with _
 		// n := &node{baseValue: newBase(imp.Path)}
-		var v evaluated = b
+		var v adt.Expr = toBuiltin(ctx, b)
 		if b.Const != "" {
 			v = mustParseConstBuiltin(ctx, b.Name, b.Const)
 		}
-		obj.Arcs = append(obj.Arcs, arc{Label: f, v: v})
+		st.Decls = append(st.Decls, &adt.Field{
+			Label: f,
+			Value: v,
+		})
 	}
-	sort.Sort(obj)
 
 	// Parse builtin CUE
 	if p.cue != "" {
@@ -91,32 +100,77 @@
 		if err != nil {
 			panic(fmt.Errorf("could not parse %v: %v", p.cue, err))
 		}
-		v := newVisitor(ctx.index, nil, nil, nil, false)
-		value := v.walk(expr)
-		pkg := value.evalPartial(ctx).(*structLit)
-		for _, a := range pkg.Arcs {
-			// Discard option status and attributes at top level.
-			// TODO: filter on capitalized fields?
-			obj.insertValue(ctx, a.Label, false, false, a.v, nil, a.docs)
+		c, err := compile.Expr(nil, ctx.opCtx.Runtime, expr)
+		if err != nil {
+			panic(fmt.Errorf("could compile parse %v: %v", p.cue, err))
 		}
+		obj.AddConjunct(c)
+	}
+
+	// We could compile lazily, but this is easier for debugging.
+	obj.Finalize(ctx.opCtx)
+	if err := obj.Err(ctx.opCtx, adt.Finalized); err != nil {
+		panic(err.Err)
 	}
 
 	return obj
 }
 
+func toBuiltin(ctx *context, b *builtin) *adt.Builtin {
+	x := &adt.Builtin{
+		Params:  b.Params,
+		Result:  b.Result,
+		Package: b.pkg,
+		Name:    b.Name,
+	}
+	x.Func = func(ctx *adt.OpContext, args []adt.Value) (ret adt.Expr) {
+		runtime := ctx.Impl().(*runtime.Runtime)
+		index := runtime.Data.(*index)
+
+		// call, _ := ctx.Source().(*ast.CallExpr)
+		c := &callCtxt{
+			idx: index,
+			// src:  call,
+			ctx:     index.newContext(),
+			args:    args,
+			builtin: b,
+		}
+		defer func() {
+			var errVal interface{} = c.err
+			if err := recover(); err != nil {
+				errVal = err
+			}
+			ret = processErr(c, errVal, ret)
+		}()
+		b.Func(c)
+		switch v := c.ret.(type) {
+		case adt.Value:
+			return v
+		case *valueError:
+			return v.err
+		}
+		if c.err != nil {
+			return nil
+		}
+		return convert.GoValueToValue(ctx, c.ret, true)
+	}
+	return x
+}
+
 // newConstBuiltin parses and creates any CUE expression that does not have
 // fields.
-func mustParseConstBuiltin(ctx *context, name, val string) evaluated {
+func mustParseConstBuiltin(ctx *context, name, val string) adt.Expr {
 	expr, err := parser.ParseExpr("<builtin:"+name+">", val)
 	if err != nil {
 		panic(err)
 	}
-	v := newVisitor(ctx.index, nil, nil, nil, false)
-	value := v.walk(expr)
-	return value.evalPartial(ctx)
-}
+	c, err := compile.Expr(nil, ctx.Runtime, expr)
+	if err != nil {
+		panic(err)
+	}
+	return c.Expr()
 
-var _ caller = &builtin{}
+}
 
 var lenBuiltin = &builtin{
 	Name:   "len",
@@ -163,17 +217,34 @@
 	},
 }
 
+func pos(n adt.Node) (p token.Pos) {
+	if n == nil {
+		return
+	}
+	src := n.Source()
+	if src == nil {
+		return
+	}
+	return src.Pos()
+}
+
 var closeBuiltin = &builtin{
 	Name:   "close",
 	Params: []kind{structKind},
 	Result: structKind,
 	Func: func(c *callCtxt) {
-		s, ok := c.args[0].(*structLit)
+		s, ok := c.args[0].(*adt.Vertex)
 		if !ok {
-			c.ret = errors.Newf(c.args[0].Pos(), "struct argument must be concrete")
+			c.ret = errors.Newf(pos(c.args[0]), "struct argument must be concrete")
 			return
 		}
-		c.ret = s.close()
+		if s.IsClosed(c.ctx.opCtx) {
+			c.ret = s
+		} else {
+			v := *s
+			v.Closed = nil // TODO: set dedicated Closer.
+			c.ret = &v
+		}
 	},
 }
 
@@ -184,12 +255,12 @@
 	Func: func(c *callCtxt) {
 		iter := c.iter(0)
 		if !iter.Next() {
-			c.ret = &top{baseValue{c.src}}
+			c.ret = &top{}
 			return
 		}
-		u := iter.Value().v.v
+		var u adt.Expr = iter.Value().v
 		for iter.Next() {
-			u = mkBin(c.ctx, c.src.Pos(), opUnify, u, iter.Value().v.v)
+			u = &adt.BinaryExpr{Op: adt.AndOp, X: u, Y: iter.Value().v}
 		}
 		c.ret = u
 	},
@@ -201,11 +272,11 @@
 	Result: intKind,
 	Func: func(c *callCtxt) {
 		iter := c.iter(0)
-		d := []dValue{}
+		d := []adt.Disjunct{}
 		for iter.Next() {
-			d = append(d, dValue{iter.Value().v.v, false})
+			d = append(d, adt.Disjunct{iter.Value().v, false})
 		}
-		c.ret = &disjunction{baseValue{c.src}, d, nil, false}
+		c.ret = &adt.DisjunctionExpr{nil, d, false}
 		if len(d) == 0 {
 			// TODO(manifest): This should not be unconditionally incomplete,
 			// but it requires results from comprehensions and all to have
@@ -214,33 +285,14 @@
 			// an open list or struct. This would actually be exactly what
 			// that means. The error here could then only add an incomplete
 			// status if the source is open.
-			c.ret = c.ctx.mkErr(c.src, codeIncomplete, "empty list in call to or")
+			c.ret = &adt.Bottom{
+				Code: adt.IncompleteError,
+				Err:  errors.Newf(c.Pos(), "empty list in call to or"),
+			}
 		}
 	},
 }
 
-func (x *builtin) representedKind() kind {
-	if x.isValidator() {
-		return x.Params[0]
-	}
-	return x.Kind()
-}
-
-func (x *builtin) Kind() kind {
-	return lambdaKind
-}
-
-func (x *builtin) evalPartial(ctx *context) evaluated {
-	return x
-}
-
-func (x *builtin) subsumesImpl(s *subsumer, v value) bool {
-	if y, ok := v.(*builtin); ok {
-		return x == y
-	}
-	return false
-}
-
 func (x *builtin) name(ctx *context) string {
 	if x.pkg == 0 {
 		return x.Name
@@ -252,61 +304,9 @@
 	return len(x.Params) == 1 && x.Result == boolKind
 }
 
-func convertBuiltin(v evaluated) evaluated {
-	x, ok := v.(*builtin)
-	if ok && x.isValidator() {
-		return &customValidator{v.base(), x, []evaluated{}}
-	}
-	return v
-}
-
-func (x *builtin) call(ctx *context, src source, args ...evaluated) (ret value) {
-	if x.Func == nil {
-		return ctx.mkErr(x, "builtin %s is not a function", x.name(ctx))
-	}
-	if len(x.Params)-1 == len(args) && x.Result == boolKind {
-		// We have a custom builtin
-		return &customValidator{src.base(), x, args}
-	}
-	switch {
-	case len(x.Params) < len(args):
-		return ctx.mkErr(src, x, "too many arguments in call to %s (have %d, want %d)",
-			x.name(ctx), len(args), len(x.Params))
-	case len(x.Params) > len(args):
-		return ctx.mkErr(src, x, "not enough arguments in call to %s (have %d, want %d)",
-			x.name(ctx), len(args), len(x.Params))
-	}
-	for i, a := range args {
-		if x.Params[i] != bottomKind {
-			if unifyType(x.Params[i], a.Kind()) == bottomKind {
-				const msg = "cannot use %s (type %s) as %s in argument %d to %s"
-				return ctx.mkErr(src, x, msg, ctx.str(a), a.Kind(), x.Params[i], i+1, x.name(ctx))
-			}
-		}
-	}
-	call := callCtxt{src: src, ctx: ctx, builtin: x, args: args}
-	defer func() {
-		var errVal interface{} = call.err
-		if err := recover(); err != nil {
-			errVal = err
-		}
-		ret = processErr(&call, errVal, ret)
-	}()
-	x.Func(&call)
-	switch v := call.ret.(type) {
-	case value:
-		return v
-	case *valueError:
-		return v.err
-	}
-	return convertVal(ctx, x, true, call.ret)
-}
-
-func processErr(call *callCtxt, errVal interface{}, ret value) value {
+func processErr(call *callCtxt, errVal interface{}, ret adt.Expr) adt.Expr {
 	ctx := call.ctx
-	x := call.builtin
 	src := call.src
-	const msg = "error in call to %s: %v"
 	switch err := errVal.(type) {
 	case nil:
 	case *callError:
@@ -316,30 +316,92 @@
 			ret = err.b
 		}
 	case *marshalError:
-		ret = err.b
-		ret = ctx.mkErr(src, x, ret, msg, x.name(ctx), err)
+		ret = wrapCallErr(call, err.b)
 	case *valueError:
-		ret = err.err
-		ret = ctx.mkErr(src, x, ret, msg, x.name(ctx), err)
-	default:
+		ret = wrapCallErr(call, err.err)
+	case errors.Error:
+		ret = wrapCallErr(call, &adt.Bottom{Err: err})
+	case error:
 		if call.err == internal.ErrIncomplete {
 			ret = ctx.mkErr(src, codeIncomplete, "incomplete value")
 		} else {
 			// TODO: store the underlying error explicitly
-			ret = ctx.mkErr(src, x, msg, x.name(ctx), err)
+			ret = wrapCallErr(call, &adt.Bottom{Err: errors.Promote(err, "")})
 		}
+	default:
+		// Likely a string passed to panic.
+		ret = wrapCallErr(call, &adt.Bottom{
+			Err: errors.Newf(call.Pos(), "%s", err),
+		})
 	}
 	return ret
 }
 
+func wrapCallErr(c *callCtxt, b *adt.Bottom) *adt.Bottom {
+	pos := token.NoPos
+	if c.src != nil {
+		if src := c.src.Source(); src != nil {
+			pos = src.Pos()
+		}
+	}
+	const msg = "error in call to %s"
+	return &adt.Bottom{
+		Code: b.Code,
+		Err:  errors.Wrapf(b.Err, pos, msg, c.builtin.name(c.ctx)),
+	}
+}
+
+func (c *callCtxt) convertError(x interface{}, name string) *adt.Bottom {
+	var err errors.Error
+	switch v := x.(type) {
+	case nil:
+		return nil
+
+	case *adt.Bottom:
+		return v
+
+	case *json.MarshalerError:
+		err = errors.Promote(v, "marshal error")
+
+	case errors.Error:
+		err = v
+
+	case error:
+		if name != "" {
+			err = errors.Newf(c.Pos(), "%s: %v", name, v)
+		} else {
+			err = errors.Newf(c.Pos(), "error in call to %s: %v", c.name(), v)
+		}
+
+	default:
+		err = errors.Newf(token.NoPos, "%s", name)
+	}
+	if err != internal.ErrIncomplete {
+		return &adt.Bottom{
+			// Wrap to preserve position information.
+			Err: errors.Wrapf(err, c.Pos(), "error in call to %s", c.name()),
+		}
+	}
+	return &adt.Bottom{
+		Code: adt.IncompleteError,
+		Err:  errors.Newf(c.Pos(), "incomplete values in call to %s", c.name()),
+	}
+}
+
 // callCtxt is passed to builtin implementations.
 type callCtxt struct {
-	src     source
+	idx     *index
+	src     adt.Expr // *adt.CallExpr
 	ctx     *context
 	builtin *builtin
-	args    []evaluated
-	err     error
+	err     interface{}
 	ret     interface{}
+
+	args []adt.Value
+}
+
+func (c *callCtxt) Pos() token.Pos {
+	return c.ctx.opCtx.Pos()
 }
 
 func (c *callCtxt) name() string {
@@ -362,8 +424,7 @@
 		i := sharedIndex.addInst(&Instance{
 			ImportPath: k,
 			PkgName:    path.Base(k),
-			rootStruct: e,
-			rootValue:  e,
+			root:       e,
 		})
 
 		builtins[k] = i
@@ -380,7 +441,7 @@
 	if !ok {
 		return nil
 	}
-	return p.rootStruct
+	return p.root
 }
 
 func init() {
@@ -394,12 +455,12 @@
 		if s == nil {
 			return v
 		}
-		a := s.Lookup(ctx, ctx.Label(name, false))
-		if a.v == nil {
+		a := s.Lookup(ctx.Label(name, false))
+		if a == nil {
 			return v
 		}
 
-		return v.Unify(newValueRoot(ctx, a.v.evalPartial(ctx)))
+		return v.Unify(makeValue(v.idx, a))
 	}
 }
 
@@ -427,12 +488,21 @@
 	c.err = &callError{err}
 }
 
+func (c *callCtxt) errcf(src source, code adt.ErrorCode, format string, args ...interface{}) {
+	a := make([]interface{}, 0, 2+len(args))
+	a = append(a, code)
+	a = append(a, format)
+	a = append(a, args...)
+	err := c.ctx.mkErr(src, a...)
+	c.err = &callError{err}
+}
+
 func (c *callCtxt) value(i int) Value {
 	v := newValueRoot(c.ctx, c.args[i])
-	v, _ = v.Default()
+	// TODO: remove default
+	// v, _ = v.Default()
 	if !v.IsConcrete() {
-		c.errf(c.src, v.toErr(c.ctx.mkErr(c.src, codeIncomplete,
-			"non-concrete value")), "incomplete")
+		c.errcf(c.src, adt.IncompleteError, "non-concrete argument %d", i)
 	}
 	return v
 }
@@ -448,12 +518,26 @@
 }
 
 func (c *callCtxt) invalidArgType(arg value, i int, typ string, err error) {
+	if ve, ok := err.(*valueError); ok && ve.err.IsIncomplete() {
+		c.err = ve
+		return
+	}
+	v, ok := arg.(adt.Value)
+	// TODO: make these permanent errors if the value did not originate from
+	// a reference.
+	if !ok {
+		c.errf(c.src, nil,
+			"cannot use incomplete value %s as %s in argument %d to %s: %v",
+			c.ctx.str(arg), typ, i, c.name(), err)
+	}
 	if err != nil {
-		c.errf(c.src, err, "cannot use %s (type %s) as %s in argument %d to %s: %v",
-			c.ctx.str(arg), arg.Kind(), typ, i, c.name(), err)
+		c.errf(c.src, err,
+			"cannot use %s (type %s) as %s in argument %d to %s: %v",
+			c.ctx.str(arg), v.Kind(), typ, i, c.name(), err)
 	} else {
-		c.errf(c.src, nil, "cannot use %s (type %s) as %s in argument %d to %s",
-			c.ctx.str(arg), arg.Kind(), typ, i, c.name())
+		c.errf(c.src, err,
+			"cannot use %s (type %s) as %s in argument %d to %s",
+			c.ctx.str(arg), v.Kind(), typ, i, c.name())
 	}
 }
 
@@ -531,6 +615,8 @@
 	return n
 }
 
+var ten = big.NewInt(10)
+
 func (c *callCtxt) bigFloat(i int) *big.Float {
 	x := newValueRoot(c.ctx, c.args[i])
 	var mant big.Int
@@ -646,8 +732,8 @@
 	for j := 0; v.Next(); j++ {
 		str, err := v.Value().String()
 		if err != nil {
-			c.errf(c.src, err, "invalid list element %d in argument %d to %s: %v",
-				j, i, c.name(), err)
+			c.err = errors.Wrapf(err, c.Pos(),
+				"element %d of list argument %d", j, i)
 			break
 		}
 		a = append(a, str)
diff --git a/internal/legacy/cue/builtin_test.go b/internal/legacy/cue/builtin_test.go
index 1901d34..21ac694 100644
--- a/internal/legacy/cue/builtin_test.go
+++ b/internal/legacy/cue/builtin_test.go
@@ -49,7 +49,7 @@
 		`3`,
 	}, {
 		test("math", "math.Pi(3)"),
-		`_|_(cannot call non-function Pi (type float))`,
+		`_|_(cannot call non-function math.Pi (type float))`,
 	}, {
 		test("math", "math.Floor(3, 5)"),
 		`_|_(too many arguments in call to math.Floor (have 2, want 1))`,
@@ -91,10 +91,10 @@
 		`'foo'`,
 	}, {
 		test("encoding/base64", `base64.Decode(null, "foo")`),
-		`_|_(error in call to encoding/base64.Decode: illegal base64 data at input byte 0)`,
+		`_|_(error in call to encoding/base64.Decode: illegal base64 data at input byte 0 (and 1 more errors))`,
 	}, {
 		test("encoding/base64", `base64.Decode({}, "foo")`),
-		`_|_(error in call to encoding/base64.Decode: base64: unsupported encoding: cannot use value {} (type struct) as null)`,
+		`_|_(error in call to encoding/base64.Decode: base64: unsupported encoding: cannot use value {} (type struct) as null (and 1 more errors))`,
 	}, {
 		test("encoding/hex", `hex.Encode("foo")`),
 		`"666f6f"`,
@@ -103,7 +103,7 @@
 		`'foo'`,
 	}, {
 		test("encoding/hex", `hex.Decode("foo")`),
-		`_|_(error in call to encoding/hex.Decode: encoding/hex: invalid byte: U+006F 'o')`,
+		`_|_(error in call to encoding/hex.Decode: encoding/hex: invalid byte: U+006F 'o' (and 1 more errors))`,
 	}, {
 		test("encoding/hex", `hex.Dump('foo')`),
 		`"00000000  66 6f 6f                                          |foo|\n"`,
@@ -112,19 +112,19 @@
 		`true`,
 	}, {
 		test("encoding/json", `json.Validate("{\"a\":10}", {a:<3})`),
-		`_|_(error in call to encoding/json.Validate: a: invalid value 10 (out of bound <3))`,
+		`_|_(error in call to encoding/json.Validate: invalid value 10 (out of bound <3) (and 1 more errors))`,
 	}, {
 		test("encoding/yaml", `yaml.Validate("a: 2\n---\na: 4", {a:<3})`),
-		`_|_(error in call to encoding/yaml.Validate: a: invalid value 4 (out of bound <3))`,
+		`_|_(error in call to encoding/yaml.Validate: invalid value 4 (out of bound <3) (and 1 more errors))`,
 	}, {
 		test("encoding/yaml", `yaml.Validate("a: 2\n---\na: 4", {a:<5})`),
 		`true`,
 	}, {
 		test("encoding/yaml", `yaml.Validate("a: 2\n", {a:<5, b:int})`),
-		`_|_(error in call to encoding/yaml.Validate: b: incomplete value (int))`,
+		`_|_(error in call to encoding/yaml.Validate: incomplete value int (and 1 more errors))`,
 	}, {
 		test("encoding/yaml", `yaml.ValidatePartial("a: 2\n---\na: 4", {a:<3})`),
-		`_|_(error in call to encoding/yaml.ValidatePartial: a: invalid value 4 (out of bound <3))`,
+		`_|_(error in call to encoding/yaml.ValidatePartial: invalid value 4 (out of bound <3) (and 1 more errors))`,
 	}, {
 		test("encoding/yaml", `yaml.ValidatePartial("a: 2\n---\na: 4", {a:<5})`),
 		`true`,
@@ -137,11 +137,11 @@
 	}, {
 		// Find a better alternative, as this call should go.
 		test("strconv", `strconv.FormatFloat(3.02, 300, 4, 64)`),
-		`_|_(int 300 overflows byte in argument 1 in call to strconv.FormatFloat)`,
+		`_|_(int 300 overflows byte in argument 1 in call to strconv.FormatFloat (and 1 more errors))`,
 	}, {
 		// Find a better alternative, as this call should go.
 		test("strconv", `strconv.FormatFloat(3.02, -1, 4, 64)`),
-		`_|_(cannot use -1 (type int) as byte in argument 1 to strconv.FormatFloat)`,
+		`_|_(cannot use -1 (type int) as byte in argument 1 to strconv.FormatFloat (and 1 more errors))`,
 	}, {
 		// Find a better alternative, as this call should go.
 		test("strconv", `strconv.FormatFloat(3.02, 1.0, 4, 64)`),
@@ -151,7 +151,7 @@
 		`2.5`,
 	}, {
 		test("list", `list.Avg([])`),
-		`_|_(error in call to list.Avg: empty list)`,
+		`_|_(error in call to list.Avg: empty list (and 1 more errors))`,
 	}, {
 		test("list", `list.Avg("foo")`),
 		`_|_(cannot use "foo" (type string) as list in argument 1 to list.Avg)`,
@@ -166,7 +166,7 @@
 		`[]`,
 	}, {
 		test("list", `list.Drop([1, 2, 3, 4], -1)`),
-		`_|_(error in call to list.Drop: negative index)`,
+		`_|_(error in call to list.Drop: negative index (and 1 more errors))`,
 	}, {
 		test("list", `list.FlattenN([1, [[2, 3], []], [4]], -1)`),
 		`[1,2,3,4]`,
@@ -184,7 +184,7 @@
 		`[]`,
 	}, {
 		test("list", `list.FlattenN("foo", 1)`),
-		`_|_(error in call to list.FlattenN: cannot use value "foo" (type string) as list)`,
+		`_|_(error in call to list.FlattenN: cannot use value "foo" (type string) as list (and 1 more errors))`,
 	}, {
 		test("list", `list.FlattenN([], "foo")`),
 		`_|_(cannot use "foo" (type string) as int in argument 2 to list.FlattenN)`,
@@ -193,7 +193,7 @@
 		`4`,
 	}, {
 		test("list", `list.Max([])`),
-		`_|_(error in call to list.Max: empty list)`,
+		`_|_(error in call to list.Max: empty list (and 1 more errors))`,
 	}, {
 		test("list", `list.Max("foo")`),
 		`_|_(cannot use "foo" (type string) as list in argument 1 to list.Max)`,
@@ -202,7 +202,7 @@
 		`1`,
 	}, {
 		test("list", `list.Min([])`),
-		`_|_(error in call to list.Min: empty list)`,
+		`_|_(error in call to list.Min: empty list (and 1 more errors))`,
 	}, {
 		test("list", `list.Min("foo")`),
 		`_|_(cannot use "foo" (type string) as list in argument 1 to list.Min)`,
@@ -217,13 +217,13 @@
 		`_|_(cannot use "foo" (type string) as list in argument 1 to list.Product)`,
 	}, {
 		test("list", `list.Range(0, 5, 0)`),
-		`_|_(error in call to list.Range: step must be non zero)`,
+		`_|_(error in call to list.Range: step must be non zero (and 1 more errors))`,
 	}, {
 		test("list", `list.Range(5, 0, 1)`),
-		`_|_(error in call to list.Range: end must be greater than start when step is positive)`,
+		`_|_(error in call to list.Range: end must be greater than start when step is positive (and 1 more errors))`,
 	}, {
 		test("list", `list.Range(0, 5, -1)`),
-		`_|_(error in call to list.Range: end must be less than start when step is negative)`,
+		`_|_(error in call to list.Range: end must be less than start when step is negative (and 1 more errors))`,
 	}, {
 		test("list", `list.Range(0, 5, 1)`),
 		`[0,1,2,3,4]`,
@@ -244,16 +244,16 @@
 		`[2,3]`,
 	}, {
 		test("list", `list.Slice([1, 2, 3, 4], -1, 3)`),
-		`_|_(error in call to list.Slice: negative index)`,
+		`_|_(error in call to list.Slice: negative index (and 1 more errors))`,
 	}, {
 		test("list", `list.Slice([1, 2, 3, 4], 3, 1)`),
-		`_|_(error in call to list.Slice: invalid index: 3 > 1)`,
+		`_|_(error in call to list.Slice: invalid index: 3 > 1 (and 1 more errors))`,
 	}, {
 		test("list", `list.Slice([1, 2, 3, 4], 5, 5)`),
-		`_|_(error in call to list.Slice: slice bounds out of range)`,
+		`_|_(error in call to list.Slice: slice bounds out of range (and 1 more errors))`,
 	}, {
 		test("list", `list.Slice([1, 2, 3, 4], 1, 5)`),
-		`_|_(error in call to list.Slice: slice bounds out of range)`,
+		`_|_(error in call to list.Slice: slice bounds out of range (and 1 more errors))`,
 	}, {
 		test("list", `list.Sort([], list.Ascending)`),
 		`[]`,
@@ -266,16 +266,16 @@
 			y:_,
 			less: (x.a < y.a)
 		})`),
-		`[{a: 1, v: 2},{a: 1, v: 3},{a: 2, v: 1}]`,
+		`[{a:1,v:2},{a:1,v:3},{a:2,v:1}]`,
 	}, {
 		test("list", `list.Sort([{a:1}, {b:2}], list.Ascending)`),
-		`_|_(error in call to list.Sort: less: conflicting values close(T, close(T)) and {b: 2} (mismatched types number|string and struct))`,
+		`_|_(error in call to list.Sort: invalid operands {b:2} and {a:1} to '<' (type struct and struct) (and 1 more errors))`,
 	}, {
 		test("list", `list.SortStrings(["b", "a"])`),
 		`["a","b"]`,
 	}, {
 		test("list", `list.SortStrings([1, 2])`),
-		`_|_(invalid list element 0 in argument 0 to list.SortStrings: 0: cannot use value 1 (type int) as string)`,
+		`_|_(error in call to list.SortStrings: element 0 of list argument 0: 0: cannot use value 1 (type int) as string (and 1 more errors))`,
 	}, {
 		test("list", `list.Sum([1, 2, 3, 4])`),
 		`10`,
@@ -296,7 +296,7 @@
 		`[1,2,3,4]`,
 	}, {
 		test("list", `list.Take([1, 2, 3, 4], -1)`),
-		`_|_(error in call to list.Take: negative index)`,
+		`_|_(error in call to list.Take: negative index (and 1 more errors))`,
 	}, {
 		test("list", `list.MinItems([1, 2, 3, 4], 2)`),
 		`true`,
@@ -312,20 +312,20 @@
 	}, {
 		// Panics
 		test("math", `math.Jacobi(1000, 2000)`),
-		`_|_(error in call to math.Jacobi: big: invalid 2nd argument to Int.Jacobi: need odd integer but got 2000)`,
+		`_|_(error in call to math.Jacobi: big: invalid 2nd argument to Int.Jacobi: need odd integer but got 2000 (and 1 more errors))`,
 	}, {
 		test("math", `math.Jacobi(1000, 201)`),
 		`1`,
 	}, {
 		test("math", `math.Asin(2.0e400)`),
-		`_|_(cannot use 2.0e+400 (type float) as float64 in argument 0 to math.Asin: value was rounded up)`,
+		`_|_(cannot use 2.0E+400 (type float) as float64 in argument 0 to math.Asin: value was rounded up (and 1 more errors))`,
 	}, {
 		test("math", `math.MultipleOf(4, 2)`), `true`,
 	}, {
 		test("math", `math.MultipleOf(5, 2)`), `false`,
 	}, {
 		test("math", `math.MultipleOf(5, 0)`),
-		`_|_(error in call to math.MultipleOf: division by zero)`,
+		`_|_(error in call to math.MultipleOf: division by zero (and 1 more errors))`,
 	}, {
 		test("math", `math.MultipleOf(100, 1.00001)`), `false`,
 	}, {
@@ -342,7 +342,7 @@
 		`"foo"`,
 	}, {
 		test("regexp", `regexp.Find(#"f\w\w"#, "bar")`),
-		`_|_(error in call to regexp.Find: no match)`,
+		`_|_(error in call to regexp.Find: no match (and 1 more errors))`,
 	}, {
 		test("regexp", `regexp.FindAll(#"f\w\w"#, "afoot afloat from", 2)`),
 		`["foo","flo"]`,
@@ -351,7 +351,7 @@
 		`["foo","flo"]`,
 	}, {
 		test("regexp", `regexp.FindAll(#"f\w\w"#, "bla bla", -1)`),
-		`_|_(error in call to regexp.FindAll: no match)`,
+		`_|_(error in call to regexp.FindAll: no match (and 1 more errors))`,
 	}, {
 		test("regexp", `regexp.FindSubmatch(#"f(\w)(\w)"#, "afloat afoot from")`),
 		`["flo","l","o"]`,
@@ -360,19 +360,19 @@
 		`[["flo","l","o"],["foo","o","o"],["fro","r","o"]]`,
 	}, {
 		test("regexp", `regexp.FindAllSubmatch(#"f(\w)(\w)"#, "aglom", -1)`),
-		`_|_(error in call to regexp.FindAllSubmatch: no match)`,
+		`_|_(error in call to regexp.FindAllSubmatch: no match (and 1 more errors))`,
 	}, {
 		test("regexp", `regexp.FindNamedSubmatch(#"f(?P<A>\w)(?P<B>\w)"#, "afloat afoot from")`),
-		`{A: "l", B: "o"}`,
+		`{A:"l",B:"o"}`,
 	}, {
 		test("regexp", `regexp.FindAllNamedSubmatch(#"f(?P<A>\w)(?P<B>\w)"#, "afloat afoot from", -1)`),
-		`[{A: "l", B: "o"},{A: "o", B: "o"},{A: "r", B: "o"}]`,
+		`[{A:"l",B:"o"},{A:"o",B:"o"},{A:"r",B:"o"}]`,
 	}, {
 		test("regexp", `regexp.FindAllNamedSubmatch(#"f(?P<A>optional)?"#, "fbla", -1)`),
-		`[{A: ""}]`,
+		`[{A:""}]`,
 	}, {
 		test("regexp", `regexp.FindAllNamedSubmatch(#"f(?P<A>\w)(?P<B>\w)"#, "aglom", -1)`),
-		`_|_(error in call to regexp.FindAllNamedSubmatch: no match)`,
+		`_|_(error in call to regexp.FindAllNamedSubmatch: no match (and 1 more errors))`,
 	}, {
 		test("regexp", `regexp.Valid & "valid"`),
 		`"valid"`,
@@ -387,7 +387,7 @@
 		`"Hello World!"`,
 	}, {
 		test("strings", `strings.Join([1, 2], " ")`),
-		`_|_(invalid list element 0 in argument 0 to strings.Join: 0: cannot use value 1 (type int) as string)`,
+		`_|_(error in call to strings.Join: element 0 of list argument 0: 0: cannot use value 1 (type int) as string (and 1 more errors))`,
 	}, {
 		test("strings", `strings.ByteAt("a", 0)`),
 		strconv.Itoa('a'),
@@ -432,7 +432,7 @@
 		`2`,
 	}, {
 		testExpr(`or([])`),
-		`_|_(empty list in call to or)`,
+		`_|_(empty list in call to or (and 1 more errors))`,
 	}, {
 		test("encoding/csv", `csv.Encode([[1,2,3],[4,5],[7,8,9]])`),
 		`"1,2,3\n4,5\n7,8,9\n"`,
@@ -459,7 +459,7 @@
 			x: int
 			y: json.Marshal({a: x})
 		}`),
-		`{x: int, y: Marshal ({a: x})}`,
+		`{x:int,y:_|_(cannot convert incomplete value "int" to JSON (and 1 more errors))}`,
 	}, {
 		test("encoding/yaml", `yaml.MarshalStream([{a: 1}, {b: 2}])`),
 		`"a: 1\n---\nb: 2\n"`,
@@ -482,14 +482,15 @@
 		test("net", `net.JoinHostPort([192,30,4,2], 80)`),
 		`"192.30.4.2:80"`,
 	}, {
-		test("net", `net.JoinHostPort([192,30,4], 80)`),
-		`_|_(error in call to net.JoinHostPort: invalid host [192,30,4])`,
+		// TODO: why is this not printing compactly?
+		test("net", `net.JoinHostPort([192, 30, 4], 80)`),
+		`_|_(error in call to net.JoinHostPort: invalid host [192, 30, 4] (and 1 more errors))`,
 	}, {
 		test("net", `net.IP("23.23.23.23")`),
 		`true`,
 	}, {
 		test("net", `net.IPv4 & "23.23.23.2333"`),
-		`_|_(invalid value "23.23.23.2333" (does not satisfy net.IPv4()))`,
+		`_|_(invalid value "23.23.23.2333" (does not satisfy net.IPv4))`,
 	}, {
 		test("net", `net.IP("23.23.23.23")`),
 		`true`,
@@ -501,7 +502,7 @@
 		`false`,
 	}, {
 		test("net", `net.IPv4() & "ff02::1:3"`),
-		`_|_(invalid value "ff02::1:3" (does not satisfy net.IPv4()))`,
+		`_|_(invalid value "ff02::1:3" (does not satisfy net.IPv4))`,
 	}, {
 		test("net", `net.LoopbackIP([127, 0, 0, 1])`),
 		`true`,
@@ -549,23 +550,23 @@
 		`_|_(invalid value "hello" (does not satisfy strings.MinRunes(10)))`,
 	}, {
 		test("struct", `struct.MinFields(0) & ""`),
-		`_|_(conflicting values MinFields (0) and "" (mismatched types struct and string))`,
+		`_|_(invalid value "" (mismatched types string and struct))`,
 	}, {
 		test("struct", `struct.MinFields(0) & {a: 1}`),
-		`{a: 1}`,
+		`{a:1}`,
 	}, {
 		test("struct", `struct.MinFields(2) & {a: 1}`),
-		`_|_(invalid value {a: 1} (does not satisfy struct.MinFields(2)))`,
+		`_|_(invalid value {a:1} (does not satisfy struct.MinFields(2)))`,
 	}, {
 		test("struct", `struct.MaxFields(0) & {a: 1}`),
-		`_|_(invalid value {a: 1} (does not satisfy struct.MaxFields(0)))`,
+		`_|_(invalid value {a:1} (does not satisfy struct.MaxFields(0)))`,
 	}, {
 		test("struct", `struct.MaxFields(2) & {a: 1}`),
-		`{a: 1}`,
+		`{a:1}`,
 	}, {
 		test("math", `math.Pow(8, 4)`), `4096`,
 	}, {
-		test("math", `math.Pow10(4)`), `10000`,
+		test("math", `math.Pow10(4)`), `1E+4`,
 	}, {
 		test("math", `math.Signbit(-4)`), `true`,
 	}, {
@@ -669,7 +670,41 @@
 			if err := insts[0].Err; err != nil {
 				t.Fatal(err)
 			}
-			got := strings.TrimSpace(fmt.Sprintf("%s\n", insts[0].Value()))
+			v := insts[0].Value()
+			ctx := v.ctx()
+			got := ctx.opCtx.Str(v.v)
+			if got != tc.emit {
+				t.Errorf("\n got: %s\nwant: %s", got, tc.emit)
+			}
+		})
+	}
+}
+
+// For debugging purposes. Do not remove.
+func TestSingleBuiltin(t *testing.T) {
+	// t.Skip()
+
+	test := func(pkg, expr string) []*bimport {
+		return []*bimport{{"",
+			[]string{fmt.Sprintf("import %q\n(%s)", pkg, expr)},
+		}}
+	}
+	testCases := []struct {
+		instances []*bimport
+		emit      string
+	}{{
+		test("list", `list.Sort([{a:1}, {b:2}], list.Ascending)`),
+		`_|_(error in call to list.Sort: invalid operands {b:2} and {a:1} to '<' (type struct and struct) (and 1 more errors))`,
+	}}
+	for i, tc := range testCases {
+		t.Run(fmt.Sprint(i), func(t *testing.T) {
+			insts := Build(makeInstances(tc.instances))
+			if err := insts[0].Err; err != nil {
+				t.Fatal(err)
+			}
+			v := insts[0].Value()
+			ctx := v.ctx()
+			got := ctx.opCtx.Str(v.v)
 			if got != tc.emit {
 				t.Errorf("\n got: %s\nwant: %s", got, tc.emit)
 			}
diff --git a/internal/legacy/cue/builtins.go b/internal/legacy/cue/builtins.go
index 290ab79..87ad902 100644
--- a/internal/legacy/cue/builtins.go
+++ b/internal/legacy/cue/builtins.go
@@ -148,9 +148,9 @@
 }
 
 var builtinPackages = map[string]*builtinPkg{
-	"": {
-		native: []*builtin{},
-	},
+	// "": {
+	// 	native: []*builtin{},
+	// },
 	"crypto/md5": {
 		native: []*builtin{{
 			Name:  "Size",
@@ -612,13 +612,15 @@
 						if !json.Valid(b) {
 							return false, fmt.Errorf("json: invalid JSON")
 						}
-						r := internal.GetRuntime(v).(*Runtime)
+						r := internal.GetRuntimeNew(v).(*Runtime)
 						inst, err := r.Compile("json.Validate", b)
 						if err != nil {
 							return false, err
 						}
 
-						v = v.Unify(inst.Value())
+						t := inst.Value()
+
+						v = v.Unify(t)
 						if v.Err() != nil {
 							return false, v.Err()
 						}
@@ -709,7 +711,7 @@
 						if err != nil {
 							return false, err
 						}
-						r := internal.GetRuntime(v).(*Runtime)
+						r := internal.GetRuntimeNew(v).(*Runtime)
 						for {
 							expr, err := d.Decode()
 							if err != nil {
@@ -748,7 +750,7 @@
 						if err != nil {
 							return false, err
 						}
-						r := internal.GetRuntime(v).(*Runtime)
+						r := internal.GetRuntimeNew(v).(*Runtime)
 						for {
 							expr, err := d.Decode()
 							if err != nil {
diff --git a/internal/legacy/cue/builtinutil.go b/internal/legacy/cue/builtinutil.go
index df22d71..e226cfa 100644
--- a/internal/legacy/cue/builtinutil.go
+++ b/internal/legacy/cue/builtinutil.go
@@ -14,6 +14,11 @@
 
 package cue
 
+import (
+	"cuelang.org/go/internal/core/adt"
+	"cuelang.org/go/internal/core/convert"
+)
+
 // TODO: this code could be generated, but currently isn't.
 
 type valueSorter struct {
@@ -33,9 +38,12 @@
 func (s *valueSorter) Len() int      { return len(s.a) }
 func (s *valueSorter) Swap(i, j int) { s.a[i], s.a[j] = s.a[j], s.a[i] }
 func (s *valueSorter) Less(i, j int) bool {
-	x := fill(s.cmp, s.a[i], "x")
-	x = fill(x, s.a[j], "y")
-	isLess, err := x.Lookup("less").Bool()
+	ctx := s.cmp.ctx()
+	x := fill(ctx, s.cmp.v, s.a[i], "x")
+	x = fill(ctx, x, s.a[j], "y")
+	ctx.opCtx.Unify(ctx.opCtx, x, adt.Finalized) // TODO: remove.
+	v := Value{s.cmp.idx, x}
+	isLess, err := v.Lookup("less").Bool()
 	if err != nil && s.err == nil {
 		s.err = err
 		return true
@@ -45,13 +53,22 @@
 
 // fill creates a new value with the old value unified with the given value.
 // TODO: consider making this a method on Value.
-func fill(v Value, x interface{}, path ...string) Value {
-	ctx := v.ctx()
-	root := v.v.val()
+func fill(ctx *context, v *adt.Vertex, x interface{}, path ...string) *adt.Vertex {
 	for i := len(path) - 1; i >= 0; i-- {
 		x = map[string]interface{}{path[i]: x}
 	}
-	value := convertVal(ctx, root, false, x)
-	eval := binOp(ctx, baseValue{}, opUnify, root, value)
-	return newValueRoot(ctx, eval)
+	value := convertVal(ctx, v, false, x)
+
+	w := adt.ToVertex(value)
+	n := &adt.Vertex{Label: v.Label}
+	n.AddConjunct(adt.MakeConjunct(nil, v))
+	n.AddConjunct(adt.MakeConjunct(nil, w))
+
+	// n.Add(v)
+	// n.Add(w)
+	return n
+}
+
+func convertVal(ctx *context, src source, nullIsTop bool, x interface{}) adt.Value {
+	return convert.GoValueToValue(ctx.opCtx, x, nullIsTop)
 }
diff --git a/internal/legacy/cue/context.go b/internal/legacy/cue/context.go
index a63e3e9..3f00329 100644
--- a/internal/legacy/cue/context.go
+++ b/internal/legacy/cue/context.go
@@ -15,48 +15,17 @@
 package cue
 
 import (
+	"cuelang.org/go/internal/core/adt"
+	"cuelang.org/go/internal/core/debug"
+	"cuelang.org/go/internal/core/eval"
 	"github.com/cockroachdb/apd/v2"
 )
 
 // context manages evaluation state.
 type context struct {
+	opCtx *adt.OpContext
 	*apd.Context
-
 	*index
-
-	forwardMap []scope // pairs
-	oldSize    []int
-
-	// constraints are to be evaluated at the end values to be evaluated later.
-	constraints []*binaryExpr
-	evalStack   []bottom
-
-	inDefinition int
-	inSum        int
-	cycleErr     bool
-
-	// for debug strings
-	nodeRefs map[scope]string
-
-	// tracing
-	trace bool
-	level int
-
-	// TODO: replace with proper structural cycle detection/ occurs check.
-	// See Issue #29.
-	maxDepth int
-}
-
-func (c *context) incEvalDepth() {
-	if len(c.evalStack) > 0 {
-		c.evalStack[len(c.evalStack)-1].exprDepth++
-	}
-}
-
-func (c *context) decEvalDepth() {
-	if len(c.evalStack) > 0 {
-		c.evalStack[len(c.evalStack)-1].exprDepth--
-	}
 }
 
 var baseContext apd.Context
@@ -72,50 +41,56 @@
 		Context: &baseContext,
 		index:   idx,
 	}
+	if idx != nil {
+		c.opCtx = eval.NewContext(idx.Runtime, nil)
+	}
 	return c
 }
 
-// delayConstraint schedules constraint to be evaluated and returns ret. If
-// delaying constraints is currently not allowed, it returns an error instead.
-func (c *context) delayConstraint(ret evaluated, constraint *binaryExpr) evaluated {
-	c.cycleErr = true
-	c.constraints = append(c.constraints, constraint)
-	return ret
+func debugStr(ctx *context, v adt.Node) string {
+	return debug.NodeString(ctx.opCtx, v, nil)
 }
 
-func (c *context) processDelayedConstraints() evaluated {
-	cons := c.constraints
-	c.constraints = c.constraints[:0]
-	for _, dc := range cons {
-		v := binOp(c, dc, dc.Op, dc.X.evalPartial(c), dc.Y.evalPartial(c))
-		if isBottom(v) {
-			return v
-		}
+func (c *context) str(v adt.Node) string {
+	return debugStr(c, v)
+}
+
+func (c *context) mkErr(src source, args ...interface{}) *bottom {
+	return c.index.mkErr(src, args...)
+}
+
+func (c *context) vertex(v *adt.Vertex) *adt.Vertex {
+	return v
+}
+
+// vertex returns the evaluated vertex of v.
+func (v Value) vertex(ctx *context) *adt.Vertex {
+	return ctx.vertex(v.v)
+}
+
+// eval returns the evaluated value. This may not be the vertex.
+//
+// Deprecated: use ctx.value
+func (v Value) eval(ctx *context) adt.Value {
+	if v.v == nil {
+		panic("undefined value")
 	}
-	return nil
-}
-
-func (c *context) deref(f scope) scope {
-outer:
-	for {
-		for i := 0; i < len(c.forwardMap); i += 2 {
-			if c.forwardMap[i] == f {
-				f = c.forwardMap[i+1]
-				continue outer
-			}
-		}
-		return f
+	x := ctx.manifest(v.v)
+	switch x.Kind() {
+	case adt.StructKind, adt.ListKind:
+		return x
+	default:
+		return x.Value
 	}
 }
 
-func (c *context) pushForwards(pairs ...scope) *context {
-	c.oldSize = append(c.oldSize, len(c.forwardMap))
-	c.forwardMap = append(c.forwardMap, pairs...)
-	return c
-}
+// func (v Value) evalFull(u value) (Value, adt.Value) {
+// 	ctx := v.ctx()
+// 	x := ctx.manifest(u)
+// }
 
-func (c *context) popForwards() {
-	last := len(c.oldSize) - 1
-	c.forwardMap = c.forwardMap[:c.oldSize[last]]
-	c.oldSize = c.oldSize[:last]
+// TODO: change from Vertex to Vertex.
+func (c *context) manifest(v *adt.Vertex) *adt.Vertex {
+	v.Finalize(c.opCtx)
+	return v
 }
diff --git a/internal/legacy/cue/errors.go b/internal/legacy/cue/errors.go
index 467254f..21ed886 100644
--- a/internal/legacy/cue/errors.go
+++ b/internal/legacy/cue/errors.go
@@ -18,63 +18,22 @@
 	"fmt"
 	"reflect"
 
-	"cuelang.org/go/cue/ast"
 	"cuelang.org/go/cue/errors"
 	"cuelang.org/go/cue/token"
 	"cuelang.org/go/internal/core/adt"
 )
 
-var _ errors.Error = &nodeError{}
-
-// A nodeError is an error associated with processing an AST node.
-type nodeError struct {
-	path []string // optional
-	n    ast.Node
-
-	errors.Message
-}
-
-func (n *nodeError) Error() string {
-	return errors.String(n)
-}
-
-func nodeErrorf(n ast.Node, format string, args ...interface{}) *nodeError {
-	return &nodeError{
-		n:       n,
-		Message: errors.NewMessage(format, args),
-	}
-}
-
-func (e *nodeError) Position() token.Pos {
-	return e.n.Pos()
-}
-
-func (e *nodeError) InputPositions() []token.Pos { return nil }
-
-func (e *nodeError) Path() []string {
-	return e.path
-}
-
 func (v Value) appendErr(err errors.Error, b *bottom) errors.Error {
-	switch {
-	case len(b.sub) > 0:
-		for _, b := range b.sub {
-			err = v.appendErr(err, b)
-		}
-		fallthrough
-	case b.err != nil:
-		err = errors.Append(err, b.err)
-	default:
-		err = errors.Append(err, &valueError{
-			v:   v,
-			err: b,
-		})
+	return &valueError{
+		v: v,
+		err: &adt.Bottom{
+			Err: errors.Append(err, b.Err),
+		},
 	}
-	return err
 }
 
 func (v Value) toErr(b *bottom) (err errors.Error) {
-	return v.appendErr(nil, b)
+	return &valueError{v: v, err: b}
 }
 
 var _ errors.Error = &valueError{}
@@ -90,23 +49,29 @@
 }
 
 func (e *valueError) Position() token.Pos {
-	return e.err.Pos()
+	src := e.err.Source()
+	if src == nil {
+		return token.NoPos
+	}
+	return src.Pos()
 }
 
 func (e *valueError) InputPositions() []token.Pos {
-	return e.err.Positions(e.v.ctx())
+	if e.err.Err == nil {
+		return nil
+	}
+	return e.err.Err.InputPositions()
 }
 
 func (e *valueError) Msg() (string, []interface{}) {
-	return e.err.Msg()
+	if e.err.Err == nil {
+		return "", nil
+	}
+	return e.err.Err.Msg()
 }
 
 func (e *valueError) Path() (a []string) {
-	if e.v.v == nil {
-		return nil
-	}
-	a, _ = e.v.v.appendPath(a, e.v.idx)
-	return a
+	return e.v.appendPath(nil)
 }
 
 type errCode = adt.ErrorCode
@@ -135,7 +100,10 @@
 	return false
 }
 
-var errNotExists = &bottom{Code: codeNotExist, format: "undefined value"}
+var errNotExists = &adt.Bottom{
+	Code: codeNotExist,
+	Err:  errors.Newf(token.NoPos, "undefined value"),
+}
 
 func exists(v value) bool {
 	if err, ok := v.(*bottom); ok {
@@ -144,126 +112,39 @@
 	return true
 }
 
-// bottom is the bottom of the value lattice. It is subsumed by all values.
-type bottom struct {
-	baseValue
-
-	index     *index
-	Code      errCode
-	exprDepth int
-	pos       source
-	format    string
-	args      []interface{}
-
-	err     errors.Error // pass-through from higher-level API
-	sub     []*bottom    // sub errors
-	value   value
-	wrapped *bottom
-}
-
-func (x *bottom) Kind() kind { return bottomKind }
-
-func (x *bottom) Positions(ctx *context) []token.Pos {
-	var a []token.Pos
-	if x.index != nil { // TODO: remove check?
-		a = appendPositions(ctx, nil, x.pos)
-	}
-	if w := x.wrapped; w != nil {
-		a = append(a, w.Positions(ctx)...)
-	}
-	for _, sub := range x.sub {
-		a = append(a, sub.Positions(ctx)...)
-	}
-	return a
-}
-
-func appendPositions(ctx *context, pos []token.Pos, src source) []token.Pos {
-	if len(pos) > 15 {
-		return pos
-	}
-	if src != nil {
-		if p := src.Pos(); p != token.NoPos {
-			pos = append(pos, src.Pos())
-		}
-		if c := src.computed(); c != nil {
-			pos = appendPositions(ctx, pos, c.x)
-			pos = appendPositions(ctx, pos, c.y)
-		}
-		switch x := src.(type) {
-		case evaluated:
-		case value:
-			pos = appendPositions(ctx, pos, x.evalPartial(ctx))
-		}
-	}
-	return pos
-}
-
-func (x *bottom) Msg() (format string, args []interface{}) {
-	ctx := x.index.newContext()
-	// We need to copy to avoid races.
-	args = make([]interface{}, len(x.args))
-	copy(args, x.args)
-	preEvalArgs(ctx, args)
-	return x.format, x.args
-}
-
-func (x *bottom) msg() string {
-	return fmt.Sprint(x)
-}
-
-func (x *bottom) Format(s fmt.State, verb rune) {
-	msg, args := x.Msg()
-	fmt.Fprintf(s, msg, args...)
-}
-
-func cycleError(v evaluated) *bottom {
-	if err, ok := v.(*bottom); ok && err.Code == codeCycle {
-		return err
-	}
-	return nil
-}
-
-func (c *context) mkIncompatible(src source, op op, a, b evaluated) evaluated {
-	if err := firstBottom(a, b); err != nil {
-		return err
-	}
-	e := mkBin(c, src.Pos(), op, a, b)
-	return c.mkErr(e, "invalid operation %s %s %s (mismatched types %s and %s)",
-		c.str(a), op, c.str(b), a.Kind(), b.Kind())
-}
-
 func (idx *index) mkErr(src source, args ...interface{}) *bottom {
-	e := &bottom{index: idx, pos: src}
-	if src != nil {
-		e.baseValue = src.base()
-	}
-	if v, ok := src.(value); ok {
-		e.value = v
-	}
+	var e *adt.Bottom
+	var code errCode = -1
 outer:
 	for i, a := range args {
 		switch x := a.(type) {
 		case errCode:
-			e.Code = x
+			code = x
 		case *bottom:
-			e.wrapped = x
+			e = adt.CombineErrors(nil, e, x)
 		case []*bottom:
-			e.sub = x
+			for _, b := range x {
+				e = adt.CombineErrors(nil, e, b)
+			}
 		case errors.Error:
-			e.err = x
+			e = adt.CombineErrors(nil, e, &adt.Bottom{Err: x})
 		case value:
 		case string:
-			e.format = x
-			e.args = args[i+1:]
+			args := args[i+1:]
 			// Do not expand message so that errors can be localized.
-			for i, a := range e.args {
-				e.args[i] = fixArg(idx, a)
+			pos := pos(src)
+			if code < 0 {
+				code = 0
 			}
+			e = adt.CombineErrors(nil, e, &adt.Bottom{
+				Code: code,
+				Err:  errors.Newf(pos, x, args...),
+			})
 			break outer
 		}
 	}
-	if e.Code == codeNone && e.wrapped != nil {
-		e.Code = e.wrapped.Code
+	if code >= 0 {
+		e.Code = code
 	}
 	return e
 }
@@ -283,22 +164,12 @@
 	return fmt.Sprint(x)
 }
 
-// preEvalArgs is used to expand value arguments just before printing.
-func preEvalArgs(ctx *context, args []interface{}) {
-	for i, a := range args {
-		switch v := a.(type) {
-		case *bottom:
-			args[i] = v.msg()
-		case value:
-			// TODO: convert to Go values so that localization frameworks
-			// can format values accordingly.
-			args[i] = ctx.str(v)
-		}
+func isBottom(x adt.Node) bool {
+	if x == nil {
+		return true
 	}
-}
-
-func isBottom(n value) bool {
-	return n.Kind() == bottomKind
+	b, _ := x.(*adt.Bottom)
+	return b != nil
 }
 
 func firstBottom(v ...value) *bottom {
diff --git a/internal/legacy/cue/go.go b/internal/legacy/cue/go.go
new file mode 100644
index 0000000..28399d9
--- /dev/null
+++ b/internal/legacy/cue/go.go
@@ -0,0 +1,46 @@
+// 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 cue
+
+import (
+	"cuelang.org/go/internal"
+	"cuelang.org/go/internal/core/adt"
+	"cuelang.org/go/internal/core/convert"
+	"cuelang.org/go/internal/core/eval"
+)
+
+func init() {
+	internal.FromGoValue = func(runtime, x interface{}, nilIsTop bool) interface{} {
+		r := runtime.(*Runtime)
+		ctx := eval.NewContext(r.index().Runtime, nil)
+		v := convert.GoValueToValue(ctx, x, nilIsTop)
+		n := adt.ToVertex(v)
+		return Value{r.idx, n}
+	}
+
+	internal.FromGoType = func(runtime, x interface{}) interface{} {
+		r := runtime.(*Runtime)
+		ctx := eval.NewContext(r.index().Runtime, nil)
+		expr, err := convert.GoTypeToExpr(ctx, x)
+		if err != nil {
+			expr = &adt.Bottom{Err: err}
+		}
+		n := &adt.Vertex{}
+		n.AddConjunct(adt.MakeConjunct(nil, expr))
+		return Value{r.idx, n}
+
+		// return convertType(runtime.(*Runtime), x)
+	}
+}
diff --git a/internal/legacy/cue/instance.go b/internal/legacy/cue/instance.go
index a779041..5b954ea 100644
--- a/internal/legacy/cue/instance.go
+++ b/internal/legacy/cue/instance.go
@@ -18,8 +18,11 @@
 	"cuelang.org/go/cue/ast"
 	"cuelang.org/go/cue/build"
 	"cuelang.org/go/cue/errors"
-	"cuelang.org/go/cue/token"
 	"cuelang.org/go/internal"
+	"cuelang.org/go/internal/core/adt"
+	"cuelang.org/go/internal/core/compile"
+	"cuelang.org/go/internal/core/convert"
+	"cuelang.org/go/internal/core/eval"
 	"cuelang.org/go/internal/core/runtime"
 )
 
@@ -28,12 +31,7 @@
 type Instance struct {
 	*index
 
-	rootStruct *structLit // the struct to insert root values into
-	rootValue  value      // the value to evaluate: may add comprehensions
-
-	// scope is used as an additional top-level scope between the package scope
-	// and the predeclared identifiers.
-	scope *structLit
+	root *adt.Vertex
 
 	ImportPath  string
 	Dir         string
@@ -49,12 +47,12 @@
 }
 
 func (x *index) addInst(p *Instance) *Instance {
-	x.Index.AddInst(p.ImportPath, p.rootStruct, p)
+	x.Index.AddInst(p.ImportPath, p.root, p)
 	p.index = x
 	return p
 }
 
-func (x *index) getImportFromNode(v value) *Instance {
+func (x *index) getImportFromNode(v *adt.Vertex) *Instance {
 	p := x.Index.GetImportFromNode(v)
 	if p == nil {
 		return nil
@@ -74,25 +72,23 @@
 	internal.MakeInstance = func(value interface{}) interface{} {
 		v := value.(Value)
 		x := v.eval(v.ctx())
-		st, ok := x.(*structLit)
+		st, ok := x.(*adt.Vertex)
 		if !ok {
-			st = &structLit{baseValue: x.base(), emit: x}
+			st = &adt.Vertex{}
+			st.AddConjunct(adt.MakeConjunct(nil, x))
 		}
 		return v.ctx().index.addInst(&Instance{
-			rootStruct: st,
-			rootValue:  v.v.v,
+			root: st,
 		})
 	}
 }
 
 // newInstance creates a new instance. Use Insert to populate the instance.
-func newInstance(x *index, p *build.Instance) *Instance {
+func newInstance(x *index, p *build.Instance, v *adt.Vertex) *Instance {
 	// TODO: associate root source with structLit.
-	st := &structLit{baseValue: baseValue{nil}}
 	i := &Instance{
-		rootStruct: st,
-		rootValue:  st,
-		inst:       p,
+		root: v,
+		inst: p,
 	}
 	if p != nil {
 		i.ImportPath = p.ImportPath
@@ -118,28 +114,7 @@
 
 func (inst *Instance) eval(ctx *context) evaluated {
 	// TODO: remove manifest here?
-	v := ctx.manifest(inst.rootValue)
-	if s, ok := v.(*structLit); ok && s.emit != nil {
-		e := s.emit.evalPartial(ctx)
-		src := binSrc(token.NoPos, opUnify, v, e)
-	outer:
-		switch e.(type) {
-		case *structLit, *top:
-			v = binOp(ctx, src, opUnifyUnchecked, v, e)
-			if s, ok := v.(*structLit); ok {
-				s.emit = nil
-			}
-
-		default:
-			for _, a := range s.Arcs {
-				if !a.definition {
-					v = binOp(ctx, src, opUnify, v, e)
-					break outer
-				}
-			}
-			return e
-		}
-	}
+	v := ctx.manifest(inst.root)
 	return v
 }
 
@@ -148,20 +123,63 @@
 		v := value.(Value)
 		e := expr.(ast.Expr)
 		ctx := v.idx.newContext()
-		return newValueRoot(ctx, evalExpr(ctx, v.eval(ctx), e))
+		return newValueRoot(ctx, evalExpr(ctx, v.vertex(ctx), e))
 	}
 }
 
-func evalExpr(ctx *context, x value, expr ast.Expr) evaluated {
-	if isBottom(x) {
-		return ctx.mkErr(x, "error evaluating instance: %v", x)
+// evalExpr evaluates expr within scope.
+func evalExpr(ctx *context, scope *adt.Vertex, expr ast.Expr) evaluated {
+	cfg := &compile.Config{
+		Scope: scope,
+		Imports: func(x *ast.Ident) (pkgPath string) {
+			if _, ok := builtins[x.Name]; !ok {
+				return ""
+			}
+			return x.Name
+		},
 	}
-	obj, ok := x.(*structLit)
-	if !ok {
-		return ctx.mkErr(x, "instance is not a struct, found %s", x.Kind())
+
+	c, err := compile.Expr(cfg, ctx.opCtx, expr)
+	if err != nil {
+		return &adt.Bottom{Err: err}
 	}
-	v := newVisitor(ctx.index, nil, nil, obj, true)
-	return v.walk(expr).evalPartial(ctx)
+	return adt.Resolve(ctx.opCtx, c)
+
+	// scope.Finalize(ctx.opCtx) // TODO: not appropriate here.
+	// switch s := scope.Value.(type) {
+	// case *bottom:
+	// 	return s
+	// case *adt.StructMarker:
+	// default:
+	// 	return ctx.mkErr(scope, "instance is not a struct, found %s", scope.Kind())
+	// }
+
+	// c := ctx.opCtx
+
+	// x, err := compile.Expr(&compile.Config{Scope: scope}, c.Runtime, expr)
+	// if err != nil {
+	// 	return c.NewErrf("could not evaluate %s: %v", c.Str(x), err)
+	// }
+
+	// env := &adt.Environment{Vertex: scope}
+
+	// switch v := x.(type) {
+	// case adt.Value:
+	// 	return v
+	// case adt.Resolver:
+	// 	r, err := c.Resolve(env, v)
+	// 	if err != nil {
+	// 		return err
+	// 	}
+	// 	return r
+
+	// case adt.Evaluator:
+	// 	e, _ := c.Evaluate(env, x)
+	// 	return e
+
+	// }
+
+	// return c.NewErrf("could not evaluate %s", c.Str(x))
 }
 
 // Doc returns the package comments for this instance.
@@ -183,7 +201,8 @@
 // top-level values.
 func (inst *Instance) Value() Value {
 	ctx := inst.newContext()
-	return newValueRoot(ctx, inst.eval(ctx))
+	inst.root.Finalize(ctx.opCtx)
+	return newVertexRoot(ctx, inst.root)
 }
 
 // Eval evaluates an expression within an existing instance.
@@ -191,7 +210,9 @@
 // Expressions may refer to builtin packages if they can be uniquely identified.
 func (inst *Instance) Eval(expr ast.Expr) Value {
 	ctx := inst.newContext()
-	result := evalExpr(ctx, inst.eval(ctx), expr)
+	v := inst.root
+	v.Finalize(ctx.opCtx)
+	result := evalExpr(ctx, v, expr)
 	return newValueRoot(ctx, result)
 }
 
@@ -201,33 +222,22 @@
 // that these will only surface during manifestation. This allows
 // non-conflicting parts to be used.
 func Merge(inst ...*Instance) *Instance {
-	switch len(inst) {
-	case 0:
-		return nil
-	case 1:
-		return inst[0]
-	}
+	v := &adt.Vertex{}
 
-	values := []value{}
+	i := inst[0]
+	ctx := i.index.newContext().opCtx
+
+	// TODO: interesting test: use actual unification and then on K8s corpus.
+
 	for _, i := range inst {
-		if i.Err != nil {
-			return i
-		}
-		values = append(values, i.rootValue)
+		w := i.Value()
+		v.AddConjunct(adt.MakeConjunct(nil, w.v.ToDataAll()))
 	}
-	merged := &mergedValues{values: values}
+	v.Finalize(ctx)
 
-	ctx := inst[0].newContext()
-
-	st, ok := ctx.manifest(merged).(*structLit)
-	if !ok {
-		return nil
-	}
-
-	p := ctx.index.addInst(&Instance{
-		rootStruct: st,
-		rootValue:  merged,
-		complete:   true,
+	p := i.index.addInst(&Instance{
+		root:     v,
+		complete: true,
 	})
 	return p
 }
@@ -239,37 +249,33 @@
 	p.Complete()
 
 	idx := inst.index
+	r := inst.index.Runtime
 
-	i := newInstance(idx, p)
+	rErr := runtime.ResolveFiles(idx.Index, p, isBuiltin)
+
+	v, err := compile.Files(&compile.Config{Scope: inst.root}, r, p.Files...)
+
+	v.AddConjunct(adt.MakeConjunct(nil, inst.root))
+
+	i := newInstance(idx, p, v)
+	if rErr != nil {
+		i.setListOrError(err)
+	}
 	if i.Err != nil {
-		return i
+		i.setListOrError(err)
 	}
 
-	ctx := inst.newContext()
-	val := newValueRoot(ctx, inst.rootValue)
-	v, err := val.structValFull(ctx)
 	if err != nil {
-		i.setError(val.toErr(err))
-		return i
+		i.setListOrError(err)
 	}
-	i.scope = v.obj
 
-	if err := runtime.ResolveFiles(idx.Index, p, isBuiltin); err != nil {
-		i.setError(err)
-		return i
-	}
-	for _, f := range p.Files {
-		if err := i.insertFile(f); err != nil {
-			i.setListOrError(err)
-		}
-	}
 	i.complete = true
 
 	return i
 }
 
 func (inst *Instance) value() Value {
-	return newValueRoot(inst.newContext(), inst.rootValue)
+	return newVertexRoot(inst.newContext(), inst.root)
 }
 
 // Lookup reports the value at a path starting from the top level struct. The
@@ -322,44 +328,36 @@
 // a Value. In the latter case, it will panic if the Value is not from the same
 // Runtime.
 func (inst *Instance) Fill(x interface{}, path ...string) (*Instance, error) {
-	ctx := inst.newContext()
-	root := ctx.manifest(inst.rootValue)
 	for i := len(path) - 1; i >= 0; i-- {
 		x = map[string]interface{}{path[i]: x}
 	}
-	value := convertVal(ctx, root, true, x)
-	eval := binOp(ctx, baseValue{}, opUnify, root, value)
-	// TODO: validate recursively?
-	err := inst.Err
-	var st *structLit
-	var stVal evaluated
-	switch x := eval.(type) {
-	case *structLit:
-		st = x
-		stVal = x
-	default:
-		// This should not happen.
-		b := ctx.mkErr(eval, "error filling struct")
-		err = inst.Value().toErr(b)
-		st = &structLit{emit: b}
-		stVal = b
-	case *bottom:
-		err = inst.Value().toErr(x)
-		st = &structLit{emit: x}
-		stVal = x
+	a := make([]adt.Conjunct, len(inst.root.Conjuncts))
+	copy(a, inst.root.Conjuncts)
+	u := &adt.Vertex{Conjuncts: a}
+
+	if v, ok := x.(Value); ok {
+		if inst.index != v.idx {
+			panic("value of type Value is not created with same Runtime as Instance")
+		}
+		for _, c := range v.v.Conjuncts {
+			u.AddConjunct(c)
+		}
+	} else {
+		ctx := eval.NewContext(inst.index.Runtime, nil)
+		expr := convert.GoValueToExpr(ctx, true, x)
+		u.AddConjunct(adt.MakeConjunct(nil, expr))
+		u.Finalize(ctx)
 	}
 	inst = inst.index.addInst(&Instance{
-		rootStruct: st,
-		rootValue:  stVal,
-		inst:       nil,
+		root: u,
+		inst: nil,
 
 		// Omit ImportPath to indicate this is not an importable package.
 		Dir:        inst.Dir,
 		PkgName:    inst.PkgName,
 		Incomplete: inst.Incomplete,
-		Err:        err,
 
-		complete: err != nil,
+		complete: true,
 	})
-	return inst, err
+	return inst, nil
 }
diff --git a/internal/legacy/cue/marshal.go b/internal/legacy/cue/marshal.go
index fd3cbe1..c48d136 100644
--- a/internal/legacy/cue/marshal.go
+++ b/internal/legacy/cue/marshal.go
@@ -28,6 +28,7 @@
 	"cuelang.org/go/cue/format"
 	"cuelang.org/go/cue/token"
 	"cuelang.org/go/internal"
+	"cuelang.org/go/internal/core/export"
 )
 
 // root.
@@ -141,7 +142,7 @@
 			return p
 		}
 		// TODO: support exporting instance
-		file, _ := exportFile(ctx, nil, i.rootValue, options{raw: true})
+		file, _ := export.Def(r.idx.Runtime, i.root)
 		imports := []string{}
 		for _, i := range internal.Imports(file) {
 			for _, spec := range i.(*ast.ImportDecl).Specs {
@@ -151,8 +152,15 @@
 		}
 
 		if i.PkgName != "" {
-			pkg := &ast.Package{Name: ast.NewIdent(i.PkgName)}
-			file.Decls = append([]ast.Decl{pkg}, file.Decls...)
+			p, name, _ := internal.PackageInfo(file)
+			if p == nil {
+				pkg := &ast.Package{Name: ast.NewIdent(i.PkgName)}
+				file.Decls = append([]ast.Decl{pkg}, file.Decls...)
+			} else if name != i.PkgName {
+				// p is guaranteed to be generated by Def, so it is "safe" to
+				// modify.
+				p.Name = ast.NewIdent(i.PkgName)
+			}
 		}
 
 		b, err := format.Node(file)
diff --git a/internal/legacy/cue/marshal_test.go b/internal/legacy/cue/marshal_test.go
index b380b1a..64775aa 100644
--- a/internal/legacy/cue/marshal_test.go
+++ b/internal/legacy/cue/marshal_test.go
@@ -100,7 +100,7 @@
 	insts := func(i ...*instanceData) []*instanceData { return i }
 	pkg1 := &instanceData{
 		true,
-		"pkg1",
+		"example.com/foo/pkg1",
 		files(`
 		package pkg1
 
@@ -137,7 +137,7 @@
 			files(
 				`package test
 
-			import "pkg1"
+			import "example.com/foo/pkg1"
 
 			"Hello \(pkg1.Object)!"`),
 		}),
@@ -147,7 +147,7 @@
 			files(
 				`package test
 
-		import pkg2 "pkg1"
+		import pkg2 "example.com/foo/pkg1"
 		pkg1: pkg2.Object
 
 		"Hello \(pkg1)!"`),
diff --git a/internal/legacy/cue/resolve_test.go b/internal/legacy/cue/resolve_test.go
index e7480da..b9ad808 100644
--- a/internal/legacy/cue/resolve_test.go
+++ b/internal/legacy/cue/resolve_test.go
@@ -15,3031 +15,12 @@
 package cue
 
 import (
-	"flag"
 	"strings"
 	"testing"
+
+	"cuelang.org/go/internal/core/adt"
 )
 
-var traceOn = flag.Bool("debug", false, "enable tracing")
-
-func compileFileWithErrors(t *testing.T, body string) (*context, *structLit, error) {
-	t.Helper()
-	ctx, inst, err := compileInstance(t, body)
-	return ctx, inst.rootValue.evalPartial(ctx).(*structLit), err
-}
-
-func compileFile(t *testing.T, body string) (*context, *structLit) {
-	t.Helper()
-	ctx, inst, errs := compileInstance(t, body)
-	if errs != nil {
-		t.Fatal(errs)
-	}
-	return ctx, inst.rootValue.evalPartial(ctx).(*structLit)
-}
-
-func compileInstance(t *testing.T, body string) (*context, *Instance, error) {
-	var r Runtime
-	inst, err := r.Compile("test", body)
-
-	if err != nil {
-		x := newInstance(newIndex(sharedIndex), nil)
-		ctx := x.newContext()
-		return ctx, x, err
-	}
-
-	return r.index().newContext(), inst, nil
-}
-
-func rewriteHelper(t *testing.T, cases []testCase, r rewriteMode) {
-	for _, tc := range cases {
-		t.Run(tc.desc, func(t *testing.T) {
-			ctx, obj := compileFile(t, tc.in)
-			ctx.trace = *traceOn
-			root := testResolve(ctx, obj, r)
-
-			got := debugStr(ctx, root)
-
-			// Copy the result
-			if got != tc.out {
-				fn := t.Errorf
-				if tc.skip {
-					fn = t.Skipf
-				}
-				fn("output differs:\ngot  %s\nwant %s", got, tc.out)
-			}
-		})
-	}
-}
-
-type testCase struct {
-	desc string
-	in   string
-	out  string
-	skip bool
-}
-
-func TestBasicRewrite(t *testing.T) {
-	testCases := []testCase{{
-		desc: "errors",
-		in: `
-			a: _|_ & _|_
-			b: null & _|_
-			c: b.a == _|_
-			d: _|_ != b.a
-			e: _|_ == _|_
-			`,
-		out: `<0>{a: _|_(from source), b: _|_(from source), c: true, d: false, e: true}`,
-	}, {
-		desc: "regexp",
-		in: `
-			c1: "a" =~ "a"
-			c2: "foo" =~ "[a-z]{3}"
-			c3: "foo" =~ "[a-z]{4}"
-			c4: "foo" !~ "[a-z]{4}"
-
-			b1: =~ "a"
-			b1: "a"
-			b2: =~ "[a-z]{3}"
-			b2: "foo"
-			b3: =~ "[a-z]{4}"
-			b3: "foo"
-			b4: !~ "[a-z]{4}"
-			b4: "foo"
-
-			s1: != "b" & =~"c"      // =~"c"
-			s2: != "b" & =~"[a-z]"  // != "b" & =~"[a-z]"
-
-			e1: "foo" =~ 1
-			e2: "foo" !~ true
-			e3: != "a" & <5
-		`,
-		out: `<0>{c1: true, ` +
-			`c2: true, ` +
-			`c3: false, ` +
-			`c4: true, ` +
-
-			`b1: "a", ` +
-			`b2: "foo", ` +
-			`b3: _|_((=~"[a-z]{4}" & "foo"):invalid value "foo" (does not match =~"[a-z]{4}")), ` +
-			`b4: "foo", ` +
-
-			`s1: =~"c", ` +
-			`s2: (!="b" & =~"[a-z]"), ` +
-
-			`e1: _|_(("foo" =~ 1):invalid operation "foo" =~ 1 (mismatched types string and int)), ` +
-			`e2: _|_(("foo" !~ true):invalid operation "foo" !~ true (mismatched types string and bool)), ` +
-			`e3: _|_((!="a" & <5):conflicting values !="a" and <5 (mismatched types string and number))}`,
-	}, {
-		desc: "arithmetic",
-		in: `
-			i1: 1 & int
-			i2: 2 & int
-
-			sum: -1 + +2        // 1
-			div1: 2.0 / 3 * 6   // 4
-			div2: 2 / 3 * 6     // 4
-			div3: 1.00 / 1.00
-			divZero: 1.0 / 0
-			div00: 0 / 0
-			b: 1 != 4
-			add: div1 + 1.0
-
-			idiv00: 0 div 0
-			imod00: 0 mod 0
-			iquo00: 0 quo 0
-			irem00: 0 rem 0
-
-			v1: 1.0T/2.0
-			v2: 2.0 == 2
-			v3: 2.0/3.0
-			v5: i1 div i2
-
-			e0: 2 + "a"
-			// these are now all alloweed
-			// e1: 2.0 / i1
-			// e2: i1 / 2.0
-			// e3: 3.0 % i2
-			// e4: i1 % 2.0
-			e5: 1.0 div 2
-			e6: 2 rem 2.0
-			e7: 2 quo 2.0
-			e8: 1.0 mod 1
-			`,
-		out: `<0>{i1: 1, i2: 2, ` +
-			`sum: 1, ` +
-			`div1: 4.00000000000000000000000, ` +
-			`div2: 4.00000000000000000000000, ` +
-			`div3: 1., ` +
-			`divZero: _|_((1.0 / 0):division by zero), ` +
-			`div00: _|_((0 / 0):division undefined), ` +
-			`b: true, ` +
-			`add: 5.00000000000000000000000, ` +
-			`idiv00: _|_((0 div 0):division by zero), ` +
-			`imod00: _|_((0 mod 0):division by zero), ` +
-			`iquo00: _|_((0 quo 0):division by zero), ` +
-			`irem00: _|_((0 rem 0):division by zero), ` +
-			`v1: 5.0000000000e+11, ` +
-			`v2: true, ` +
-			`v3: 0.666666666666666666666667, ` +
-			`v5: 0, ` +
-
-			`e0: _|_((2 + "a"):invalid operation 2 + "a" (mismatched types int and string)), ` +
-			// `e1: _|_((2.0 / 1):unsupported op /(float, int)), ` +
-			// `e2: _|_((1 / 2.0):unsupported op /(int, float)), ` +
-			// `e3: _|_((3.0 % 2):unsupported op %(float, int)), ` +
-			// `e4: _|_((1 % 2.0):unsupported op %(int, float)), ` +
-			`e5: _|_((1.0 div 2):invalid operation 1.0 div 2 (mismatched types float and int)), ` +
-			`e6: _|_((2 rem 2.0):invalid operation 2 rem 2.0 (mismatched types int and float)), ` +
-			`e7: _|_((2 quo 2.0):invalid operation 2 quo 2.0 (mismatched types int and float)), ` +
-			`e8: _|_((1.0 mod 1):invalid operation 1.0 mod 1 (mismatched types float and int))}`,
-	}, {
-		desc: "integer-specific arithmetic",
-		in: `
-			q1: 5 quo 2    // 2
-			q2: 5 quo -2   // -2
-			q3: -5 quo 2   // -2
-			q4: -5 quo -2  // 2
-			qe1: 2.0 quo 1
-			qe2: 2 quo 1.0
-
-			r1: 5 rem 2    // 1
-			r2: 5 rem -2   // 1
-			r3: -5 rem 2   // -1
-			r4: -5 rem -2  // -1
-			re1: 2.0 rem 1
-			re2: 2 rem 1.0
-
-			d1: 5 div 2    // 2
-			d2: 5 div -2   // -2
-			d3: -5 div 2   // -3
-			d4: -5 div -2  // 3
-			de1: 2.0 div 1
-			de2: 2 div 1.0
-
-			m1: 5 mod 2    // 1
-			m2: 5 mod -2   // 1
-			m3: -5 mod 2   // 1
-			m4: -5 mod -2  // 1
-			me1: 2.0 mod 1
-			me2: 2 mod 1.0
-			`,
-		out: `<0>{q1: 2, q2: -2, q3: -2, q4: 2, ` +
-			`qe1: _|_((2.0 quo 1):invalid operation 2.0 quo 1 (mismatched types float and int)), ` +
-			`qe2: _|_((2 quo 1.0):invalid operation 2 quo 1.0 (mismatched types int and float)), ` +
-			`r1: 1, r2: 1, r3: -1, r4: -1, ` +
-			`re1: _|_((2.0 rem 1):invalid operation 2.0 rem 1 (mismatched types float and int)), ` +
-			`re2: _|_((2 rem 1.0):invalid operation 2 rem 1.0 (mismatched types int and float)), ` +
-			`d1: 2, d2: -2, d3: -3, d4: 3, ` +
-			`de1: _|_((2.0 div 1):invalid operation 2.0 div 1 (mismatched types float and int)), ` +
-			`de2: _|_((2 div 1.0):invalid operation 2 div 1.0 (mismatched types int and float)), ` +
-			`m1: 1, m2: 1, m3: 1, m4: 1, ` +
-			`me1: _|_((2.0 mod 1):invalid operation 2.0 mod 1 (mismatched types float and int)), ` +
-			`me2: _|_((2 mod 1.0):invalid operation 2 mod 1.0 (mismatched types int and float))}`,
-	}, {
-		desc: "booleans",
-		in: `
-			t: true
-			t: !false
-			f: false
-			f: !t
-			e: true
-			e: !true
-			`,
-		out: "<0>{t: true, f: false, e: _|_(true:conflicting values true and false)}",
-	}, {
-		desc: "boolean arithmetic",
-		in: `
-			a: true && true
-			b: true || false
-			c: false == true
-			d: false != true
-			e: true & true
-			f: true & false
-			`,
-		out: "<0>{a: true, b: true, c: false, d: true, e: true, f: _|_(true:conflicting values true and false)}",
-	}, {
-		desc: "basic type",
-		in: `
-			a: 1 & int
-			b: number & 1
-			c: 1.0
-			c: float
-			d: int & float // _|_
-			e: "4" & string
-			f: true
-			f: bool
-			`,
-		out: `<0>{a: 1, b: 1, c: 1.0, d: _|_((int & float):conflicting values int and float (mismatched types int and float)), e: "4", f: true}`, // TODO: eliminate redundancy
-	}, {
-		desc: "strings and bytes",
-		in: `
-			s0: "foo" + "bar"
-			s1: 3 * "abc"
-			s2: "abc" * 2
-
-			b0: 'foo' + 'bar'
-			b1: 3 * 'abc'
-			b2: 'abc' * 2
-
-			// TODO: consider the semantics of this and perhaps allow this.
-			e0: "a" + ''
-			e1: 'b' + "c"
-		`,
-		out: `<0>{` +
-			`s0: "foobar", ` +
-			`s1: "abcabcabc", ` +
-			`s2: "abcabc", ` +
-			`b0: 'foobar', ` +
-			`b1: 'abcabcabc', ` +
-			`b2: 'abcabc', ` +
-
-			`e0: _|_(("a" + ''):invalid operation "a" + '' (mismatched types string and bytes)), ` +
-			`e1: _|_(('b' + "c"):invalid operation 'b' + "c" (mismatched types bytes and string))` +
-			`}`,
-	}, {
-		desc: "escaping",
-
-		in: `
-			a: "foo\nbar",
-			b: a,
-
-			// TODO: mimic http://exploringjs.com/es6/ch_template-literals.html#sec_introduction-template-literals
-		`,
-		out: `<0>{a: "foo\nbar", b: "foo\nbar"}`,
-		// out: `<0>{a: "foo\nbar", b: <0>.a}`,
-	}, {
-		desc: "reference",
-		in: `
-			a: b
-			b: 2
-			d: {
-				d: 3
-				e: d
-			}
-			e: {
-				e: {
-					v: 1
-				}
-				f: {
-					v: e.v
-				}
-			}
-			`,
-		out: "<0>{a: 2, b: 2, d: <1>{d: 3, e: 3}, e: <2>{e: <3>{v: 1}, f: <4>{v: 1}}}",
-	}, {
-		desc: "lists",
-		in: `
-			list: [1,2,3]
-			index: [1,2,3][1]
-			unify: [1,2,3] & [_,2,3]
-			e: [] & 4
-			e2: [3]["d"]
-			e3: [3][-1]
-			e4: [1, 2, ...>=4 & <=5] & [1, 2, 4, 8]
-			e5: [1, 2, 4, 8] & [1, 2, ...>=4 & <=5]
-			`,
-		out: `<0>{list: [1,2,3], index: 2, unify: [1,2,3], e: _|_(([] & 4):conflicting values [] and 4 (mismatched types list and int)), e2: _|_("d":invalid list index "d" (type string)), e3: _|_(-1:invalid list index -1 (index must be non-negative)), e4: [1,2,4,_|_((<=5 & 8):invalid value 8 (out of bound <=5))], e5: [1,2,4,_|_((<=5 & 8):invalid value 8 (out of bound <=5))]}`,
-	}, {
-		desc: "list arithmetic",
-		in: `
-			list: [1,2,3]
-			mul0: list*0
-			mul1: list*1
-			mul2: 2*list
-			list1: [1]
-		    mul1_0: list1*0
-			mul1_1: 1*list1
-			mul1_2: list1*2
-			e: list*-1
-			`,
-		out: `<0>{list: [1,2,3], ` +
-			`mul0: [], ` +
-			`mul1: [1,2,3], ` +
-			`mul2: [1,2,3,1,2,3], ` +
-			`list1: [1], ` +
-			`mul1_0: [], ` +
-			`mul1_1: [1], ` +
-			`mul1_2: [1,1], ` +
-			`e: _|_((<1>.list * -1):negative number -1 multiplies list)}`,
-	}, {
-		desc: "selecting",
-		in: `
-			obj: {a: 1, b: 2}
-			index: {a: 1, b: 2}["b"]
-			mulidx: {a: 1, b: {a:1, b: 3}}["b"]["b"]
-			e: {a: 1}[4]
-			f: {a: 1}.b
-			g: {a: 1}["b"]
-			h: [3].b
-			`,
-		out: `<0>{obj: <1>{a: 1, b: 2}, index: 2, mulidx: 3, e: _|_(4:invalid struct index 4 (type int)), f: <2>{a: 1}.b, g: <3>{a: 1}["b"], h: _|_([3]:invalid operation: [3].b (type list does not support selection))}`,
-	}, {
-		desc: "obj unify",
-		in: `
-			o1: {a: 1 } & { b: 2}      // {a:1,b:2}
-			o2: {a: 1, b:2 } & { b: 2} // {a:1,b:2}
-			o3: {a: 1 } & { a:1, b: 2} // {a:1,b:2}
-			o4: {a: 1 } & { b: 2}      // {a:1,b:2}
-			o4: {a: 1, b:2 } & { b: 2}
-			o4: {a: 1 } & { a:1, b: 2}
-			e: 1                       // 1 & {a:3}
-			e: {a:3}
-			`,
-		out: "<0>{o1: <1>{a: 1, b: 2}, o2: <2>{a: 1, b: 2}, o3: <3>{a: 1, b: 2}, o4: <4>{a: 1, b: 2}, e: _|_((1 & <5>{a: 3}):conflicting values 1 and {a: 3} (mismatched types int and struct))}",
-	}, {
-		desc: "disjunctions",
-		in: `
-			o1: 1 | 2 | 3
-			o2: (1 | 2 | 3) & 1
-			o3: 2 & (1 | *2 | 3)
-			o4: (1 | *2 | 3) & (1 | 2 | *3)
-			o5: (1 | *2 | 3) & (3 | *2 | 1)
-			o6: (1 | 2 | 3) & (3 | 1 | 2)
-			o7: (1 | 2 | 3) & (2 | 3)
-			o8: (1 | 2 | 3) & (3 | 2)
-			o9: (2 | 3) & (1 | 2 | 3)
-			o10: (3 | 2) & (1 | *2 | 3)
-
-			m1: (*1 | (*2 | 3)) & (>=2 & <=3)
-			m2: (*1 | (*2 | 3)) & (2 | 3)
-			m3: (*1 | *(*2 | 3)) & (2 | 3)
-			m4: (2 | 3) & (*2 | 3)
-			m5: (*2 | 3) & (2 | 3)
-
-			// (*2 | 3) & (2 | 3)
-			// (2 | 3) & (*2 | 3)
-			// 2&(*2 | 3) | 3&(*2 | 3)
-			// (*1 | (*2 | 3)) & (2 | 3)
-			// *1& (2 | 3) | (*2 | 3)&(2 | 3)
-			// *2&(2 | 3) | 3&(2 | 3)
-
-			// (2 | 3)&(*1 | (*2 | 3))
-			// 2&(*1 | (*2 | 3)) | 3&(*1 | (*2 | 3))
-			// *1&2 | (*2 | 3)&2 | *1&3 | (*2 | 3)&3
-			// (*2 | 3)&2 | (*2 | 3)&3
-			// *2 | 3
-
-
-			// All errors are treated the same as per the unification model.
-			i1: [1, 2][3] | "c"
-			`,
-		out: `<0>{o1: (1 | 2 | 3), o2: 1, o3: 2, o4: (1 | 2 | 3 | *_|_), o5: (1 | *2 | 3), o6: (1 | 2 | 3), o7: (2 | 3), o8: (2 | 3), o9: (2 | 3), o10: (3 | *2), m1: (*2 | 3), m2: (*2 | 3), m3: (*2 | 3), m4: (*2 | 3), m5: (*2 | 3), i1: "c"}`,
-	}, {
-		desc: "types",
-		in: `
-			i: int
-			j: int & 3
-			s: string
-			t: "s" & string
-			e: int & string
-			e2: 1 & string
-			b: !int
-			p: +true
-			m: -false
-		`,
-		out: `<0>{i: int, j: 3, s: string, t: "s", e: _|_((int & string):conflicting values int and string (mismatched types int and string)), e2: _|_((1 & string):conflicting values 1 and string (mismatched types int and string)), b: _|_(!int:invalid operation !int (! int)), p: _|_(+true:invalid operation +true (+ bool)), m: _|_(-false:invalid operation -false (- bool))}`,
-	}, {
-		desc: "comparison",
-		in: `
-			lss: 1 < 2
-			leq: 1 <= 1.0
-			leq: 2.0 <= 3
-			eql: 1 == 1.0
-			neq: 1.0 == 1
-			gtr: !(2 > 3)
-			geq: 2.0 >= 2
-			seq: "a" + "b" == "ab"
-			err: 2 == "s"
-		`,
-		out: `<0>{lss: true, leq: true, eql: true, neq: true, gtr: true, geq: true, seq: true, err: _|_((2 == "s"):invalid operation 2 == "s" (mismatched types int and string))}`,
-	}, {
-		desc: "null",
-		in: `
-			eql: null == null
-			neq: null != null
-			unf: null & null
-
-			// errors
-			eq1: null == 1
-			eq2: 1 == null
-			ne1: "s" != null
-			call: null()
-		`,
-		out: `<0>{eql: true, neq: false, unf: null, eq1: false, eq2: false, ne1: true, call: _|_(null:cannot call non-function null (type null))}`,
-	}, {
-		desc: "self-reference cycles",
-		in: `
-			a: b - 100
-			b: a + 100
-
-			c: [c[1], c[0]]
-		`,
-		out: `<0>{a: (<1>.b - 100), ` +
-			`b: (<1>.a + 100), ` +
-			`c: [<1>.c[1],<1>.c[0]]}`,
-	}, {
-		desc: "resolved self-reference cycles",
-		in: `
-			a: b - 100
-			b: a + 100
-			b: 200
-
-			c: [c[1], a]
-
-			s1: s2 & {a: 1}
-			s2: s3 & {b: 2}
-			s3: s1 & {c: 3}
-		`,
-		out: `<0>{a: 100, b: 200, c: [100,100], s1: <1>{a: 1, b: 2, c: 3}, s2: <2>{a: 1, b: 2, c: 3}, s3: <3>{a: 1, b: 2, c: 3}}`,
-	}, {
-		desc: "resolved self-reference cycles: Issue 19",
-		in: `
-			// CUE knows how to resolve the following:
-			x: y + 100
-			y: x - 100
-			x: 200
-
-			z1: z2 + 1
-			z2: z3 + 2
-			z3: z1 - 3
-			z3: 8
-
-			// TODO: extensive tests with disjunctions.
-		`,
-		out: `<0>{x: 200, y: 100, z1: 11, z2: 10, z3: 8}`,
-	}, {
-		desc: "delayed constraint failure",
-		in: `
-			a: b - 100
-			b: a + 110
-			b: 200
-
-			x: 100
-			x: x + 1
-		`,
-		out: `<0>{` +
-			`x: _|_((100 & 101):conflicting values 100 and 101), ` +
-			`a: _|_((210 & 200):conflicting values 210 and 200), ` +
-			`b: _|_((210 & 200):conflicting values 210 and 200)}`,
-		// TODO: find a way to mark error in data.
-	}}
-	rewriteHelper(t, testCases, evalPartial)
-}
-
-func TestChooseDefault(t *testing.T) {
-	testCases := []testCase{{
-		desc: "pick first",
-		in: `
-		a: *5 | "a" | true
-		b: c: *{
-			a: 2
-		} | {
-			a : 3
-		}
-		`,
-		out: "<0>{a: 5, b: <1>{c: <2>{a: 2}}}",
-	}, {
-		// In this test, default results to bottom, meaning that the non-default
-		// value remains.
-		desc: "simple disambiguation conflict",
-		in: `
-			a: *"a" | "b"
-			b: *"b" | "a"
-			c: a & b
-			`,
-		out: `<0>{a: "a", b: "b", c: ("a" | "b")}`,
-	}, {
-		desc: "associativity of defaults",
-		in: `
-			a: *"a" | ("b" | "c")
-			b: (*"a" | "b") | "c"
-			c: *"a" | (*"b" | "c")
-			x: a & b
-			y: b & c
-			`,
-		out: `<0>{x: "a", y: (*"a" | *"b"), a: "a", b: "a", c: (*"a" | *"b")}`,
-	}}
-	rewriteHelper(t, testCases, evalFull)
-}
-
-func TestResolve(t *testing.T) {
-	testCases := []testCase{{
-		desc: "convert _ to top",
-		in:   `a: { [_]: _ }`,
-		out:  `<0>{a: <1>{...}}`,
-	}, {
-		in: `
-			a: b.c.d
-			b: c: { d: 3 }
-			c: { c: d.d, }
-			d: { d: 2 }
-			`,
-		out: "<0>{a: 3, b: <1>{c: <2>{d: 3}}, c: <3>{c: 2}, d: <4>{d: 2}}",
-	}, {
-		in:  "`foo-bar`: 3\n x: `foo-bar`,",
-		out: `<0>{x: 3, "foo-bar": 3}`,
-	}, {
-		desc: "resolution of quoted identifiers",
-		in: `
-		package foo
-
-` + "`foo-bar`" + `: 2
-"baz":     ` + "`foo-bar`" + `
-
-a: {
-	qux:        3
-	` + "`qux-quux`" + `: qux
-	"qaz":      ` + "`qux-quux`" + `
-}`,
-		out: `<0>{"foo-bar": 2, baz: 2, a: <1>{qux: 3, "qux-quux": 3, qaz: 3}}`,
-	}, {
-		in: `
-			a: _
-			b: a
-			a: { d: 1, d: _ }
-			b: _
-			`,
-		out: `<0>{a: <1>{d: 1}, b: <2>{d: 1}}`,
-	}, {
-		desc: "JSON",
-		in: `
-			a="a": 3
-			b: a
-			o: { "a\nb": 2 } // TODO: use $ for root?
-			c: o["a\nb"]
-		`,
-		out: `<0>{a: 3, b: 3, o: <1>{"a\nb": 2}, c: 2}`,
-	}, {
-		desc: "arithmetic",
-		in: `
-				v1: 1.0T/2.0
-				v2: 2.0 == 2
-				n1: 1
-				v5: 2.0 / n1
-				v6: 1.0 / 1.0
-				e2: int & 4.0/2.0
-				`,
-		out: `<0>{v1: 5.0000000000e+11, v2: true, n1: 1, v5: 2.0, v6: 1., e2: _|_((int & (4.0 / 2.0)):conflicting values int and (4.0 / 2.0) (mismatched types int and float))}`,
-	}, {
-		desc: "inequality",
-		in: `
-			a: 1 != 2
-			b: 1 != null
-			c: true == null
-			d: null != {}
-			e: null == []
-			f: 0 == 0.0    // types are unified first TODO: make this consistent
-		`,
-		out: `<0>{a: true, b: true, c: false, d: true, e: false, f: true}`,
-	}, {
-		desc: "attributes",
-		in: `
-			a: { foo: 1 @foo() @baz(1) }
-			b: { foo: 1 @bar() @foo() }
-			c: a & b
-
-			e: a & { foo: 1 @foo(other) }
-		`,
-		out: `<0>{a: <1>{foo: 1 @baz(1) @foo()}, ` +
-			`b: <2>{foo: 1 @bar() @foo()}, ` +
-			`c: <3>{foo: 1 @bar() @baz(1) @foo()}, ` +
-			`e: _|_((<4>.a & <5>{foo: 1 @foo(other)}):conflicting attributes for key "foo")}`,
-	}, {
-		desc: "optional field unification",
-		in: `
-			a: { foo?: string }
-			b: { foo: "foo" }
-			c: a & b
-			d: a & { "foo"?: "bar" }
-
-			g1: 1
-			"g\(1)"?: 1
-			"g\(2)"?: 2
-		`,
-		out: `<0>{a: <1>{foo?: string}, ` +
-			`b: <2>{foo: "foo"}, ` +
-			`c: <3>{foo: "foo"}, ` +
-			`d: <4>{foo?: "bar"}, ` +
-			`g1: 1, ` +
-			`g2?: 2}`,
-	}, {
-		desc: "optional field resolves to incomplete",
-		in: `
-		r: {
-			a?: 3
-			b: a
-			c: r["a"]
-		}
-	`,
-		out: `<0>{r: <1>{a?: 3, b: <2>.a, c: <3>.r["a"]}}`,
-		// TODO(#152): should be
-		// out: `<0>{r: <1>{a?: 3, b: <2>.a, c: <2>["a"]}}`,
-	}, {
-		desc: "bounds",
-		in: `
-			i1: >1 & 5
-			i2: (>=0 & <=10) & 5
-			i3: !=null & []
-			i4: !=2 & !=4
-
-
-			s1: >=0 & <=10 & !=1        // no simplification
-			s2: >=0 & <=10 & !=11       // >=0 & <=10
-			s3: >5 & !=5                // >5
-			s4: <10 & !=10              // <10
-			s5: !=2 & !=2
-
-			// TODO: could change inequality
-			s6: !=2 & >=2
-			s7: >=2 & !=2
-
-			s8: !=5 & >5
-
-			s10: >=0 & <=10 & <12 & >1   // >1  & <=10
-			s11: >0 & >=0 & <=12 & <12   // >0  & <12
-
-			s20: >=10 & <=10             // 10
-
-			s22:  >5 & <=6               // no simplification
-			s22a: >5 & (<=6 & int)       // 6
-			s22b: (int & >5) & <=6       // 6
-			s22c: >=5 & (<6 & int)       // 5
-			s22d: (int & >=5) & <6       // 5
-			s22e: (>=5 & <6) & int       // 5
-			s22f: int & (>=5 & <6)       // 5
-
-			s23: >0 & <2                 // no simplification
-			s23a: (>0 & <2) & int        // int & 1
-			s23b: int & (>0 & <2)        // int & 1
-			s23c: (int & >0) & <2        // int & 1
-			s23d: >0 & (int & <2)        // int & 1
-			s23e: >0.0 & <2.0            // no simplification
-
-			s30: >0 & int
-
-			e1: null & !=null
-			e2: !=null & null
-			e3: >1 & 1
-			e4: <0 & 0
-			e5: >1 & <0
-			e6: >11 & <11
-			e7: >=11 & <11
-			e8: >11 & <=11
-			e9: >"a" & <1
-		`,
-		out: `<0>{i1: 5, i2: 5, i3: [], i4: (!=2 & !=4), ` +
-
-			`s1: (>=0 & <=10 & !=1), ` +
-			`s2: (>=0 & <=10), ` +
-			`s3: >5, ` +
-			`s4: <10, ` +
-			`s5: !=2, ` +
-
-			`s6: (!=2 & >=2), ` +
-			`s7: (>=2 & !=2), ` +
-
-			`s8: >5, ` +
-
-			`s10: (<=10 & >1), ` +
-			`s11: (>0 & <12), ` +
-
-			`s20: 10, ` +
-
-			`s22: (>5 & <=6), ` +
-			`s22a: 6, ` +
-			`s22b: 6, ` +
-			`s22c: 5, ` +
-			`s22d: 5, ` +
-			`s22e: 5, ` +
-			`s22f: 5, ` +
-
-			`s23: (>0 & <2), ` +
-			`s23a: 1, ` +
-			`s23b: 1, ` +
-			`s23c: 1, ` +
-			`s23d: 1, ` +
-			`s23e: (>0.0 & <2.0), ` +
-
-			`s30: int & >0, ` +
-
-			`e1: _|_((!=null & null):invalid value null (excluded by !=null)), ` +
-			`e2: _|_((!=null & null):invalid value null (excluded by !=null)), ` +
-			`e3: _|_((>1 & 1):invalid value 1 (out of bound >1)), ` +
-			`e4: _|_((<0 & 0):invalid value 0 (out of bound <0)), ` +
-			`e5: _|_(conflicting bounds >1 and <0), ` +
-			`e6: _|_(conflicting bounds >11 and <11), ` +
-			`e7: _|_(conflicting bounds >=11 and <11), ` +
-			`e8: _|_(conflicting bounds >11 and <=11), ` +
-			`e9: _|_((>"a" & <1):conflicting values >"a" and <1 (mismatched types string and number))}`,
-	}, {
-		desc: "bound conversions",
-		in: `
-		r0: int & >0.1 &  <=1.9
-		r1: int & >0.1 & <1.9
-		r2: int & >=0.1 & <1.9
-		r3: int & >=-1.9 & <=-0.1
-		r4: int & >-1.9 & <=-0.1
-
-		r5: >=1.1 & <=1.1
-		r6: r5 & 1.1
-
-		c1: (1.2 & >1.3) & <2
-		c2: 1.2 & (>1.3 & <2)
-
-		c3: 1.2 & (>=1 & <2)
-		c4: 1.2 & (>=1 & <2 & int)
-		`,
-		out: `<0>{` +
-			`r0: 1, ` +
-			`r1: 1, ` +
-			`r2: 1, ` +
-			`r3: -1, ` +
-			`r4: -1, ` +
-			`r5: 1.1, ` +
-			`r6: 1.1, ` +
-			`c1: _|_((>1.3 & 1.2):invalid value 1.2 (out of bound >1.3)), ` +
-			`c2: _|_((>1.3 & 1.2):invalid value 1.2 (out of bound >1.3)), ` +
-			`c3: 1.2, ` +
-			`c4: _|_((1.2 & ((>=1 & <2) & int)):conflicting values 1.2 and ((>=1 & <2) & int) (mismatched types float and int))}`,
-	}, {
-		desc: "custom validators",
-		in: `
-		import "strings"
-
-		a: strings.ContainsAny("ab")
-		a: "after"
-
-		b: strings.ContainsAny("c")
-		b: "dog"
-
-		c: strings.ContainsAny("d") & strings.ContainsAny("g")
-		c: "dog"
-		`,
-		out: `<0>{` +
-			`a: "after", ` +
-			`b: _|_(strings.ContainsAny ("c"):invalid value "dog" (does not satisfy strings.ContainsAny("c"))), ` +
-			`c: "dog"` +
-			`}`,
-	}, {
-		desc: "null coalescing",
-		in: `
-			a: null
-			b: a.x | "b"
-			c: a["x"] | "c"
-			`,
-		out: `<0>{a: null, b: "b", c: "c"}`,
-	}, {
-		desc: "reference across tuples and back",
-		// Tests that it is okay to partially evaluate structs.
-		in: `
-			a: { c: b.e, d: b.f }
-			b: { e: 3, f: a.c }
-			`,
-		out: "<0>{a: <1>{c: 3, d: 3}, b: <2>{e: 3, f: 3}}",
-	}, {
-		desc: "index",
-		in: `
-			a: [2][0]
-			b: {foo:"bar"}["foo"]
-			c: (*l|{"3":3})["3"]
-			d: (*[]|[1])[0]
-			l: []
-			e1: [2][""]
-			e2: 2[2]
-			e3: [][true]
-			e4: [1,2,3][3]
-			e5: [1,2,3][-1]
-			e6: (*[]|{})[1]
-			def: {
-				a: 1
-				#b: 3
-			}
-			e7: def["b"]
-		`,
-		out: `<0>{a: 2, b: "bar", c: _|_("3":invalid list index "3" (type string)), l: [], d: _|_([]:index 0 out of bounds), e1: _|_("":invalid list index "" (type string)), e2: _|_(2:invalid operation: 2[2] (type int does not support indexing)), e3: _|_(true:invalid list index true (type bool)), e4: _|_([1,2,3]:index 3 out of bounds), e5: _|_(-1:invalid list index -1 (index must be non-negative)), e6: _|_([]:index 1 out of bounds), def: <1>{a: 1, #b: 3}, e7: <2>.def["b"]}`,
-		// }, {
-		// NOTE: string indexing no longer supported.
-		// Keeping it around until this is no longer an experiment.
-		// 	desc: "string index",
-		// 	in: `
-		// 		a0: "abc"[0]
-		// 		a1: "abc"[1]
-		// 		a2: "abc"[2]
-		// 		a3: "abc"[3]
-		// 		a4: "abc"[-1]
-
-		// 		b: "zoëven"[2]
-		// 	`,
-		// 	out: `<0>{a0: "a", a1: "b", a2: "c", a3: _|_("abc":index 3 out of bounds), a4: _|_(-1:invalid string index -1 (index must be non-negative)), b: "ë"}`,
-	}, {
-		desc: "disjunctions of lists",
-		in: `
-			l: [ int, int ] | [ string, string ]
-
-			l1: [ "a", "b" ]
-			l2: l & [ "c", "d" ]
-			`,
-		out: `<0>{l: ([int,int] | [string,string]), l1: ["a","b"], l2: ["c","d"]}`,
-	}, {
-		desc: "slice",
-		in: `
-			a: [2][0:0]
-			b: [0][1:1]
-			e1: [][1:1]
-			e2: [0][-1:0]
-			e3: [0][1:0]
-			e4: [0][1:2]
-			e5: 4[1:2]
-			e6: [2]["":]
-			e7: [2][:"9"]
-
-		`,
-		out: `<0>{a: [], b: [], e1: _|_(1:slice bounds out of range), e2: _|_([0]:negative slice index), e3: _|_([0]:invalid slice index: 1 > 0), e4: _|_(2:slice bounds out of range), e5: _|_(4:cannot slice 4 (type int)), e6: _|_("":invalid slice index "" (type string)), e7: _|_("9":invalid slice index "9" (type string))}`,
-		// }, {
-		// NOTE: string indexing no longer supported.
-		// Keeping it around until this is no longer an experiment.
-		// 	desc: "string slice",
-		// 	in: `
-		// 		a0: ""[0:0]
-		// 		a1: ""[:]
-		// 		a2: ""[0:]
-		// 		a3: ""[:0]
-		// 		b0: "abc"[0:0]
-		// 		b1: "abc"[0:1]
-		// 		b2: "abc"[0:2]
-		// 		b3: "abc"[0:3]
-		// 		b4: "abc"[3:3]
-		// 		b5: "abc"[1:]
-		// 		b6: "abc"[:2]
-
-		// 		// TODO: supported extended graphemes, instead of just runes.
-		// 		u: "Spaß"[3:4]
-		// 	`,
-		// 	out: `<0>{a0: "", a1: "", a2: "", a3: "", b0: "", b1: "a", b2: "ab", b3: "abc", b4: "", b5: "bc", b6: "ab", u: "ß"}`,
-	}, {
-		desc: "list types",
-		in: `
-			l0: 3*[int]
-			l0: [1, 2, 3]
-			l2: [...{ a: int }]
-			l2: [{a: 1}, {a: 2, b: 3}]
-
-			// TODO: work out a decent way to specify length ranges of lists.
-			// l3: <=10*[int]
-			// l3: [1, 2, 3, ...]
-
-			s1: (6*[int])[2:3]
-			s2: [0,2,3][1:2]
-
-			i1: (6*[int])[2]
-			i2: [0,2,3][2]
-
-			t0: [...{a: 8}]
-			t0: [{}]
-			t1: [...]
-			t1: [...int]
-
-			e0: 2*[{}]
-			e0: [{}]
-			e1: [...int]
-			e1: [...float]
-			`,
-		out: `<0>{` +
-			`l0: [1,2,3], ` +
-			`l2: [<1>{a: 1},<2>{a: 2, b: 3}], ` +
-			`s1: [int], ` +
-			`s2: [2], ` +
-			`i1: int, ` +
-			`i2: 3, ` +
-			`t0: [<3>{a: 8}], ` +
-			`t1: [, ...int], ` +
-			`e0: _|_(([<4>{},<4>{}] & [<5>{}]):conflicting list lengths: conflicting values 2 and 1), ` +
-			`e1: [, ..._|_((int & float):conflicting values int and float (mismatched types int and float))]` +
-			`}`,
-	}, {
-		// TODO: consider removing list arithmetic altogether. It is no longer
-		// needed to indicate the allowed capacity of a list and that didn't
-		// work anyway.
-		desc: "list arithmetic",
-		in: `
-			l0: 3*[1, 2, 3]
-			l1: 0*[1, 2, 3]
-			l2: 10*[]
-			l3: <=2*[]
-			l4: <=2*[int]
-			l5: <=2*(int*[int])
-			l6: 3*[...int]
-			l7: 3*[1, ...int]
-			l8: 3*[1, 2, ...int]
-
-			s0: [] + []
-			s1: [1] + []
-			s2: [] + [2]
-			s3: [1] + [2]
-			s4: [1,2] + []
-			s5: [] + [1,2]
-			s6: [1] + [1,2]
-			s7: [1,2] + [1]
-			s8: [1,2] + [1,2]
-			s9: [] + [...]
-			s10: [1] + [...]
-			s11: [] + [2, ...]
-			s12: [1] + [2, ...]
-			s13: [1,2] + [...]
-			s14: [] + [1,2, ...]
-			s15: [1] + [1,2, ...]
-			s16: [1,2] + [1, ...]
-			s17: [1,2] + [1,2, ...]
-
-			s18: [...] + []
-			s19: [1, ...] + []
-			s20: [...] + [2]
-			s21: [1, ...] + [2]
-			s22: [1,2, ...] + []
-			s23: [...] + [1,2]
-			s24: [1, ...] + [1,2]
-			s25: [1,2, ...] + [1]
-			s26: [1,2, ...] + [1,2]
-			s27: [...] + [...]
-			s28: [1, ...] + [...]
-			s29: [...] + [2, ...]
-			s30: [1, ...] + [2, ...]
-			s31: [1,2, ...] + [...]
-			s32: [...] + [1,2, ...]
-			s33: [1, ...] + [1,2, ...]
-			s34: [1,2, ...] + [1, ...]
-			s35: [1,2, ...] + [1,2, ...]
-			`,
-		out: `<0>{l0: [1,2,3,1,2,3,1,2,3], ` +
-			`l1: [], ` +
-			`l2: [], ` +
-			`l3: (<=2 * []), ` +
-			`l4: (<=2 * [int]), ` +
-			`l5: (<=2 * (int * [int])), ` +
-			`l6: [], ` +
-			`l7: [1,1,1], ` +
-			`l8: [1,2,1,2,1,2], ` +
-
-			`s0: [], ` +
-			`s1: [1], ` +
-			`s2: [2], ` +
-			`s3: [1,2], ` +
-			`s4: [1,2], ` +
-			`s5: [1,2], ` +
-			`s6: [1,1,2], ` +
-			`s7: [1,2,1], ` +
-			`s8: [1,2,1,2], ` +
-			`s9: [], ` +
-			`s10: [1], ` +
-			`s11: [2], ` +
-			`s12: [1,2], ` +
-			`s13: [1,2], ` +
-			`s14: [1,2], ` +
-			`s15: [1,1,2], ` +
-			`s16: [1,2,1], ` +
-			`s17: [1,2,1,2], ` +
-
-			`s18: [], ` +
-			`s19: [1], ` +
-			`s20: [2], ` +
-			`s21: [1,2], ` +
-			`s22: [1,2], ` +
-			`s23: [1,2], ` +
-			`s24: [1,1,2], ` +
-			`s25: [1,2,1], ` +
-			`s26: [1,2,1,2], ` +
-			`s27: [], ` +
-			`s28: [1], ` +
-			`s29: [2], ` +
-			`s30: [1,2], ` +
-			`s31: [1,2], ` +
-			`s32: [1,2], ` +
-			`s33: [1,1,2], ` +
-			`s34: [1,2,1], ` +
-			`s35: [1,2,1,2]` +
-
-			`}`,
-	}, {
-		desc: "list equality",
-		in: `
-		eq0: [] == []
-		eq1: [...] == []
-		eq2: [] == [...]
-		eq3: [...] == [...]
-
-		eq4: [1] == [1]
-		eq5: [1, ...] == [1]
-		eq6: [1] == [1, ...]
-		eq7: [1, ...] == [1, ...]
-
-		eq8: [1, 2] == [1, 2]
-		eq9: [1, 2, ...] == [1, 2]
-		eq10: [1, 2] == [1, 2, ...]
-		eq11: [1, 2, ...] == [1, 2, ...]
-
-		ne0: [] != []
-		ne1: [...] != []
-		ne2: [] != [...]
-		ne3: [...] != [...]
-
-		ne4: [1] != [1]
-		ne5: [1, ...] != [1]
-		ne6: [1] != [1, ...]
-		ne7: [1, ...] != [1, ...]
-
-		ne8: [1, 2] != [1, 2]
-		ne9: [1, 2, ...] != [1, 2]
-		ne10: [1, 2] != [1, 2, ...]
-		ne11: [1, 2, ...] != [1, 2, ...]
-
-		feq0: [] == [1]
-		feq1: [...] == [1]
-		feq2: [] == [1, ...]
-		feq3: [...] == [1, ...]
-
-		feq4: [1] == []
-		feq5: [1, ...] == []
-		feq6: [1] == [...]
-		feq7: [1, ...] == [...]
-
-		feq8: [1, 2] == [1]
-		feq9: [1, ...] == [1, 2]
-		feq10: [1, 2] == [1, ...]
-		feq11: [1, ...] == [1, 2, ...]
-
-		fne0: [] != [1]
-		fne1: [...] != [1]
-		fne2: [] != [1, ...]
-		fne3: [1, ...] != [1, ...]
-
-		fne4: [1] != []
-		fne5: [1, ...] != []
-		fne6: [1] != [...]
-		fne7: [1, ...] != [...]
-
-		fne8: [1, 2] != [1]
-		fne9: [1, ...] != [1, 2]
-		fne10: [1, 2] != [1, ...]
-		fne11: [1, ...] != [1, 2, ...]
-		`,
-		out: `<0>{` +
-			`eq0: true, eq1: true, eq2: true, eq3: true, eq4: true, eq5: true, eq6: true, eq7: true, eq8: true, eq9: true, eq10: true, eq11: true, ` +
-			`ne0: true, ne1: true, ne2: true, ne3: true, ne4: false, ne5: false, ne6: false, ne7: false, ne8: false, ne9: false, ne10: false, ne11: false, ` +
-			`feq0: false, feq1: false, feq2: false, feq3: false, feq4: false, feq5: false, feq6: false, feq7: false, feq8: false, feq9: false, feq10: false, feq11: false, ` +
-			`fne0: false, fne1: false, fne2: false, fne3: false, fne4: false, fne5: false, fne6: false, fne7: false, fne8: false, fne9: false, fne10: false, fne11: false}`,
-	}, {
-		desc: "list unification",
-		in: `
-		a: { l: ["foo", v], v: l[1] }
-		b: a & { l: [_, "bar"] }
-		`,
-		out: `<0>{` +
-			`a: <1>{l: ["foo",<2>.v], ` +
-			`v: <2>.l[1]}, ` +
-			`b: <3>{l: ["foo","bar"], v: "bar"}}`,
-	}, {
-		desc: "correct error messages",
-		// Tests that it is okay to partially evaluate structs.
-		in: `
-			a: "a" & 1
-			`,
-		out: `<0>{a: _|_(("a" & 1):conflicting values "a" and 1 (mismatched types string and int))}`,
-	}, {
-		desc: "structs",
-		in: `
-			a: t & { c: 5 }             // {c:5,d:15}
-			b: ti & { c: 7 }            // {c:7,d:21}
-			t: { c: number, d: c * 3 }  // {c:number,d:number*3}
-			ti: t & { c: int }
-			`,
-		out: `<0>{a: <1>{c: 5, d: 15}, t: <2>{c: number, d: (<3>.c * 3)}, b: <4>{c: 7, d: 21}, ti: <5>{c: int, d: (<6>.c * 3)}}`,
-	}, {
-		desc: "definitions",
-		in: `
-			#Foo: {
-				field: int
-				recursive: {
-					field: string
-				}
-			}
-
-			// Allowed
-			#Foo1: { field: int }
-			#Foo1: { field2: string }
-
-			foo: #Foo
-			foo: { feild: 2 }
-
-			foo1: #Foo
-			foo1: {
-				field: 2
-				recursive: {
-					feild: 2 // Not caught as per spec. TODO: change?
-				}
-			}
-
-			#Bar: {
-				field: int
-				{[A=_]:   int}
-			}
-			bar: #Bar
-			bar: { feild: 2 }
-
-			#Mixed: string
-			Mixed: string
-
-			mixedRec: { #Mixed: string }
-			mixedRec: { Mixed: string }
-			`,
-		out: `<0>{` +
-			`#Foo: <1>C{field: int, recursive: <2>C{field: string}}, ` +
-			`#Foo1: <3>C{field: int, field2: string}, ` +
-			`foo: _|_(2:field "feild" not allowed in closed struct), ` +
-			`foo1: <4>C{field: 2, recursive: _|_(2:field "feild" not allowed in closed struct)}, ` +
-			`#Bar: <5>{[]: <6>(A: string)->int, field: int}, ` +
-			`bar: <7>{[]: <8>(A: string)->int, field: int, feild: 2}, ` +
-			`#Mixed: string, ` +
-			`Mixed: string, ` +
-			`mixedRec: <9>{#Mixed: string, Mixed: string}}`,
-	}, {
-		desc: "combined definitions",
-		in: `
-			// Allow combining of structs within a definition
-			#D1: {
-				env: a: "A"
-				env: b: "B"
-				#def: {a: "A"}
-				#def: {b: "B"}
-			}
-
-			d1: #D1 & { env: c: "C" }
-
-			#D2: {
-				a: int
-			}
-			#D2: {
-				b: int
-			}
-
-			#D3: {
-				env: a: "A"
-			}
-			#D3: {
-				env: b: "B"
-			}
-
-			#D4: {
-				env: #DC
-				env: b: int
-			}
-
-			#DC: { a: int }
-					`,
-		out: `<0>{` +
-			`#D1: <1>C{env: <2>C{a: "A", b: "B"}, #def: <3>C{a: "A", b: "B"}}, ` +
-			`d1: <4>C{env: _|_("C":field "c" not allowed in closed struct), #def: <5>C{a: "A", b: "B"}}, ` +
-			`#D2: <6>C{a: int, b: int}, ` +
-			`#D3: <7>C{env: <8>C{a: "A", b: "B"}}, ` +
-			`#D4: <9>C{env: _|_(int:field "b" not allowed in closed struct)}, ` +
-			`#DC: <10>C{a: int}` +
-			`}`,
-	}, {
-		desc: "new-style definitions",
-		in: `
-		#Foo: {
-			a: 1
-			b: int
-		}
-		"#Foo": #Foo & {b: 1}
-
-		bulk: {[string]: string} & {
-			#def: 4 // Different namespace, so bulk option does not apply.
-			_hid: 3
-			a: "foo"
-		}
-		`,
-		out: `<0>{` +
-			`"#Foo": <1>C{a: 1, b: 1}, ` +
-			`#Foo: <2>C{a: 1, b: int}, ` +
-			`bulk: <3>{[]: <4>(_: string)->string, a: "foo", #def: 4, _hid: 3}` +
-			`}`,
-	}, {
-		desc: "recursive closing starting at non-definition",
-		in: `
-			z: a: {
-				#B: {
-					c: d: 1
-					c: f: 1
-				}
-			}
-			A: z & { a: { #B: { c: e: 2 } } }
-			`,
-		out: `<0>{z: <1>{a: <2>{#B: <3>C{c: <4>C{d: 1, f: 1}}}}, A: <5>{a: <6>{#B: <7>C{c: _|_(2:field "e" not allowed in closed struct)}}}}`,
-	}, {
-		desc: "non-closed definition carries over closedness to enclosed template",
-		in: `
-		#S: {
-			[string]: { a: int }
-		}
-		a: #S & {
-			v: { b: int }
-		}
-		#Q: {
-			[string]: { a: int } | { b: int }
-		}
-		b: #Q & {
-			w: { c: int }
-		}
-		#R: {
-			[string]: [{ a: int }, { b: int }]
-		}
-		c: #R & {
-			w: [{ d: int }, ...]
-		}
-		`,
-		out: `<0>{` +
-			`#S: <1>{[]: <2>(_: string)-><3>C{a: int}, }, ` +
-			`a: <4>{[]: <5>(_: string)-><6>C{a: int}, v: _|_(int:field "b" not allowed in closed struct)}, ` +
-			`b: <7>{[]: <8>(_: string)->(<9>C{a: int} | <10>C{b: int}), w: _|_(int:empty disjunction: field "c" not allowed in closed struct)}, ` +
-			`#Q: <11>{[]: <12>(_: string)->(<13>C{a: int} | <14>C{b: int}), }, ` +
-			`c: <15>{[]: <16>(_: string)->[<17>C{a: int},<18>C{b: int}], w: [_|_(int:field "d" not allowed in closed struct),<19>C{b: int}]}, ` +
-			`#R: <20>{[]: <21>(_: string)->[<22>C{a: int},<23>C{b: int}], }}`,
-	}, {
-		desc: "definitions with disjunctions",
-		in: `
-			#Foo: {
-				field: int
-
-				{ a: 1 } |
-				{ b: 2 }
-			}
-
-			foo: #Foo
-			foo: { a: 1 }
-
-			bar: #Foo
-			bar: { c: 2 }
-
-			baz: #Foo
-			baz: { b: 2 }
-			`,
-		out: `<0>{` +
-			`#Foo: (<1>C{field: int, a: 1} | <2>C{field: int, b: 2}), ` +
-			`foo: <3>C{field: int, a: 1}, ` +
-			`bar: _|_(2:empty disjunction: field "c" not allowed in closed struct), ` +
-			`baz: <4>C{field: int, b: 2}}`,
-	}, {
-		desc: "definitions with disjunctions recurisive",
-		in: `
-			#Foo: {
-				x: {
-					field: int
-
-					{ a: 1 } |
-					{ b: 2 }
-				}
-				x: c: 3
-			}
-					`,
-		out: `<0>{` +
-			`#Foo: <1>C{x: (<2>C{field: int, a: 1, c: 3} | <3>C{field: int, b: 2, c: 3})}` +
-			`}`,
-	}, {
-		desc: "definitions with embedding",
-		in: `
-		#E: {
-			a: { b: int }
-		}
-
-		#S: {
-			#E
-			a: { c: int }
-			b: 3
-		}
-
-		// adding a field to a nested struct that is closed.
-		#e1: #S & { a: d: 4 }
-		// literal struct not closed until after unification.
-		#v1: #S & { a: c: 4 }
-		`,
-		out: `<0>{` +
-			`#E: <1>C{a: <2>C{b: int}}, ` +
-			`#S: <3>C{a: <4>C{b: int, c: int}, b: 3}, ` +
-			`#e1: <5>C{a: _|_(4:field "d" not allowed in closed struct), b: 3}, ` +
-			`#v1: <6>C{a: <7>C{b: int, c: 4}, b: 3}}`,
-	}, {
-		desc: "top-level definition with struct and disjunction",
-		in: `
-		#def: {
-			Type: string
-			Text: string
-			Size: int
-		}
-
-		#def: {
-			Type: "B"
-			Size: 0
-		} | {
-			Type: "A"
-			Size: 1
-		}`,
-		out: `<0>{` +
-			`#def: (<1>C{Size: (0 & int), Type: ("B" & string), Text: string} | ` +
-			`<2>C{Size: (1 & int), Type: ("A" & string), Text: string})` +
-			`}`,
-	}, {
-		desc: "closing structs",
-		in: `
-		op: {x: int}             // {x: int}
-		ot: {x: int, ...}        // {x: int, ...}
-		cp: close({x: int})      // closed({x: int})
-		ct: close({x: int, ...}) // {x: int, ...}
-
-		opot: op & ot  // {x: int, ...}
-		otop: ot & op  // {x: int, ...}
-		opcp: op & cp  // closed({x: int})
-		cpop: cp & op  // closed({x: int})
-		opct: op & ct  // {x: int, ...}
-		ctop: ct & op  // {x: int, ...}
-		otcp: ot & cp  // closed({x: int})
-		cpot: cp & ot  // closed({x: int})
-		otct: ot & ct  // {x: int, ...}
-		ctot: ct & ot  // {x: int, ...}
-		cpct: cp & ct  // closed({x: int})
-		ctcp: ct & cp  // closed({x: int})
-		ctct: ct & ct  // {x: int, ...}
-		`,
-		out: `<0>{` +
-			`op: <1>{x: int}, ` +
-			`ot: <2>{x: int, ...}, ` +
-			`cp: <3>C{x: int}, ` +
-			`ct: <4>{x: int, ...}, ` +
-			`opot: <5>{x: int, ...}, ` +
-			`otop: <6>{x: int, ...}, ` +
-			`opcp: <7>C{x: int}, ` +
-			`cpop: <8>C{x: int}, ` +
-			`opct: <9>{x: int, ...}, ` +
-			`ctop: <10>{x: int, ...}, ` +
-			`otcp: <11>C{x: int}, ` +
-			`cpot: <12>C{x: int}, ` +
-			`otct: <13>{x: int, ...}, ` +
-			`ctot: <14>{x: int, ...}, ` +
-			`cpct: <15>C{x: int}, ` +
-			`ctcp: <16>C{x: int}, ` +
-			`ctct: <17>{x: int, ...}}`,
-	}, {
-		desc: "excluded embedding from closing",
-		in: `
-		#S: {
-			a: { c: int }
-			{
-				c: { d: int }
-			}
-			B = { open: int }
-			b: B
-		}
-		V: #S & {
-			c: e: int
-			b: extra: int
-		}
-		`,
-		out: `<0>{` +
-			`#S: <1>C{` +
-			`a: <2>C{c: int}, ` +
-			`c: <3>{d: int}, ` +
-			`b: <4>{open: int}}, ` +
-			`V: <5>C{` +
-			`a: <6>C{c: int}, ` +
-			`c: <7>{d: int, e: int}, ` +
-			`b: <8>{open: int, extra: int}}}`,
-	}, {
-		desc: "closing with failed optional",
-		in: `
-		#k1: {a: int, b?: int} & #A // closed({a: int})
-		#k2: #A & {a: int, b?: int} // closed({a: int})
-
-		o1: {a?: 3} & {a?: 4} // {a?: _|_}
-
-		// Optional fields with error values can be elimintated when closing
-		#o2: {a?: 3} & {a?: 4} // close({})
-
-		#d1: {a?: 2, b: 4} | {a?: 3, c: 5}
-		v1: #d1 & {a?: 3, b: 4}  // close({b: 4})
-
-		#A: {a: int}
-		`,
-		out: `<0>{` +
-			`#k1: <1>C{a: int}, ` +
-			`#A: <2>C{a: int}, ` +
-			`#k2: <3>C{a: int}, ` +
-			`o1: <4>{a?: _|_((3 & 4):conflicting values 3 and 4)}, ` +
-			`#o2: <5>C{a?: _|_((3 & 4):conflicting values 3 and 4)}, ` +
-			`#d1: (<6>C{a?: 2, b: 4} | <7>C{a?: 3, c: 5}), ` +
-			`v1: <8>C{a?: _|_((2 & 3):conflicting values 2 and 3), b: 4}` +
-			`}`,
-	}, {
-		desc: "closing with comprehensions",
-		in: `
-		#A: {f1: int, f2: int}
-
-		for k, v in {f3 : int} {
-			a: #A & { "\(k)": v }
-		}
-
-		#B: {
-			for k, v in {f1: int} {
-				"\(k)": v
-			}
-		}
-
-		#C: {
-			f1: _
-			for k, v in {f1: int} {
-				"\(k)": v
-			}
-		}
-
-		#D: {
-			for k, v in {f1: int} {
-				"\(k)": v
-			}
-			...
-		}
-
-		#E: #A & {
-			for k, v in { f3: int } {
-				"\(k)": v
-			}
-		}
-		`,
-		out: `<0>{` +
-			`#A: <1>C{f1: int, f2: int}, ` +
-			`a: _|_(<2>.v:field "f3" not allowed in closed struct), ` +
-			`#B: <3>C{f1: int}, ` +
-			`#C: <4>C{f1: int}, ` +
-			`#D: <5>{f1: int, ...}, ` +
-			`#E: _|_(<6>.v:field "f3" not allowed in closed struct)` +
-			`}`,
-	}, {
-		desc: "incomplete comprehensions",
-		in: `
-		A: {
-			for v in src {
-				"\(v)": v
-			}
-			src: _
-			if true {
-				baz: "baz"
-			}
-		}
-		B: A & {
-			src: ["foo", "bar"]
-		}
-		`,
-		out: `<0>{` +
-			`A: <1>{src: _, baz: "baz" <2>for _, v in <3>.src yield <4>{""+<2>.v+"": <2>.v}}, ` +
-			`B: <5>{src: ["foo","bar"], baz: "baz", foo: "foo", bar: "bar"}}`,
-	}, {
-		desc: "reference to root",
-		in: `
-			a: { b: int }
-			c: a & {
-				b: 100
-				d: a.b + 3 // do not resolve as c != a.
-			}
-			x: {
-				b: int
-				c: b + 5
-			}
-			y: x & {
-				b: 100
-				// c should resolve to 105
-			}
-			v: {
-				b: int
-				c: v.b + 5 // reference starting from copied node.
-			}
-			w: v & { b: 100 }
-			wp: v & { b: 100 }
-			`,
-		out: `<0>{x: <1>{b: int, c: (<2>.b + 5)}, y: <3>{b: 100, c: 105}, a: <4>{b: int}, c: <5>{b: 100, d: (<6>.a.b + 3)}, v: <7>{b: int, c: (<6>.v.b + 5)}, w: <8>{b: 100, c: (<6>.v.b + 5)}, wp: <9>{b: 100, c: (<6>.v.b + 5)}}`,
-		// TODO(#152): should be
-		// out: `<0>{a: <1>{b: int}, c: <2>{b: 100, d: (<3>.a.b + 3)}, x: <4>{b: int, c: (<5>.b + 5)}, y: <6>{b: 100, c: 105}, v: <7>{b: int, c: (<8>.b + 5)}, w: <9>{b: 100, c: 105}, wp: <10>{b: 100, c: 105}}`,
-	}, {
-		desc: "references from template to concrete",
-		in: `
-			res: [t]
-			t: [X=string]: {
-				a: c + b.str
-				b: str: string
-				c: "X"
-			}
-			t: x: { b: str: "DDDD" }
-			`,
-		out: `<0>{res: [<1>{[]: <2>(X: string)-><3>{a: (<3>.c + <3>.b.str), c: "X", b: <4>{str: string}}, x: <5>{a: "XDDDD", c: "X", b: <6>{str: "DDDD"}}}], t: <7>{[]: <2>(X: string)-><3>{a: (<3>.c + <3>.b.str), c: "X", b: <4>{str: string}}, x: <8>{a: "XDDDD", c: "X", b: <9>{str: "DDDD"}}}}`,
-	}, {
-		desc: "interpolation",
-		in: `
-			a: "\(4)"
-			b: "one \(a) two \(  a + c  )"
-			c: "one"
-			d: "\(r)"
-			u: "\(_)"
-			r: _
-			e: "\([])"`,
-		out: `<0>{a: "4", b: "one 4 two 4one", c: "one", d: ""+<1>.r+"", r: _, u: ""+_+"", e: _|_([]:expression in interpolation must evaluate to a number kind or string (found list))}`,
-	}, {
-		desc: "multiline interpolation",
-		in: `
-			a1: """
-			before
-			\(4)
-			after
-			"""
-			a2: """
-			before
-			\(4)
-
-			"""
-			a3: """
-
-			\(4)
-			after
-			"""
-			a4: """
-
-			\(4)
-
-			"""
-			m1: """
-			before
-			\(
-				4)
-			after
-			"""
-			m2: """
-			before
-			\(
-	4)
-
-			"""
-			m3: """
-
-			\(
-
-				4)
-			after
-			"""
-			m4: """
-
-			\(
-	4)
-
-			"""
-			`,
-		out: `<0>{` +
-			`a1: "before\n4\nafter", a2: "before\n4\n", a3: "\n4\nafter", a4: "\n4\n", ` +
-			`m1: "before\n4\nafter", m2: "before\n4\n", m3: "\n4\nafter", m4: "\n4\n"` +
-			`}`,
-	}, {
-		desc: "diamond-shaped constraints",
-		in: `
-		S: {
-			A: {
-				a: 1,
-			},
-			B: A & {
-				b: 2,
-			}
-		},
-		T: S & { // S == { A: { a:1 }, B: { a:1, b:2 } }
-			A: {
-				c: 3,
-			},
-			B: { // S.B & A
-				d: 4, // Combines constraints S.A, S.B, T.A, and T.B
-			}
-		}`,
-		out: "<0>{T: <1>{A: <2>{a: 1, c: 3}, B: <3>{a: 1, b: 2, c: 3, d: 4}}, S: <4>{A: <5>{a: 1}, B: <6>{a: 1, b: 2}}}",
-	}, {
-		desc: "field templates",
-		in: `
-			a: {
-				{[name=_]: int}
-				k: 1
-			}
-			b: {
-				{[X=_]: { x: 0, y: *1 | int }}
-				v: {}
-				w: { x: 0 }
-			}
-			b: { [y=_]: {} }
-			c: {
-				{[Name=_]: { name: Name, y: 1 }}
-				foo: {}
-				bar: _
-			}
-			`,
-		out: `<0>{a: <1>{[]: <2>(name: string)->int, k: 1}, b: <3>{[]: <4>(X: string)->(<5>{x: 0, y: (*1 | int)} & <6>{}), v: <7>{x: 0, y: (*1 | int)}, w: <8>{x: 0, y: (*1 | int)}}, c: <9>{[]: <10>(Name: string)-><11>{y: 1, name: <10>.Name}, foo: <12>{y: 1, name: "foo"}, bar: <13>{y: 1, name: "bar"}}}`,
-	}, {
-		desc: "range unification",
-		in: `
-			// with concrete values
-			a1: >=1 & <=5 & 3
-			a2: >=1 & <=5 & 1
-			a3: >=1 & <=5 & 5
-			a4: >=1 & <=5 & 6
-			a5: >=1 & <=5 & 0
-
-			a6: 3 & >=1 & <=5
-			a7: 1 & >=1 & <=5
-			a8: 5 & >=1 & <=5
-			a9: 6 & >=1 & <=5
-			a10: 0 & >=1 & <=5
-
-			// with ranges
-			b1: >=1 & <=5 & >=1 & <=5
-			b2: >=1 & <=5 & >=1 & <=1
-			b3: >=1 & <=5 & >=5 & <=5
-			b4: >=1 & <=5 & >=2 & <=3
-			b5: >=1 & <=5 & >=3 & <=9
-			b6: >=1 & <=5 & >=5 & <=9
-			b7: >=1 & <=5 & >=6 & <=9
-
-			b8: >=1 & <=5 & >=1 & <=5
-			b9: >=1 & <=1 & >=1 & <=5
-			b10: >=5 & <=5 & >=1 & <=5
-			b11: >=2 & <=3 & >=1 & <=5
-			b12: >=3 & <=9 & >=1 & <=5
-			b13: >=5 & <=9 & >=1 & <=5
-			b14: >=6 & <=9 & >=1 & <=5
-
-			// ranges with more general types
-			c1: int & >=1 & <=5
-			c2: >=1 & <=5 & int
-			c3: string & >=1 & <=5
-			c4: >=1 & <=5 & string
-
-			// other types
-			s1: >="d" & <="z" & "e"
-			s2: >="d" & <="z" & "ee"
-
-			n1: number & >=1 & <=2
-			n2: int & >=1.1 & <=1.3
-			n3: >=1.0 & <=3.0 & 2
-			n4: >=0.0 & <=0.1 & 0.09999
-			n5: >=1 & <=5 & 2.5
-			`,
-		out: `<0>{` +
-			`a1: 3, ` +
-			`a2: 1, ` +
-			`a3: 5, ` +
-			`a4: _|_((<=5 & 6):invalid value 6 (out of bound <=5)), ` +
-			`a5: _|_((>=1 & 0):invalid value 0 (out of bound >=1)), ` +
-			`a6: 3, ` +
-			`a7: 1, ` +
-			`a8: 5, ` +
-
-			`a9: _|_((<=5 & 6):invalid value 6 (out of bound <=5)), ` +
-			`a10: _|_((>=1 & 0):invalid value 0 (out of bound >=1)), ` +
-
-			`b1: (>=1 & <=5), ` +
-			`b2: 1, ` +
-			`b3: 5, ` +
-			`b4: (>=2 & <=3), ` +
-			`b5: (>=3 & <=5), ` +
-			`b6: 5, ` +
-			`b7: _|_(conflicting bounds >=6 and <=5), ` +
-			`b8: (>=1 & <=5), ` +
-			`b9: 1, ` +
-			`b10: 5, ` +
-			`b11: (>=2 & <=3), ` +
-			`b12: (>=3 & <=5), ` +
-			`b13: 5, ` +
-			`b14: _|_(conflicting bounds >=6 and <=5), ` +
-			`c1: (int & >=1 & <=5), ` +
-			`c2: (<=5 & int & >=1), ` +
-			`c3: _|_((string & >=1):conflicting values string and >=1 (mismatched types string and number)), ` +
-			`c4: _|_(((>=1 & <=5) & string):conflicting values (>=1 & <=5) and string (mismatched types number and string)), ` +
-			`s1: "e", ` +
-			`s2: "ee", ` +
-			`n1: (>=1 & <=2), ` +
-			`n2: _|_(conflicting bounds int & >=1.1 and <=1.3), ` +
-			`n3: 2, ` +
-			`n4: 0.09999, ` +
-			`n5: 2.5}`,
-	}, {
-		desc: "predefined ranges",
-		in: `
-			k1: int8
-			k1: 44
-
-			k2: int64
-			k2: -8_000_000_000
-
-			e1: int16
-			e1: 100_000
-		`,
-		out: `<0>{k1: 44, k2: -8000000000, ` +
-			`e1: _|_((int & <=32767 & 100000):invalid value 100000 (out of bound int & <=32767))}`,
-	}, {
-		desc: "struct comprehensions",
-		in: `
-			obj: foo: a: "bar"
-			obj: [Name=string]: {
-				a: *"dummy" | string
-				if true {
-					sub: as: a
-				}
-			}
-
-			for k, v in { #def: 1, opt?: 2, _hid: 3, reg: 4 } {
-				"\(k)": v
-			}
-		`,
-		out: `<0>{obj: <1>{[]: <2>(Name: string)-><3>{a: (*"dummy" | string) if true yield <4>{sub: <5>{as: <3>.a}}}, foo: <6>{a: "bar", sub: <7>{as: "bar"}}}, reg: 4}`,
-	}, {
-		desc: "builtins",
-		in: `
-		a1: {
-			a: and([b, c])
-			b: =~"oo"
-			c: =~"fo"
-		}
-		a2: a1 & { a: "foo" }
-		a3: a1 & { a: "bar" }
-
-		o1: {
-			a: or([b, c])
-			b: string
-			c: "bar"
-		}
-		o2: o1 & { a: "foo" }
-		o3: o1 & { a: "foo", b: "baz" }
-		`,
-		out: `<0>{` +
-			`a1: <1>{a: (=~"oo" & =~"fo"), b: =~"oo", c: =~"fo"}, ` +
-			`a2: <2>{a: "foo", b: =~"oo", c: =~"fo"}, ` +
-			`a3: <3>{a: _|_((=~"oo" & "bar"):invalid value "bar" (does not match =~"oo")), b: =~"oo", c: =~"fo"}, ` +
-			`o1: <4>{a: string, b: string, c: "bar"}, ` +
-			`o2: <5>{a: "foo", b: string, c: "bar"}, ` +
-			`o3: <6>{a: _|_(("baz" & "foo"):empty disjunction: conflicting values "baz" and "foo";("bar" & "foo"):empty disjunction: conflicting values "bar" and "foo"), b: "baz", c: "bar"}}`,
-	}, {
-		desc: "self-reference cycles conflicts with strings",
-		in: `
-			a: {
-				x: y+"?"
-				y: x+"!"
-			}
-			a: x: "hey"
-		`,
-		out: `<0>{a: <1>{x: _|_(("hey!?" & "hey"):conflicting values "hey!?" and "hey"), y: "hey!"}}`,
-	}, {
-		desc: "resolved self-reference cycles with disjunctions",
-		in: `
-			a: b&{x:1} | {y:1}  // {x:1,y:3,z:2} | {y:1}
-			b: {x:2} | c&{z:2}  // {x:2} | {x:1,y:3,z:2}
-			c: a&{y:3} | {z:3}  // {x:1,y:3,z:2} | {z:3}
-		`,
-		out: `<0>{a: (<1>{x: 1, y: 3, z: 2} | <2>{y: 1}), b: (<3>{x: 2} | <4>{x: 1, y: 3, z: 2}), c: (<5>{x: 1, y: 3, z: 2} | <6>{z: 3})}`,
-	}, {
-		// We take a very conservative stance on delaying arithmetic
-		// expressions within disjunctions. It should remain resolvable, though,
-		// once the user specifies one.
-		desc: "resolved self-reference cycles with disjunction",
-		in: `
-			// The second disjunct in xa1 is not resolvable and can be
-			// eliminated:
-			//   xa4 & 9
-			//   (xa2 + 2) & 9
-			//   ((xa3 + 2) + 2) & 9
-			//   (((6 & xa1-2) + 2) + 2) & 9
-			//   ((6 + 2) + 2) & 9 // 6 == xa1-2
-			//   10 & 9 => _|_
-			// The remaining values resolve.
-			xa1: (xa2 & 8) | (xa4 & 9)
-			xa2: xa3 + 2
-			xa3: 6 & xa1-2
-			xa4: xa2 + 2
-
-			// The second disjunct in xb4 can be eliminated as both disjuncts
-			// of xb3 result in an incompatible sum when substituted.
-			xb1: (xb2 & 8) | (xb4 & 9)
-			xb2: xb3 + 2
-			xb3: (6 & (xb1-2)) | (xb4 & 9)
-			xb4: xb2 + 2
-
-			// Another variant with more disjunctions. xc1 remains with two
-			// possibilities. Technically, only the first value is valid.
-			// However, to fully determine that, all options of the remaining
-			// disjunction will have to be evaluated algebraically, which is
-			// not done.
-			xc1: xc2 & 8 | xc4 & 9 | xc5 & 9
-			xc2: xc3 + 2
-			xc3: 6 & xc1-2
-			xc4: xc2 + 1
-			xc5: xc2 + 2
-
-			// The above is resolved by setting xd1 explicitly.
-			xd1: xd2 & 8 | xd4 & 9 | xd5 & 9
-			xd2: xd3 + 2
-			xd3: 6 & xd1-2
-			xd4: xd2 + 1
-			xd5: xd2 + 2
-			xd1: 8
-
-			// The above is resolved by setting xd1 explicitly to the wrong
-			// value, resulting in an error.
-			xe1: xe2 & 8 | xe4 & 9 | xe5 & 9
-			xe2: xe3 + 2
-			xe3: 6 & xe1-2
-			xe4: xe2 + 1
-			xe5: xe2 + 2
-			xe1: 9
-
-			// Only one solution.
-			xf1: xf2 & 8 | xf4 & 9
-			xf2: xf3 + 2
-			xf3: 6 & xf1-2 | xf4 & 9
-			xf4: xf2 + 2
-
-			z1: z2 + 1 | z3 + 5
-			z2: z3 + 2
-			z3: z1 - 3
-			z3: 8
-		`,
-		out: `<0>{` +
-			`xa1: 8, ` +
-			`xa2: 8, ` +
-			`xa4: 10, ` +
-			`xa3: 6, ` +
-
-			`xb1: 8, ` +
-			`xb2: 8, ` +
-			`xb4: 10, ` +
-			`xb3: 6, ` +
-
-			`xc1: ((<1>.xc2 & 8) | (<1>.xc4 & 9) | (<1>.xc5 & 9)), ` +
-			`xc2: (<1>.xc3 + 2), ` +
-			`xc4: (<1>.xc2 + 1), ` +
-			`xc5: (<1>.xc2 + 2), ` +
-			`xc3: (6 & (<1>.xc1 - 2)), ` +
-
-			`xd1: 8, ` +
-			`xd2: 8, ` +
-			`xd4: 9, ` +
-			`xd5: 10, ` +
-			`xd3: 6, ` +
-
-			`xe1: _|_((6 & 7):conflicting values 6 and 7), ` +
-			`xe2: _|_((6 & 7):conflicting values 6 and 7), ` +
-			`xe4: _|_((6 & 7):conflicting values 6 and 7), ` +
-			`xe5: _|_((6 & 7):conflicting values 6 and 7), ` +
-			`xe3: _|_((6 & 7):conflicting values 6 and 7), ` +
-
-			`xf1: 8, ` +
-			`xf2: 8, ` +
-			`xf4: 10, ` +
-			`xf3: 6, ` +
-
-			`z1: ((<1>.z2 + 1) | (<1>.z3 + 5)), ` +
-			`z2: (<1>.z3 + 2), ` +
-			`z3: ((<1>.z1 - 3) & 8)}`,
-	}, {
-		// Defaults should not alter the result of the above disjunctions.
-		// The results may differ, but errors and resolution should be roughly
-		// the same.
-		desc: "resolved self-reference cycles with disjunction with defaults",
-		in: `
-			// The disjunction in xa could be resolved, but as disjunctions
-			// are not resolved for expression, it remains unresolved.
-			xa1: (xa2 & 8) | *(xa4 & 9)
-			xa2: xa3 + 2
-			xa3: 6 & xa1-2
-			xa4: xa2 + 2
-
-			// As xb3 is a disjunction, xb2 cannot be resolved and evaluating
-			// the cycle completely is broken. However, it is not an error
-			// as the user might still resolve the disjunction.
-			xb1: *(xb2 & 8) | (xb4 & 9)
-			xb2: xb3 + 2
-			xb3: *(6 & (xb1-2)) | (xb4 & 9)
-			xb4: xb2 + 2
-
-			// Another variant with more disjunctions. xc1 remains with two
-			// possibilities. Technically, only the first value is valid.
-			// However, to fully determine that, all options of the remaining
-			// disjunction will have to be evaluated algebraically, which is
-			// not done.
-			xc1: *(xc2 & 8) | (xc4 & 9) | (xc5 & 9)
-			xc2: xc3 + 2
-			xc3: 6 & xc1-2
-			xc4: xc2 + 1
-			xc5: xc2 + 2
-
-			// The above is resolved by setting xd1 explicitly.
-			xd1: *(xd2 & 8) | xd4 & 9 | xd5 & 9
-			xd2: xd3 + 2
-			xd3: 6 & xd1-2
-			xd4: xd2 + 1
-			xd5: xd2 + 2
-
-			// The above is resolved by setting xd1 explicitly to the wrong
-			// value, resulting in an error.
-			xe1: *(xe2 & 8) | xe4 & 9 | xe5 & 9
-			xe2: xe3 + 2
-			xe3: 6 & xe1-2
-			xe4: xe2 + 1
-			xe5: xe2 + 2
-			xe1: 9
-
-			z1: *(z2 + 1) | z3 + 5
-			z2: z3 + 2
-			z3: z1 - 3
-			z3: 8
-		`,
-		out: `<0>{` +
-			`xa1: 8, ` +
-			`xa2: 8, ` +
-			`xa4: 10, ` +
-			`xa3: 6, ` +
-
-			`xb1: 8, ` +
-			`xb2: 8, ` +
-			`xb4: 10, ` +
-			`xb3: 6, ` +
-
-			`xc1: (*8 | 9), ` + // not resolved because we use evalPartial
-			`xc2: 8, ` +
-			`xc4: 9, ` +
-			`xc5: 10, ` +
-			`xc3: 6, ` +
-
-			`xd1: (*8 | 9), ` + // TODO: eliminate 9?
-			`xd2: 8, ` +
-			`xd4: 9, ` +
-			`xd5: 10, ` +
-			`xd3: 6, ` +
-
-			`xe1: _|_((6 & 7):conflicting values 6 and 7), ` +
-			`xe2: _|_((6 & 7):conflicting values 6 and 7), ` +
-			`xe4: _|_((6 & 7):conflicting values 6 and 7), ` +
-			`xe5: _|_((6 & 7):conflicting values 6 and 7), ` +
-			`xe3: _|_((6 & 7):conflicting values 6 and 7), ` +
-
-			`z1: (*11 | 13), ` + // 13 is eliminated with evalFull
-			`z2: 10, ` +
-			`z3: 8}`,
-	}}
-	rewriteHelper(t, testCases, evalPartial)
-}
-
-func TestFullEval(t *testing.T) {
-	testCases := []testCase{{
-		desc: "detect conflicting value",
-		in: `
-				a: 8000.9
-				a: 7080 | int`,
-		out: `<0>{a: _|_((8000.9 & (int | int)):conflicting values 8000.9 and int (mismatched types float and int))}`, // TODO: fix repetition
-	}, {
-		desc: "conflicts in optional fields are okay ",
-		in: `
-			d: {a: 1, b?: 3} | {a: 2}
-
-			// the following conjunction should not eliminate any disjuncts
-			c: d & {b?:4}
-		`,
-		out: `<0>{d: (<1>{a: 1, b?: 3} | <2>{a: 2}), c: (<3>{a: 1, b?: (3 & 4)} | <4>{a: 2, b?: 4})}`,
-	}, {
-		desc: "resolve all disjunctions",
-		in: `
-			service: [Name=string]: {
-				name: string | *Name
-				port: int | *7080
-			}
-			service: foo: _
-			service: bar: { port: 8000 }
-			service: baz: { name: "foobar" }
-			`,
-		out: `<0>{service: <1>{[]: <2>(Name: string)-><3>{name: (string | *<2>.Name), port: (int | *7080)}, foo: <4>{name: "foo", port: 7080}, bar: <5>{name: "bar", port: 8000}, baz: <6>{name: "foobar", port: 7080}}}`,
-	}, {
-		desc: "field templates",
-		in: `
-			a: {
-				[name=_]: int
-				k: 1
-			}
-			b: {
-				[X=_]: { x: 0, y: *1 | int }
-				v: {}
-				w: { y: 0 }
-			}
-			b: { [y=_]: {} } // TODO: allow different name
-			c: {
-				[Name=_]: { name: Name, y: 1 }
-				foo: {}
-				bar: _
-			}
-			`,
-		out: `<0>{a: <1>{[]: <2>(name: string)->int, k: 1}, b: <3>{[]: <4>(X: string)->(<5>{x: 0, y: (*1 | int)} & <6>{}), v: <7>{x: 0, y: 1}, w: <8>{x: 0, y: 0}}, c: <9>{[]: <10>(Name: string)-><11>{y: 1, name: <10>.Name}, foo: <12>{y: 1, name: "foo"}, bar: <13>{y: 1, name: "bar"}}}`,
-	}, {
-		desc: "field comprehension",
-		in: `
-			a: {
-				for k, v in b
-				if k < "d"
-				if v > b.a {
-					"\(k)": v
-				}
-			}
-			b: {
-				a: 1
-				b: 2
-				c: 3
-				d: 4
-			}
-			c: {
-				for k, v in b
-				if k < "d"
-				if v > b.a {
-					"\(k)": v
-				}
-			}
-			`,
-		out: `<0>{a: <1>{b: 2, c: 3}, b: <2>{a: 1, b: 2, c: 3, d: 4}, c: <3>{b: 2, c: 3}}`,
-	}, {
-		desc: "conditional field",
-		in: `
-			if b {
-				a: "foo"
-			}
-			b: true
-			c: {
-				a: 3
-				if a > 1 {
-					a: 3
-				}
-			}
-			d: {
-				a: int
-				if a > 1 {
-					a: 3
-				}
-			}
-		`,
-		// NOTE: the node numbers are not correct here, but this is an artifact
-		// of the testing code.
-		out: `<0>{b: true, a: "foo", c: <1>{a: 3}, d: <2>{a: int if (<3>.a > 1) yield <4>{a: 3}}}`,
-	}, {
-		desc: "referencing field in field comprehension",
-		in: `
-		a: { b: c: 4 }
-		a: {
-			b: d: 5
-			for k, v in b {
-				"\(k)": v
-			}
-		}
-		`,
-		out: `<0>{a: <1>{b: <2>{c: 4, d: 5}, c: 4, d: 5}}`,
-	}, {
-		desc: "different labels for templates",
-		in: `
-		a: [X=string]: { name: X }
-		a: [Name=string]: { name: Name }
-		a: foo: {}
-		`,
-		out: `<0>{a: <1>{[]: <2>(X: string)->(<3>{name: <2>.X} & <4>{name: <2>.X}), foo: <5>{name: "foo"}}}`,
-	}, {
-		// TODO: rename EE and FF to E and F to check correct ordering.
-
-		desc: "nested templates in one field",
-		in: `
-			a: [A=string]: b: [B=string]: {
-				name: A
-				kind: B
-			}
-			a: "A": b: "B": _
-			a: "C": b: "D": _
-			a: "EE": b: "FF": { c: "bar" }
-		`,
-		out: `<0>{a: <1>{[]: <2>(A: string)-><3>{b: <4>{[]: <5>(B: string)-><6>{name: <2>.A, kind: <5>.B}, }}, ` +
-			`A: <7>{b: <8>{[]: <9>(B: string)-><10>{name: <11>.A, kind: <9>.B}, ` +
-			`B: <12>{name: "A", kind: "B"}}}, ` +
-			`C: <13>{b: <14>{[]: <15>(B: string)-><16>{name: <17>.A, kind: <15>.B}, ` +
-			`D: <18>{name: "C", kind: "D"}}}, ` +
-			`EE: <19>{b: <20>{[]: <21>(B: string)-><22>{name: <23>.A, kind: <21>.B}, ` +
-			`FF: <24>{name: "EE", kind: "FF", c: "bar"}}}}}`,
-	}, {
-		desc: "template unification within one struct",
-		in: `
-			a: {
-				[A=string]: { name: A }
-				// TODO: allow duplicate alias here
-				[X=string]: { kind: X }
-			}
-			a: "A": _
-			a: "C": _
-			a: "E": { c: "bar" }
-		`,
-		out: `<0>{a: <1>{[]: <2>(A: string)->(<3>{name: <2>.A} & <4>{kind: <2>.A}), ` +
-			`E: <5>{name: "E", kind: "E", c: "bar"}, ` +
-			`A: <6>{name: "A", kind: "A"}, ` +
-			`C: <7>{name: "C", kind: "C"}}}`,
-	}, {
-		desc: "field comprehensions with multiple keys",
-		in: `
-			for x in [
-				{a: "A", b: "B" },
-				{a: "C", b: "D" },
-				{a: "E", b: "F" },
-			] {
-				a: "\(x.a)": b: "\(x.b)": x
-			}
-
-			for x in [
-				{a: "A", b: "B" },
-				{a: "C", b: "D" },
-				{a: "E", b: "F" },
-			] {
-				"\(x.a)": "\(x.b)": x
-			}
-			`,
-		out: `<0>{E: <1>{F: <2>{a: "E", b: "F"}}, ` +
-			`a: <3>{` +
-			`E: <4>{b: <5>{F: <6>{a: "E", b: "F"}}}, ` +
-			`A: <7>{b: <8>{B: <9>{a: "A", b: "B"}}}, ` +
-			`C: <10>{b: <11>{D: <12>{a: "C", b: "D"}}}}, ` +
-			`A: <13>{B: <14>{a: "A", b: "B"}}, ` +
-			`C: <15>{D: <16>{a: "C", b: "D"}}}`,
-		// TODO: this order would be desirable.
-		// out: `<0>{a: <1>{` +
-		// 	`A: <2>{b: <3>{B: <4>{a: "A", b: "B"}}}, ` +
-		// 	`C: <5>{b: <6>{D: <7>{a: "C", b: "D"}}}, ` +
-		// 	`E: <8>{b: <9>{F: <10>{a: "E", b: "F"}}}}, ` +
-		// 	`A: <11>{B: <12>{a: "A", b: "B"}}, ` +
-		// 	`C: <13>{D: <14>{a: "C", b: "D"}}, ` +
-		// 	`E: <15>{F: <16>{a: "E", b: "F"}}}`,
-	}, {
-		desc: "field comprehensions with templates",
-		in: `
-			num: 1
-			a: {
-				if num < 5 {
-					[A=string]: [B=string]: {
-						name: A
-						kind: B
-					}
-				}
-			}
-			a: b: c: d: "bar"
-			`,
-		out: `<0>{num: 1, a: <1>{[]: <2>(A: string)-><3>{[]: <4>(B: string)-><5>{name: <2>.A, kind: <4>.B}, }, ` +
-			`b: <6>{[]: <7>(B: string)-><8>{name: <9>.A, kind: <7>.B}, ` +
-			`c: <10>{name: "b", kind: "c", ` +
-			`d: "bar"}}}}`,
-	}, {
-		desc: "disjunctions of lists",
-		in: `
-			l: *[ int, int ] | [ string, string ]
-
-			l1: [ "a", "b" ]
-			l2: l & [ "c", "d" ]
-			`,
-		out: `<0>{l: [int,int], l1: ["a","b"], l2: ["c","d"]}`,
-	}, {
-		desc: "normalization",
-		in: `
-			a: string | string
-			b: *1 | *int
-			c: *1.0 | *float
-		`,
-		out: `<0>{a: string, b: int, c: float}`,
-	}, {
-		desc: "default disambiguation and elimination",
-		in: `
-		a: *1 | int
-		b: *3 | int
-		c: a & b
-		d: b & a
-
-		e: *1 | *1
-		`,
-		out: `<0>{a: 1, b: 3, c: int, d: int, e: 1}`,
-	}, {
-		desc: "list comprehension",
-		in: `
-			a: [ for k, v in b if k < "d" if v > b.a { k }]
-			b: {
-				a: 1
-				b: 2
-				c: 3
-				d: 4
-			}
-			c: [ for _, x in b for _, y in b  if x < y { x } ]
-			d: [ for x, _ in a { x } ]
-			`,
-		out: `<0>{a: ["b","c"], b: <1>{a: 1, b: 2, c: 3, d: 4}, c: [1,1,1,2,2,3], d: [0,1]}`,
-	}, {
-		desc: "struct comprehension with template",
-		in: `
-			result: [ for _, v in service { v } ]
-
-			service: [Name=string]: {
-				name: *Name | string
-				type: "service"
-				port: *7080 | int
-			}
-			service: foo: {}
-			service: bar: { port: 8000 }
-			service: baz: { name: "foobar" }
-			`,
-		out: `<0>{result: [` +
-			`<1>{name: "foo", type: "service", port: 7080},` +
-			`<2>{name: "bar", type: "service", port: 8000},` +
-			`<3>{name: "foobar", type: "service", port: 7080}], ` +
-
-			`service: <4>{` +
-			`[]: <5>(Name: string)-><6>{name: (*<5>.Name | string), type: "service", port: (*7080 | int)}, ` +
-			`foo: <7>{name: "foo", type: "service", port: 7080}, ` +
-			`bar: <8>{name: "bar", type: "service", port: 8000}, ` +
-			`baz: <9>{name: "foobar", type: "service", port: 7080}}}`,
-	}, {
-		desc: "resolutions in struct comprehension keys",
-		in: `
-			a: { for _, b in ["c"] { "\(b + ".")": "a" } }
-			`,
-		out: `<0>{a: <1>{"c.": "a"}}`,
-	}, {
-		desc: "recursive evaluation within list",
-		in: `
-			l: [a]
-			a: b & { c: "t" }
-			b: {
-				d: c
-				c: string
-			}
-			l1: [a1]
-			a1: b1 & { c: "t" }
-			b1: {
-				d: "s" + c
-				c:  string
-			}
-		`,
-		out: `<0>{` +
-			`l: [<1>{c: "t", d: "t"}], ` +
-			`a: <2>{c: "t", d: "t"}, ` +
-			`b: <3>{c: string, d: string}, ` +
-			`l1: [<4>{c: "t", d: "st"}], ` +
-			`a1: <5>{c: "t", d: "st"}, ` +
-			`b1: <6>{c: string, d: ("s" + <7>.c)}}`,
-	}, {
-		desc: "ips",
-		in: `
-		IP: 4*[ uint8 ]
-
-		Private:
-			*[ 192, 168, uint8, uint8 ] |
-			[ 10, uint8, uint8, uint8] |
-			[ 172, >=16 & <=32, uint8, uint8 ]
-
-		Inst: Private & [ _, 10, ... ]
-
-		MyIP: Inst & [_, _, 10, 10 ]
-		`,
-		out: `<0>{` +
-			`IP: [(int & >=0 & int & <=255),(int & >=0 & int & <=255),(int & >=0 & int & <=255),(int & >=0 & int & <=255)], ` +
-			`Private: [192,168,(int & >=0 & int & <=255),(int & >=0 & int & <=255)], ` +
-			`Inst: [10,10,(int & >=0 & int & <=255),(int & >=0 & int & <=255)], ` +
-			`MyIP: [10,10,10,10]` +
-			`}`,
-	}, {
-		desc: "complex interaction of groundness",
-		in: `
-			res: [ for x in a for y in x { y & { d: "b" } }]
-			res: [ a.b.c & { d: "b" } ]
-
-			a: b: [C=string]: { d: string, s: "a" + d }
-			a: b: c: d: string
-		`,
-		// TODO(perf): unification should catch shared node.
-		out: `<0>{res: [<1>{d: "b", s: "ab"}], ` +
-			`a: <2>{b: <3>{[]: <4>(C: string)-><5>{d: string, s: ("a" + <5>.d)}, c: <6>{d: string, s: ("a" + <7>.d)}}}}`,
-	}, {
-		desc: "complex groundness 2",
-		in: `
-			r1: f1 & { y: "c" }
-
-			f1: { y: string, res: a.b.c & { d: y } }
-
-			a: b: c: { d: string, s: "a" + d }
-			a: b: [C=string]: { d: string, s: "a" + d }
-			a: b: c: d: string
-		`,
-		out: `<0>{r1: <1>{y: "c", res: <2>{d: "c", s: "ac"}}, f1: <3>{y: string, res: <4>{d: string, s: (("a" + <5>.d) & ("a" + <5>.d))}}, a: <6>{b: <7>{[]: <8>(C: string)-><9>{d: string, s: ("a" + <9>.d)}, c: <10>{d: string, s: (("a" + <11>.d) & ("a" + <11>.d))}}}}`,
-	}, {
-		desc: "references from template to concrete",
-		in: `
-				res: [t]
-				t: [X=string]: {
-					a: c + b.str
-					b: str: string
-					c: "X"
-				}
-				t: x: { b: str: "DDDD" }
-				`,
-		out: `<0>{res: [<1>{[]: <2>(X: string)-><3>{a: (<3>.c + <3>.b.str), c: "X", b: <4>{str: string}}, x: <5>{a: "XDDDD", c: "X", b: <6>{str: "DDDD"}}}], ` +
-			`t: <7>{[]: <2>(X: string)-><3>{a: (<3>.c + <3>.b.str), c: "X", b: <4>{str: string}}, x: <8>{a: "XDDDD", c: "X", b: <9>{str: "DDDD"}}}}`,
-	}, {
-		// TODO: A nice property for CUE to have would be that evaluation time
-		// is proportional to the number of output nodes (note that this is
-		// not the same as saying that the running time is O(n)).
-		// We should probably disallow shenanigans like the one below. But until
-		// this is allowed, it should at least be correct. At least we are not
-		// making reentrant coding easy.
-		desc: "reentrance",
-		in: `
-		// This indirection is needed to avoid binding references to fib
-		// within fib to the instantiated version.
-		fibRec: {nn: int, out: (fib & {n: nn}).out}
-		fib: {
-			n: int
-
-			if n >= 2 {
-				out: (fibRec & {nn: n - 2}).out + (fibRec & {nn: n - 1}).out
-			}
-			if n < 2 {
-				out: n
-			}
-		}
-		fib2: (fib & {n: 2}).out
-		fib7: (fib & {n: 7}).out
-		fib12: (fib & {n: 12}).out
-		`,
-		out: `<0>{` +
-			`fibRec: <1>{` +
-			`nn: int, ` +
-			`out: (<2>.fib & <3>{n: <4>.nn}).out}, ` +
-			// NOTE: the node numbers are not correct here, but this is an artifact
-			// of the testing code.
-			`fib: <5>{n: int if (<6>.n >= 2) yield <7>{out: ((<2>.fibRec & <8>{nn: (<6>.n - 2)}).out + (<2>.fibRec & <9>{nn: (<6>.n - 1)}).out)},  if (<6>.n < 2) yield <10>{out: <6>.n}}, ` +
-			`fib2: 1, ` +
-			`fib7: 13, ` +
-			`fib12: 144}`,
-	}, {
-		desc: "Issue #23",
-		in: `
-			x: {a:1}|{a:2}
-			y: x & {a:3}
-		`,
-		out: `<0>{x: (<1>{a: 1} | <2>{a: 2}), y: _|_((1 & 3):empty disjunction: conflicting values 1 and 3;(2 & 3):empty disjunction: conflicting values 2 and 3)}`,
-	}, {
-		desc: "cannot resolve references that would be ambiguous",
-		in: `
-		a1: *0 | 1
-		a1: a3 - a2
-		a2: *0 | 1
-		a2: a3 - a1
-		a3: 1
-
-		b1: (*0 | 1) & b2
-		b2: (0 | *1) & b1
-
-		c1: (*{a:1} | {b:1}) & c2
-		c2: (*{a:2} | {b:2}) & c1
-		`,
-		out: `<0>{` +
-			`a1: ((*0 | 1) & (<1>.a3 - <1>.a2)), ` +
-			`a3: 1, ` +
-			`a2: ((*0 | 1) & (<1>.a3 - <1>.a1)), ` +
-			`b1: (0 | 1), ` +
-			`b2: (0 | 1), ` +
-			`c1: (<2>{a: 1, b: 2} | <3>{a: 2, b: 1}), ` +
-			`c2: (<4>{a: 2, b: 1} | <5>{a: 1, b: 2})}`,
-	}, {
-		desc: "dont convert incomplete errors to non-incomplete",
-		in: `
-		import "strings"
-
-		n1: {min: <max, max: >min}
-		n2: -num
-		n3: +num
-		n4: num + num
-		n5: num - num
-		n6: num * num
-		n7: num / num
-
-		b1: !is
-
-		s1: "\(str)"
-		s2: strings.ContainsAny("dd")
-		s3: strings.ContainsAny(str, "dd")
-
-		str: string
-		num: <4
-		is:  bool
-		`,
-		out: `<0>{` +
-			`n1: <1>{min: <<2>.max, max: ><2>.min}, ` +
-			`n2: -<3>.num, num: <4, ` +
-			`n3: +<3>.num, ` +
-			`n4: (<3>.num + <3>.num), ` +
-			`n5: (<3>.num - <3>.num), ` +
-			`n6: (<3>.num * <3>.num), ` +
-			`n7: (<3>.num / <3>.num), ` +
-			`b1: !<3>.is, ` +
-			`is: bool, ` +
-			`s1: ""+<3>.str+"", ` +
-			`str: string, ` +
-			`s2: strings.ContainsAny ("dd"), ` +
-			`s3: <4>.ContainsAny (<3>.str,"dd")}`,
-	}, {
-		desc: "len of incomplete types",
-		in: `
-		args: *[] | [...string]
-		v1: len(args)
-		v2: len([])
-		v3: len({})
-		v4: len({a: 3})
-		v5: len({a: 3} | {a: 4})
-		v6: len('sf' | 'dd')
-		v7: len([2] | *[1, 2])
-		v8: len([2] | [1, 2])
-		v9: len("😂")
-		v10: len("")
-		`,
-		out: `<0>{` +
-			`args: [], ` +
-			`v1: 0, ` +
-			`v2: 0, ` +
-			`v3: 0, ` +
-			`v4: 1, ` +
-			`v5: len ((<1>{a: 3} | <2>{a: 4})), ` +
-			`v6: len (('sf' | 'dd')), ` +
-			`v7: 2, ` +
-			`v8: len (([2] | [1,2])), ` +
-			`v9: 4, ` +
-			`v10: 0}`,
-	}, {
-		desc: "slice rewrite bug",
-		in: `
-		fn: {
-			arg: [...int] & [1]
-			out: arg[1:]
-		}
-		fn1: fn & {arg: [1]}
-		`,
-		out: `<0>{fn: <1>{arg: [1], out: []}, fn1: <2>{arg: [1], out: []}}`,
-	}, {
-		desc: "Issue #94",
-		in: `
-		foo: {
-			opt?: 1
-			"txt": 2
-			#def: 3
-			regular: 4
-			_hidden: 5
-		}
-		comp: { for k, v in foo { "\(k)": v } }
-		select: {
-			opt: foo.opt
-			"txt": foo.txt
-			#def: foo.#def
-			regular: foo.regular
-			_hidden: foo._hidden
-		}
-		index: {
-			opt: foo["opt"]
-			"txt": foo["txt"]
-			#def: foo["#def"]
-			regular: foo["regular"]
-			_hidden: foo["_hidden"]
-		}
-		`,
-		out: `<0>{` +
-			`foo: <1>{opt?: 1, txt: 2, #def: 3, regular: 4, _hidden: 5}, ` +
-			`comp: <2>{txt: 2, regular: 4}, ` +
-			`select: <3>{opt: <4>.foo.opt, txt: 2, #def: 3, regular: 4, _hidden: 5}, ` +
-			`index: <5>{opt: <4>.foo["opt"], txt: 2, #def: <4>.foo["#def"], regular: 4, _hidden: <4>.foo["_hidden"]}}`,
-	}, {
-		desc: "retain references with interleaved embedding",
-		in: `
-		a: d: {
-			#base
-			#info: {...}
-			Y: #info.X
-		}
-
-		#base: {
-			#info: {...}
-		}
-
-		a: [Name=string]: { #info: {
-			X: "foo"
-		}}
-		`,
-		out: `<0>{a: <1>{[]: <2>(Name: string)-><3>{#info: <4>C{X: "foo"}}, d: <5>C{#info: <6>C{X: "foo"}, Y: "foo"}}, #base: <7>C{#info: <8>{...}}}`,
-	}, {
-		desc: "comparison against bottom",
-		in: `
-		a: _|_ == _|_
-		b: err == 1&2 // not a literal error, so not allowed
-		c: err == _|_ // allowed
-		d: err != _|_ // allowed
-		e: err != 1&3
-		// z: err == err // TODO: should infer to be true?
-		f: ({a: 1} & {a: 2}) == _|_
-		g: ({a: 1} & {b: 2}) == _|_
-		h: _|_ == ({a: 1} & {a: 2})
-		i: _|_ == ({a: 1} & {b: 2})
-
-		err: 1 & 2
-		`,
-		out: `<0>{a: true, b: _|_((1 & 2):conflicting values 1 and 2), err: _|_((1 & 2):conflicting values 1 and 2), c: true, d: false, e: _|_((1 & 2):conflicting values 1 and 2), f: true, g: false, h: true, i: false}`,
-	}, {
-		desc: "or builtin should not fail on non-concrete empty list",
-		in: `
-		#Workflow: {
-			jobs: {
-				[jobID=string]: {
-				}
-			}
-			#JobID: or([ for k, _ in jobs { k } ])
-		}
-
-		foo: #Workflow & {
-			jobs: foo: {
-			}
-		}
-		`,
-		out: `<0>{#Workflow: <1>C{jobs: <2>{[]: <3>(jobID: string)-><4>C{}, }, #JobID: or ([ <5>for k, _ in <6>.jobs yield <5>.k ])}, foo: <7>C{jobs: <8>{[]: <9>(jobID: string)-><10>C{}, foo: <11>C{}}, #JobID: "foo"}}`,
-	}, {
-		desc: "Issue #153",
-		in: `
-		Foo: {
-			listOfCloseds: [...#Closed]
-		}
-
-		#Closed: {
-			a: int | *0
-		}
-
-		Junk: {
-			b: 2
-		}
-
-		Foo & {
-			listOfCloseds: [{
-				for k, v in Junk {
-					"\(k)": v
-				}
-			 }]
-		}
-		`,
-		out: `<0>{<1>{listOfCloseds: [_|_(<2>.v:field "b" not allowed in closed struct)]}, Foo: <3>{listOfCloseds: []}, #Closed: <4>C{a: 0}, Junk: <5>{b: 2}}`,
-	}, {
-		desc: "label and field aliases",
-		in: `
-		p: [ID=string]: { name: ID }
-		A="foo=bar": "str"
-		a: A
-		B=bb: 4
-		b1: B
-		b1: bb
-		C="\(a)": 5
-		c: C
-		`,
-		out: `<0>{` +
-			`p: <1>{[]: <2>(ID: string)-><3>{name: <2>.ID}, }, ` +
-			`"foo=bar": "str", ` +
-			`a: "str", ` +
-			`bb: 4, ` +
-			`b1: 4, ` +
-			`c: 5, ` +
-			`str: 5}`,
-	}, {
-		desc: "optionals with label filters",
-		in: `
-		#JobID: =~"^[a-zA-Z]*$"
-		#Job: {
-			name: string
-			cmd:  string
-		}
-		#Jobs: {
-			[#JobID]: #Job
-			[=~"Test$"]: name: =~"^test" // Must work without ...
-		}
-
-		jobs: foo: name: "allGood"
-		jobs: foo: name: "allGood"
-
-		jobs1: #Jobs
-		jobs1: foo1: {} // faulty
-
-		jobs2: #Jobs
-		jobs2: fooTest: name: "badName" // faulty
-
-		jobs3: #Jobs
-		jobs3: [string]: #Job
-		jobs3: fooTest1: name: "badName" // faulty
-		`,
-		out: `<0>{` +
-			`#JobID: =~"^[a-zA-Z]*$", ` +
-			`#Job: <1>C{name: string, cmd: string}, ` +
-			`#Jobs: <2>C{[=~"^[a-zA-Z]*$"]: <3>(_: string)-><4>.#Job, [=~"Test$"]: <5>(_: string)-><6>C{name: =~"^test"}, }, ` +
-			`jobs: <7>{foo: <8>{name: "allGood"}}, ` +
-			`jobs1: _|_(<9>{}:field "foo1" not allowed in closed struct), ` +
-			`jobs2: <10>C{[=~"^[a-zA-Z]*$"]: <11>(_: string)-><4>.#Job, [=~"Test$"]: <12>(_: string)-><13>C{name: =~"^test"}, fooTest: _|_(string:field "cmd" not allowed in closed struct)}, ` +
-			`jobs3: _|_(<14>{name: "badName"}:field "fooTest1" not allowed in closed struct)}`,
-	}, {
-		desc: "optionals in open structs",
-		in: `
-		A: {
-			[=~"^[a-s]*$"]: int
-		}
-		B: {
-			[=~"^[m-z]*$"]: int
-		}
-		#C: {A & B}
-		c: #C & { aaa: 3 }
-		`,
-		out: `<0>{A: <1>{[=~"^[a-s]*$"]: <2>(_: string)->int, }, B: <3>{[=~"^[m-z]*$"]: <4>(_: string)->int, }, #C: <5>C{[=~"^[a-s]*$"]: <6>(_: string)->int, [=~"^[m-z]*$"]: <7>(_: string)->int, }, c: <8>C{[=~"^[a-s]*$"]: <9>(_: string)->int, [=~"^[m-z]*$"]: <10>(_: string)->int, aaa: 3}}`,
-	}, {
-		desc: "conjunction of optional sets",
-		in: `
-		#A: {
-			[=~"^[a-s]*$"]: int
-		}
-		#B: {
-			[=~"^[m-z]*$"]: int
-		}
-
-		#C: #A & #B
-		c: #C & { aaa: 3 }
-
-		#D: {#A & #B}
-		d: #D & { aaa: 3 }
-		`,
-		out: `<0>{` +
-			`#A: <1>C{[=~"^[a-s]*$"]: <2>(_: string)->int, }, ` +
-			`#B: <3>C{[=~"^[m-z]*$"]: <4>(_: string)->int, }, ` +
-			`#C: <5>C{(C{[=~"^[a-s]*$"]: <6>(_: string)->int} & C{[=~"^[m-z]*$"]: <7>(_: string)->int}), }, ` +
-			`c: _|_(3:field "aaa" not allowed in closed struct), ` +
-			`#D: <8>C{(C{[=~"^[a-s]*$"]: <9>(_: string)->int} & C{[=~"^[m-z]*$"]: <10>(_: string)->int}), }, ` +
-			`d: _|_(3:field "aaa" not allowed in closed struct)` +
-			`}`,
-	}, {
-		desc: "continue recursive closing for optionals",
-		in: `
-		#S: {
-			[string]: { a: int }
-		}
-		a: #S & {
-			v: { b: int }
-		}
-		`,
-		out: `<0>{#S: <1>{[]: <2>(_: string)-><3>C{a: int}, }, a: <4>{[]: <5>(_: string)-><6>C{a: int}, v: _|_(int:field "b" not allowed in closed struct)}}`,
-	}, {
-		desc: "augment closed optionals",
-		in: `
-		#A: {
-			[=~"^[a-s]*$"]: int
-		}
-		#B: {
-			[=~"^[m-z]*?"]: int
-		}
-		#C: {
-			#A & #B
-			[=~"^Q*$"]: int
-		}
-		c: #C & { QQ: 3 }
-		#D: {
-			#A
-			#B
-		}
-		d: #D & { aaa: 4 }
-		`,
-		out: `<0>{` +
-			`#A: <1>C{[=~"^[a-s]*$"]: <2>(_: string)->int, }, ` +
-			`#B: <3>C{[=~"^[m-z]*?"]: <4>(_: string)->int, }, ` +
-			`#C: <5>C{C{[=~"^Q*$"]: <6>(_: string)->int}, C{(C{[=~"^[a-s]*$"]: <7>(_: string)->int} & C{[=~"^[m-z]*?"]: <8>(_: string)->int})}, }, ` +
-			`c: <9>C{C{[=~"^Q*$"]: <10>(_: string)->int}, C{(C{[=~"^[a-s]*$"]: <11>(_: string)->int} & C{[=~"^[m-z]*?"]: <12>(_: string)->int})}, QQ: 3}, ` +
-			`#D: <13>C{[=~"^[a-s]*$"]: <14>(_: string)->int, [=~"^[m-z]*?"]: <15>(_: string)->int, }, ` +
-			`d: <16>C{[=~"^[a-s]*$"]: <17>(_: string)->int, [=~"^[m-z]*?"]: <18>(_: string)->int, aaa: 4}}`,
-	}, {
-		in: `
-		#Task: {
-			{
-				op:          "pull"
-				tag:         *"latest" | string
-				refToTag:    tag
-				tagExpr: tag + "dd"
-				tagInString: "\(tag)"
-			} | {
-				op: "scratch"
-			}
-		}
-
-		foo: #Task & {"op": "pull"}
-		`,
-		out: `<0>{#Task: (<1>C{op: "pull", tag: (*"latest" | string), refToTag: <1>.tag, tagExpr: (<1>.tag + "dd"), tagInString: ""+<1>.tag+""} | <2>C{op: "scratch"}), foo: <3>C{op: "pull", tag: "latest", refToTag: "latest", tagExpr: "latestdd", tagInString: "latest"}}`,
-	}, {
-		in: `
-		t: {
-			#ok: *true | bool
-			if #ok {
-				x: int
-			}
-		}
-		s: t & {
-			#ok: false
-		}`,
-		out: `<0>{t: <1>{x: int, #ok: true}, s: <2>{#ok: false}}`,
-	}, {
-		desc: "cross-dependent comprehension",
-		// TODO(eval): fix: c should ultimately be allowed the struct. Current
-		// semantics require, however, that generated fields are not available
-		// for evaluation. This, however, does not have to hold, for closedness
-		// checks and allowing this would be more intuitive.
-		// Until that time, ensure that the behavior is at commutative.
-		in: `
-		#a: {
-			if b {
-				c: 4
-			}
-			b: bool
-		}
-		x: (#a & { b: true}) & {c: 4 }
-		y: x
-		`,
-		// c should not be allowed, as it would break commutativiy.
-		// See comments above.
-		out: `<0>{x: _|_(4:field "c" not allowed in closed struct), y: _|_(4:field "c" not allowed in closed struct), #a: <1>C{b: bool if <2>.b yield <3>C{c: 4}}}`,
-	}, {
-		desc: "optional expanded before lookup",
-		in: `
-		test: [ID=_]: {
-			name: ID
-		}
-
-		test: A: {
-			field1: "1"
-			field2: "2"
-		}
-
-		B: test.A & {}
-		`,
-		out: `<0>{test: <1>{[]: <2>(ID: string)-><3>{name: <2>.ID}, A: <4>{name: "A", field1: "1", field2: "2"}}, B: <5>{name: "A", field1: "1", field2: "2"}}`,
-	}, {
-		desc: "Issue #178",
-		in: `
-		import "encoding/csv"
-		import "encoding/hex"
-
-		foo: csv.Decode(data)
-		data: bytes
-
-		len: int
-		bar: hex.EncodedLen(len)
-		`,
-		out: `<0>{foo: <1>.Decode (<2>.data), data: bytes, len: int, bar: <3>.EncodedLen (<2>.len)}`,
-	}, {
-		// This resulted in an issue in an older version. Prevent regression.
-		desc: "comprehension and skipped field",
-		in: `
-		for key, value in {x: v: 1} {
-			"\(key)": {
-				v: *{for pod, _ in value.v {}} | {"\(value.v)": 2}
-				_p: 3
-			}
-		}
-		`,
-		out: `<0>{x: <1>{v: <2>{"1": 2}, _p: 3}}`,
-	}, {
-		desc: "non-structural direct cycles",
-		in: `
-		c1: {bar: baz: 2} & c1.bar
-		c2: {bar: 1} & c2.bar
-		`,
-		out: `<0>{` +
-			`c1: <1>{bar: <2>{baz: 2}, baz: 2}, ` +
-			`c2: _|_(conflicting values {bar: 1} and 1 (mismatched types struct and int))}`,
-	}, {
-		desc: "dont bind to string labels",
-		in: `
-			x: 1
-			y: {
-				"x": 2
-				z: x
-			}
-			`,
-		out: `<0>{x: 1, y: <1>{x: 2, z: 1}}`,
-	}, {
-		desc: "dont pass incomplete values to builtins",
-		in: `
-		import "encoding/json"
-
-		input: string
-		foo: json.Marshal(input)
-		`,
-		out: `<0>{input: string, foo: <1>.Marshal (<2>.input)}`,
-	}, {
-		desc: "alias reuse in nested scope",
-		in: `
-		#Foo: {
-			let X = or([ for k, _ in {} { k } ])
-			connection: [X]: X
-		}
-		#A: {
-			foo: "key"
-			let X = foo
-			a: foo: [X]: X
-		}
-		#B: {
-			foo: string
-			let X = foo
-			a: foo: [X]: X
-		}
-		b: #B & { foo: "key" }
-		`,
-		out: `<0>{` +
-			`#Foo: <1>C{connection: <2>C{[or ([ <3>for k, _ in <4>{} yield <3>.k ])]: <5>(_: string)->or ([ <3>for k, _ in <4>{} yield <3>.k ]), }}, ` +
-			`#A: <6>C{foo: "key", a: <7>C{foo: <8>C{["key"]: <9>(_: string)-><10>.foo, }}}, ` +
-			`#B: <11>C{foo: string, a: <12>C{foo: <13>C{[string]: <14>(_: string)-><15>.foo, }}}, ` +
-			`b: <16>C{foo: "key", a: <17>C{foo: <18>C{["key"]: <19>(_: string)-><20>.foo, }}}` +
-			`}`,
-	}, {
-		desc: "json Marshaling detects incomplete",
-		in: `
-		import "encoding/json"
-		a: json.Marshal({ a: string} )
-
-		foo: { a: 3, b: foo.c }
-		b: json.Marshal(foo)
-		`,
-		out: `<0>{` +
-			`a: <1>.Marshal (<2>{a: string}), ` +
-			`foo: <3>{a: 3, b: <4>.foo.c}, ` +
-			`b: <1>.Marshal (<4>.foo)}`,
-	}, {
-		desc: "detectIncompleteYAML",
-		in: `
-		package foobar
-
-		import yaml "encoding/yaml"
-
-		#Spec: {
-			_vars: {something: string}
-			data: {
-				#foo: {
-					use: _vars.something
-				}
-				baz:    yaml.Marshal(_vars.something)
-				foobar: yaml.Marshal(#foo)
-			}
-		}
-		Val: #Spec & {
-			_vars: something: "var-string"
-		}
-		`,
-		out: `<0>{#Spec: <1>C{_vars: <2>C{something: string}, data: <3>C{#foo: <4>C{use: string}, baz: <5>.Marshal (<6>._vars.something), foobar: <5>.Marshal (<7>.#foo)}}, Val: <8>C{_vars: <9>C{something: "var-string"}, data: <10>C{#foo: <11>C{use: "var-string"}, baz: "var-string\n", foobar: "use: var-string\n"}}}`,
-	}, {
-		desc: "detectIncompleteJSON",
-		in: `
-			package foobar
-	
-			import "encoding/json"
-		
-			#Spec: {
-				_vars: {something: string}
-				data: {
-					#foo: {
-						use: _vars.something
-					}
-					baz:    json.Marshal(_vars.something)
-					foobar: json.Marshal(#foo)
-				}
-			}
-			Val: #Spec & {
-				_vars: something: "var-string"
-			}
-			`,
-		out: `<0>{#Spec: <1>C{_vars: <2>C{something: string}, data: <3>C{#foo: <4>C{use: string}, baz: <5>.Marshal (<6>._vars.something), foobar: <5>.Marshal (<7>.#foo)}}, Val: <8>C{_vars: <9>C{something: "var-string"}, data: <10>C{#foo: <11>C{use: "var-string"}, baz: "\"var-string\"", foobar: "{\"use\":\"var-string\"}"}}}`,
-	}, {
-		desc: "issue312",
-		in: `
-		for x in [1] {
-			*close({}) | { [_]: null }
-		}
-		`,
-		out: `<0>{ <1>for _, x in [1] yield <2>{}, (*close (<3>{}) | <4>{[]: <5>(_: string)->null, })}`,
-	}, {
-		// TODO(eval): note that this behavior is incompatible with allowing
-		// non-struct as emit values. If we ever want to do this, we need to
-		// do it soon.
-		desc: "issue312",
-		in: `
-		y: *1 | {a: 2}
-		for x in [1] { y }
-		`,
-		out: `<0>{y: 1, a: 2}`,
-	}, {
-		desc: "issue318",
-		in: `
-		#T: {
-			arg: x: string
-			out1: "\(arg.x) \(arg.y)"
-			out2: "\(arg.y)"
-			vx: arg.x
-			vy: arg.y
-		}
-		`,
-		out: `<0>{` +
-			`#T: <1>C{` +
-			`arg: <2>C{x: string}, ` +
-			`out1: _|_(<3>.arg.y:undefined field "y"), ` +
-			`out2: _|_(<3>.arg.y:undefined field "y"), ` +
-			`vx: string, ` +
-			`vy: _|_(<3>.arg.y:undefined field "y")}}`,
-	}, {
-		desc: "issue314",
-		in: `
-		import (
-			"text/template"
-			"encoding/yaml"
-			"encoding/json"
-		)
-
-		x: {
-			s: "myname"
-			#T
-		}
-
-		#T: {
-			s: string
-			out: template.Execute("{{.s}}", {
-				"s": s
-			})
-		}
-
-		#V: {
-			s: string
-			out: json.Marshal({"s": s})
-		}
-
-		#U: {
-			s: string
-			out: yaml.Marshal({"s": s})
-		}`,
-		out: `<0>{` +
-			`x: <1>C{s: "myname", out: "myname"}, ` +
-			`#T: <2>C{s: string, out: <3>.Execute ("{{.s}}",<4>C{s: <5>.s})}, ` +
-			`#V: <6>C{s: string, out: <7>.Marshal (<8>C{s: <9>.s})}, ` +
-			`#U: <10>C{s: string, out: <11>.Marshal (<12>C{s: <13>.s})}}`,
-	}}
-	rewriteHelper(t, testCases, evalFull)
-}
-
 func TestX(t *testing.T) {
 	// Don't remove. For debugging.
 	in := `
@@ -3048,5 +29,34 @@
 	if strings.TrimSpace(in) == "" {
 		t.Skip()
 	}
-	rewriteHelper(t, []testCase{{in: in}}, evalFull)
+}
+
+// var traceOn = flag.Bool("debug", false, "enable tracing")
+
+// func compileFileWithErrors(t *testing.T, body string) (*context, *structLit, error) {
+// 	t.Helper()
+// 	ctx, inst, err := compileInstance(t, body)
+// 	return ctx, inst.root, err
+// }
+
+// func compileFile(t *testing.T, body string) (*context, *structLit) {
+// 	t.Helper()
+// 	ctx, inst, errs := compileInstance(t, body)
+// 	if errs != nil {
+// 		t.Fatal(errs)
+// 	}
+// 	return ctx, inst.root
+// }
+
+func compileInstance(t *testing.T, body string) (*context, *Instance, error) {
+	var r Runtime
+	inst, err := r.Compile("test", body)
+
+	if err != nil {
+		x := newInstance(newIndex(sharedIndex), nil, &adt.Vertex{})
+		ctx := x.newContext()
+		return ctx, x, err
+	}
+
+	return r.index().newContext(), inst, nil
 }
diff --git a/internal/legacy/cue/types.go b/internal/legacy/cue/types.go
index a5deb07..c3665c7 100644
--- a/internal/legacy/cue/types.go
+++ b/internal/legacy/cue/types.go
@@ -27,10 +27,17 @@
 	"github.com/cockroachdb/apd/v2"
 
 	"cuelang.org/go/cue/ast"
+	"cuelang.org/go/cue/ast/astutil"
 	"cuelang.org/go/cue/errors"
+	"cuelang.org/go/cue/format"
 	"cuelang.org/go/cue/token"
 	"cuelang.org/go/internal"
 	"cuelang.org/go/internal/core/adt"
+	"cuelang.org/go/internal/core/convert"
+	"cuelang.org/go/internal/core/eval"
+	"cuelang.org/go/internal/core/export"
+	"cuelang.org/go/internal/core/subsume"
+	"cuelang.org/go/internal/core/validate"
 )
 
 // Kind determines the underlying type of a Value.
@@ -71,17 +78,17 @@
 	// NumberKind represents any kind of number.
 	NumberKind = IntKind | FloatKind
 
-	TopKind = Kind(adt.TopKind)
+	TopKind = adt.TopKind
 )
 
 // An structValue represents a JSON object.
 //
 // TODO: remove
 type structValue struct {
-	ctx  *context
-	path *valueData
-	obj  *structLit
-	Arcs arcs
+	ctx      *context
+	v        Value
+	obj      *adt.Vertex
+	features []adt.Feature
 }
 
 // Len reports the number of fields in this struct.
@@ -89,14 +96,28 @@
 	if o.obj == nil {
 		return 0
 	}
-	return len(o.Arcs)
+	return len(o.features)
 }
 
 // At reports the key and value of the ith field, i < o.Len().
 func (o *structValue) At(i int) (key string, v Value) {
-	a := o.Arcs[i]
-	v = newChildValue(o, i)
-	return o.ctx.LabelStr(a.Label), v
+	f := o.features[i]
+	return o.ctx.LabelStr(f), newChildValue(o, i)
+}
+
+func (o *structValue) at(i int) (v *adt.Vertex, isOpt bool) {
+	f := o.features[i]
+	arc := o.obj.Lookup(f)
+	if arc == nil {
+		arc = &adt.Vertex{
+			Parent: o.v.v,
+			Label:  f,
+		}
+		o.obj.MatchAndInsert(o.ctx.opCtx, arc)
+		arc.Finalize(o.ctx.opCtx)
+		isOpt = true
+	}
+	return arc, isOpt
 }
 
 // Lookup reports the field for the given key. The returned Value is invalid
@@ -106,7 +127,7 @@
 	i := 0
 	len := o.Len()
 	for ; i < len; i++ {
-		if o.Arcs[i].Label == f {
+		if o.features[i] == f {
 			break
 		}
 	}
@@ -114,8 +135,7 @@
 		// TODO: better message.
 		ctx := o.ctx
 		x := ctx.mkErr(o.obj, codeNotExist, "value %q not found", key)
-		v := x.evalPartial(ctx)
-		return Value{ctx.index, &valueData{o.path.parent, 0, arc{Label: o.path.Label, Value: v, v: x}}}
+		return newErrValue(o.v, x)
 	}
 	return newChildValue(o, i)
 }
@@ -190,25 +210,32 @@
 // An Iterator iterates over values.
 //
 type Iterator struct {
-	val  Value
-	ctx  *context
-	iter iterAtter
-	len  int
-	p    int
-	cur  Value
-	f    label
+	val   Value
+	ctx   *context
+	arcs  []field
+	p     int
+	cur   Value
+	f     label
+	isOpt bool
+}
+
+type field struct {
+	arc        *adt.Vertex
+	isOptional bool
 }
 
 // Next advances the iterator to the next value and reports whether there was
 // any. It must be called before the first call to Value or Key.
 func (i *Iterator) Next() bool {
-	if i.p >= i.len {
+	if i.p >= len(i.arcs) {
 		i.cur = Value{}
 		return false
 	}
-	arc := i.iter.iterAt(i.ctx, i.p)
-	i.cur = i.val.makeChild(i.ctx, uint32(i.p), arc)
-	i.f = arc.Label
+	f := i.arcs[i.p]
+	f.arc.Finalize(i.ctx.opCtx)
+	i.cur = makeValue(i.val.idx, f.arc)
+	i.f = f.arc.Label
+	i.isOpt = f.isOptional
 	i.p++
 	return true
 }
@@ -219,6 +246,10 @@
 	return i.cur
 }
 
+func (i *Iterator) Feature() adt.Feature {
+	return i.f
+}
+
 // Label reports the label of the value if i iterates over struct fields and
 // "" otherwise.
 func (i *Iterator) Label() string {
@@ -235,12 +266,12 @@
 
 // IsOptional reports if a field is optional.
 func (i *Iterator) IsOptional() bool {
-	return i.cur.v.arc.optional
+	return i.isOpt
 }
 
 // IsDefinition reports if a field is a definition.
 func (i *Iterator) IsDefinition() bool {
-	return i.cur.v.arc.definition
+	return i.f.IsDef()
 }
 
 // marshalJSON iterates over the list and generates JSON output. HasNext
@@ -266,10 +297,11 @@
 
 func (v Value) getNum(k kind) (*numLit, errors.Error) {
 	v, _ = v.Default()
-	if err := v.checkKind(v.ctx(), k); err != nil {
+	ctx := v.ctx()
+	if err := v.checkKind(ctx, k); err != nil {
 		return nil, v.toErr(err)
 	}
-	n, _ := v.v.Value.(*numLit)
+	n, _ := v.eval(ctx).(*numLit)
 	return n, nil
 }
 
@@ -491,183 +523,111 @@
 	return f, nil
 }
 
-type valueData struct {
-	parent *valueData
-	index  uint32
-	arc
-}
+func (v Value) appendPath(a []string) []string {
+	for _, f := range v.v.Path() {
+		switch f.Typ() {
+		case adt.IntLabel:
+			a = append(a, strconv.FormatInt(int64(f.Index()), 10))
 
-// path returns the path of the value.
-func (v *valueData) appendPath(a []string, idx *index) ([]string, kind) {
-	var k kind
-	if v.parent != nil {
-		a, k = v.parent.appendPath(a, idx)
-	}
-	switch k {
-	case listKind:
-		a = append(a, strconv.FormatInt(int64(v.index), 10))
-	case structKind:
-		label := idx.LabelStr(v.arc.Label)
-		if f := v.arc.Label; !f.IsDef() && !f.IsHidden() {
-			if !ast.IsValidIdent(label) {
-				label = strconv.Quote(label)
+		case adt.StringLabel:
+			label := v.idx.LabelStr(f)
+			if !f.IsDef() && !f.IsHidden() {
+				if !ast.IsValidIdent(label) {
+					label = strconv.Quote(label)
+				}
 			}
+			a = append(a, label)
+		default:
+			a = append(a, f.SelectorString(v.idx.Index))
 		}
-		a = append(a, label)
 	}
-	return a, v.arc.Value.Kind()
+	return a
 }
 
 // Value holds any value, which may be a Boolean, Error, List, Null, Number,
 // Struct, or String.
 type Value struct {
 	idx *index
-	v   *valueData
+	v   *adt.Vertex
 }
 
 func newErrValue(v Value, b *bottom) Value {
-	ctx := v.ctx()
-	p := v.v
-	if p == nil {
-		return newValueRoot(ctx, b)
+	node := &adt.Vertex{Value: b}
+	if v.v != nil {
+		node.Label = v.v.Label
+		node.Parent = v.v.Parent
 	}
-	return Value{
-		ctx.index,
-		&valueData{p.parent, p.index, arc{
-			Label: p.arc.Label,
-			Value: b,
-			v:     b,
-		}},
+	node.UpdateStatus(adt.Finalized)
+	node.AddConjunct(adt.MakeConjunct(nil, b))
+	return makeValue(v.idx, node)
+}
+
+func newVertexRoot(ctx *context, x *adt.Vertex) Value {
+	if ctx.opCtx != nil {
+		// This is indicative of an zero Value. In some cases this is called
+		// with an error value.
+		x.Finalize(ctx.opCtx)
+	} else {
+		x.UpdateStatus(adt.Finalized)
 	}
+	return makeValue(ctx.index, x)
 }
 
 func newValueRoot(ctx *context, x value) Value {
-	v := x.evalPartial(ctx)
-	return Value{ctx.index, &valueData{nil, 0, arc{Value: v, v: x}}}
+	if n, ok := x.(*adt.Vertex); ok {
+		return newVertexRoot(ctx, n)
+	}
+	node := &adt.Vertex{}
+	node.AddConjunct(adt.MakeConjunct(nil, x))
+	return newVertexRoot(ctx, node)
 }
 
-func newChildValue(obj *structValue, i int) Value {
-	a := obj.Arcs[i]
-	for j, b := range obj.obj.Arcs {
-		if b.Label == a.Label {
-			a = obj.obj.iterAt(obj.ctx, j)
-			// TODO: adding more technical debt here. The evaluator should be
-			// rewritten.
-			x := obj.obj
-			ctx := obj.ctx
-			if x.optionals != nil {
-				name := ctx.LabelStr(x.Arcs[i].Label)
-				arg := &stringLit{x.baseValue, name, nil}
-
-				val, _ := x.optionals.constraint(ctx, arg)
-				if val != nil {
-					a.v = mkBin(ctx, x.Pos(), opUnify, a.v, val)
-				}
-			}
-			break
-		}
-	}
-
-	return Value{obj.ctx.index, &valueData{obj.path, uint32(i), a}}
+func newChildValue(o *structValue, i int) Value {
+	arc, _ := o.at(i)
+	return makeValue(o.v.idx, arc)
 }
 
 // Dereference reports the value v refers to if v is a reference or v itself
 // otherwise.
 func Dereference(v Value) Value {
-	if v.v == nil {
+	n := v.v
+	if n == nil || len(n.Conjuncts) != 1 {
+		return v
+	}
+
+	c := n.Conjuncts[0]
+	r, _ := c.Expr().(adt.Resolver)
+	if r == nil {
 		return v
 	}
 
 	ctx := v.ctx()
-	a, n := appendPath(ctx, make([]label, 0, 3), v.v.v)
-
-	if n == nil {
-		return v
-
+	n, b := ctx.opCtx.Resolve(c.Env, r)
+	if b != nil {
+		return newErrValue(v, b)
 	}
-
-	p := locateNode(v.v, n)
-
-	if p == nil {
-
-		imp := ctx.getImportFromNode(n.node)
-		if imp == nil {
-			// TODO(eval): embedded structs are currently represented at the
-			// same level as the enclosing struct. This means that the parent
-			// of an embedded struct skips the struct in which it is embedded.
-			// Treat embedded structs as "anonymous" fields.
-			// See TestPathCorrection.
-			return v
-		}
-		p = &valueData{arc: arc{v: imp.rootValue, Value: imp.rootStruct}}
-	}
-
-	cached := p.Value
-	if cached == nil {
-		cached = p.v.evalPartial(ctx)
-	}
-	s := cached.(*structLit)
-	for _, f := range a {
-		a := s.Lookup(ctx, f)
-		if a.v == nil {
-			return Value{}
-		}
-		p = &valueData{parent: p, arc: a} // index
-		s, _ = a.Value.(*structLit)
-	}
-
-	v = Value{v.idx, p}
-	return v
+	return makeValue(v.idx, n)
 }
 
-func appendPath(ctx *context, a []label, v value) (path []label, n *nodeRef) {
-	switch x := v.(type) {
-	case *selectorExpr:
-		a, n = appendPath(ctx, a, x.X)
-		if n == nil {
-			return nil, nil
-		}
-
-		a = append(a, x.Sel)
-
-	case *indexExpr:
-		e := x.Index.evalPartial(ctx)
-		s, ok := e.(*stringLit)
-		if !ok {
-			return nil, nil
-		}
-
-		a, n = appendPath(ctx, a, x.X)
-		if n == nil {
-			return nil, nil
-		}
-
-		a = append(a, ctx.Label(s.Str, false))
-
-	case *nodeRef:
-		n = x
+func makeValue(idx *index, v *adt.Vertex) Value {
+	if v.Status() == 0 || v.Value == nil {
+		panic(fmt.Sprintf("not properly initialized (state: %v, value: %T)",
+			v.Status(), v.Value))
 	}
-	return a, n
+	return Value{idx, v}
 }
 
-func remakeValue(base Value, v value) Value {
-	p := base.v
-	if n, ok := v.(*nodeRef); ok {
-		if q := locateNode(p, n); q != nil {
-			p = q
-		}
-	}
-	path := *p
-	path.v = v
-	path.Value = v.evalPartial(base.ctx())
-	return Value{base.idx, &path}
+func remakeValue(base Value, env *adt.Environment, v value) Value {
+	n := &adt.Vertex{Parent: base.v.Parent, Label: base.v.Label}
+	n.AddConjunct(adt.MakeConjunct(env, v))
+	n = base.ctx().manifest(n)
+	return makeValue(base.idx, n)
 }
 
-func locateNode(p *valueData, n *nodeRef) *valueData {
-	// the parent must exist.
-	for ; p != nil && p.Value != n.node.(value); p = p.parent {
-	}
-	return p
+func remakeFinal(base Value, env *adt.Environment, v adt.Value) Value {
+	n := &adt.Vertex{Parent: base.v.Parent, Label: base.v.Label, Value: v}
+	n.UpdateStatus(adt.Finalized)
+	return makeValue(base.idx, n)
 }
 
 func (v Value) ctx() *context {
@@ -675,41 +635,8 @@
 }
 
 func (v Value) makeChild(ctx *context, i uint32, a arc) Value {
-	return Value{v.idx, &valueData{v.v, i, a}}
-}
-
-func (v Value) makeElem(x value) Value {
-	v, e := v.evalFull(x)
-	return Value{v.idx, &valueData{v.v, 0, arc{
-		optional: true,
-		v:        x,
-		Value:    e,
-	}}}
-}
-
-func (v Value) eval(ctx *context) evaluated {
-	if v.v == nil || v.v.Value == nil {
-		panic("undefined value")
-	}
-	return ctx.manifest(v.v.Value)
-}
-
-func (v Value) evalFull(u value) (Value, evaluated) {
-	ctx := v.ctx()
-	x := u.evalPartial(ctx)
-	if st, ok := x.(*structLit); ok {
-		var err *bottom
-		x, err = st.expandFields(ctx)
-		if err != nil {
-			x = err
-		}
-		if x != st {
-			p := *v.v
-			p.Value = x
-			v.v = &p
-		}
-	}
-	return v, x
+	a.Parent = v.v
+	return makeValue(v.idx, a)
 }
 
 // Eval resolves the references of a value and returns the result.
@@ -718,7 +645,12 @@
 	if v.v == nil {
 		return v
 	}
-	return remakeValue(v.evalFull(v.v.v))
+	x := v.v
+	// x = eval.FinalizeValue(v.idx.Runtime, v.v)
+	// x.Finalize(v.ctx().opCtx)
+	x = x.ToDataSingle()
+	return makeValue(v.idx, x)
+	// return remakeValue(v, nil, ctx.value(x))
 }
 
 // Default reports the default value and whether it existed. It returns the
@@ -727,12 +659,139 @@
 	if v.v == nil {
 		return v, false
 	}
-	v, u := v.evalFull(v.v.v)
-	x := v.ctx().manifest(u)
-	if x != u {
-		return remakeValue(v, x), true
+
+	d := v.v.Default()
+	if d == v.v {
+		return v, false
 	}
-	return v, false
+	return makeValue(v.idx, d), true
+
+	// d, ok := v.v.Value.(*adt.Disjunction)
+	// if !ok {
+	// 	return v, false
+	// }
+
+	// var w *adt.Vertex
+
+	// switch d.NumDefaults {
+	// case 0:
+	// 	return v, false
+
+	// case 1:
+	// 	w = d.Values[0]
+
+	// default:
+	// 	x := *v.v
+	// 	x.Value = &adt.Disjunction{
+	// 		Src:         d.Src,
+	// 		Values:      d.Values[:d.NumDefaults],
+	// 		NumDefaults: 0,
+	// 	}
+	// 	w = &x
+	// }
+
+	// w.Conjuncts = nil
+	// for _, c := range v.v.Conjuncts {
+	// 	// TODO: preserve field information.
+	// 	expr, _ := stripNonDefaults(c.Expr())
+	// 	w.AddConjunct(adt.MakeConjunct(c.Env, expr))
+	// }
+
+	// return makeValue(v.idx, w), true
+
+	// if !stripped {
+	// 	return v, false
+	// }
+
+	// n := *v.v
+	// n.Conjuncts = conjuncts
+	// return Value{v.idx, &n}, true
+
+	// isDefault := false
+	// for _, c := range v.v.Conjuncts {
+	// 	if hasDisjunction(c.Expr()) {
+	// 		isDefault = true
+	// 		break
+	// 	}
+	// }
+
+	// if !isDefault {
+	// 	return v, false
+	// }
+
+	// TODO: record expanded disjunctions in output.
+	// - Rename Disjunction to DisjunctionExpr
+	// - Introduce Disjuncts with Values.
+	// - In Expr introduce Star
+	// - Don't pick default by default?
+
+	// Evaluate the value.
+	// 	x := eval.FinalizeValue(v.idx.Runtime, v.v)
+	// 	if b, _ := x.Value.(*adt.Bottom); b != nil { // && b.IsIncomplete() {
+	// 		return v, false
+	// 	}
+	// 	// Finalize and return here.
+	// 	return Value{v.idx, x}, isDefault
+}
+
+// TODO: this should go: record preexpanded disjunctions in Vertex.
+func hasDisjunction(expr adt.Expr) bool {
+	switch x := expr.(type) {
+	case *adt.DisjunctionExpr:
+		return true
+	case *adt.Conjunction:
+		for _, v := range x.Values {
+			if hasDisjunction(v) {
+				return true
+			}
+		}
+	case *adt.BinaryExpr:
+		switch x.Op {
+		case adt.OrOp:
+			return true
+		case adt.AndOp:
+			return hasDisjunction(x.X) || hasDisjunction(x.Y)
+		}
+	}
+	return false
+}
+
+// TODO: this should go: record preexpanded disjunctions in Vertex.
+func stripNonDefaults(expr adt.Expr) (r adt.Expr, stripped bool) {
+	switch x := expr.(type) {
+	case *adt.DisjunctionExpr:
+		if !x.HasDefaults {
+			return x, false
+		}
+		d := *x
+		d.Values = []adt.Disjunct{}
+		for _, v := range x.Values {
+			if v.Default {
+				d.Values = append(d.Values, v)
+			}
+		}
+		if len(d.Values) == 1 {
+			return d.Values[0].Val, true
+		}
+		return &d, true
+
+	case *adt.BinaryExpr:
+		if x.Op != adt.AndOp {
+			return x, false
+		}
+		a, sa := stripNonDefaults(x.X)
+		b, sb := stripNonDefaults(x.Y)
+		if sa || sb {
+			bin := *x
+			bin.X = a
+			bin.Y = b
+			return &bin, true
+		}
+		return x, false
+
+	default:
+		return x, false
+	}
 }
 
 // Label reports he label used to obtain this value from the enclosing struct.
@@ -740,7 +799,7 @@
 // TODO: get rid of this somehow. Probably by including a FieldInfo struct
 // or the like.
 func (v Value) Label() (string, bool) {
-	if v.v.Label == 0 {
+	if v.v == nil || v.v.Label == 0 {
 		return "", false
 	}
 	return v.idx.LabelStr(v.v.Label), true
@@ -754,33 +813,13 @@
 		return BottomKind
 	}
 	c := v.v.Value
-	if c == nil {
-		c = v.v.v.evalPartial(v.ctx())
+	if !adt.IsConcrete(c) {
+		return BottomKind
 	}
-	k := c.Kind()
-	if k.isGround() {
-		switch {
-		case k.isAnyOf(nullKind):
-			return NullKind
-		case k.isAnyOf(boolKind):
-			return BoolKind
-		case k&numKind == (intKind):
-			return IntKind
-		case k&numKind == (floatKind):
-			return FloatKind
-		case k.isAnyOf(numKind):
-			return NumberKind
-		case k.isAnyOf(bytesKind):
-			return BytesKind
-		case k.isAnyOf(stringKind):
-			return StringKind
-		case k.isAnyOf(structKind):
-			return StructKind
-		case k.isAnyOf(listKind):
-			return ListKind
-		}
+	if v.IncompleteKind() == adt.ListKind && !v.IsClosed() {
+		return BottomKind
 	}
-	return BottomKind
+	return c.Kind()
 }
 
 // IncompleteKind returns a mask of all kinds that this value may be.
@@ -788,40 +827,7 @@
 	if v.v == nil {
 		return BottomKind
 	}
-	var k kind
-	x := v.v.v.evalPartial(v.ctx())
-	switch x := convertBuiltin(x).(type) {
-	case *builtin:
-		k = x.representedKind()
-	case *customValidator:
-		k = x.Builtin.Params[0]
-	default:
-		k = x.Kind()
-	}
-	vk := BottomKind // Everything is a bottom kind.
-	for i := kind(1); i < nonGround; i <<= 1 {
-		if k&i != 0 {
-			switch i {
-			case nullKind:
-				vk |= NullKind
-			case boolKind:
-				vk |= BoolKind
-			case intKind:
-				vk |= IntKind
-			case floatKind:
-				vk |= FloatKind
-			case stringKind:
-				vk |= StringKind
-			case bytesKind:
-				vk |= BytesKind
-			case structKind:
-				vk |= StructKind
-			case listKind:
-				vk |= ListKind
-			}
-		}
-	}
-	return vk
+	return v.v.Kind()
 }
 
 // MarshalJSON marshalls this value into valid JSON.
@@ -840,6 +846,14 @@
 	}
 	ctx := v.idx.newContext()
 	x := v.eval(ctx)
+
+	if _, ok := x.(adt.Resolver); ok {
+		return nil, marshalErrf(v, x, codeIncomplete, "value %q contains unresolved references", ctx.str(x))
+	}
+	if !adt.IsConcrete(x) {
+		return nil, marshalErrf(v, x, codeIncomplete, "cannot convert incomplete value %q to JSON", ctx.str(x))
+	}
+
 	// TODO: implement marshalles in value.
 	switch k := x.Kind(); k {
 	case nullKind:
@@ -847,7 +861,9 @@
 	case boolKind:
 		return json.Marshal(x.(*boolLit).B)
 	case intKind, floatKind, numKind:
-		return x.(*numLit).X.MarshalText()
+		b, err := x.(*numLit).X.MarshalText()
+		b = bytes.TrimLeft(b, "+")
+		return b, err
 	case stringKind:
 		return json.Marshal(x.(*stringLit).Str)
 	case bytesKind:
@@ -857,15 +873,6 @@
 		return marshalList(&i)
 	case structKind:
 		obj, err := v.structValData(ctx)
-		st := obj.obj
-		if len(st.comprehensions) > 0 {
-			// This should always evaluate to incomplete. However, fall back
-			// to a bad error message, rather than crashing, in case it doesn't.
-			if err, ok := st.comprehensions[0].comp.evalPartial(ctx).(*bottom); ok {
-				return nil, toMarshalErr(v, err)
-			}
-		}
-
 		if err != nil {
 			return nil, toMarshalErr(v, err)
 		}
@@ -873,12 +880,6 @@
 	case bottomKind:
 		return nil, toMarshalErr(v, x.(*bottom))
 	default:
-		if k.hasReferences() {
-			return nil, marshalErrf(v, x, codeIncomplete, "value %q contains unresolved references", ctx.str(x))
-		}
-		if !k.isGround() {
-			return nil, marshalErrf(v, x, codeIncomplete, "cannot convert incomplete value %q to JSON", ctx.str(x))
-		}
 		return nil, marshalErrf(v, x, 0, "cannot convert value %q of type %T to JSON", ctx.str(x), x)
 	}
 }
@@ -889,21 +890,57 @@
 	// TODO: the default should ideally be simplified representation that
 	// exactly represents the value. The latter can currently only be
 	// ensured with Raw().
-	if v.v == nil || v.v.Value == nil {
+	if v.v == nil {
 		return nil
 	}
-	ctx := v.ctx()
-	o := getOptions(opts)
-	var inst *Instance
-	if !o.final && !o.concrete {
-		inst = v.instance()
+	var o options = getOptions(opts)
+	// var inst *Instance
+
+	p := export.Profile{
+		Simplify:        !o.raw,
+		ShowOptional:    !o.omitOptional && !o.concrete,
+		ShowDefinitions: !o.omitDefinitions && !o.concrete,
+		ShowHidden:      !o.omitHidden && !o.concrete,
+		ShowAttributes:  !o.omitAttrs,
+		ShowDocs:        o.docs,
 	}
-	if o.raw {
-		n, _ := export(ctx, inst, v.v.v, o)
-		return n
+
+	// var expr ast.Expr
+	var err error
+	var f *ast.File
+	if o.concrete || o.final {
+		// inst = v.instance()
+		var expr ast.Expr
+		expr, err = p.Value(v.idx.Runtime, v.v)
+		if err != nil {
+			return nil
+		}
+
+		// This introduces gratuitous unshadowing!
+		f, err = astutil.ToFile(expr)
+		if err != nil {
+			return nil
+		}
+		// return expr
+	} else {
+		f, err = p.Def(v.idx.Runtime, v.v)
+		if err != nil {
+			panic(err)
+		}
 	}
-	n, _ := export(ctx, inst, v.v.Value, o)
-	return n
+
+	if d := internal.Imports(f); len(d) == 0 {
+		if len(f.Decls) == 1 {
+			if e, ok := f.Decls[0].(*ast.EmbedDecl); ok {
+				return e.Expr
+			}
+		}
+		return &ast.StructLit{
+			Elts: f.Decls,
+		}
+	}
+
+	return f
 }
 
 // Decode initializes x with Value v. If x is a struct, it will validate the
@@ -928,7 +965,7 @@
 	if v.v == nil {
 		return nil
 	}
-	return v.v.docs.appendDocs(nil)
+	return export.ExtractDoc(v.v)
 }
 
 // Split returns a list of values from which v originated such that
@@ -942,27 +979,9 @@
 	if v.v == nil {
 		return nil
 	}
-	ctx := v.ctx()
 	a := []Value{}
-	for _, x := range separate(v.v.v) {
-		path := *v.v
-		path.Value = x.evalPartial(ctx)
-		path.v = x
-		a = append(a, Value{v.idx, &path})
-	}
-	return a
-}
-
-func separate(v value) (a []value) {
-	c := v.computed()
-	if c == nil || (c.op != opUnify && c.op != opUnifyUnchecked) {
-		return []value{v}
-	}
-	if c.x != nil {
-		a = append(a, separate(c.x)...)
-	}
-	if c.y != nil {
-		a = append(a, separate(c.y)...)
+	for _, x := range v.v.Conjuncts {
+		a = append(a, remakeValue(v, x.Env, x.Expr()))
 	}
 	return a
 }
@@ -975,7 +994,10 @@
 	if v.v == nil {
 		return nil
 	}
-	return v.v.v.Source()
+	if len(v.v.Conjuncts) == 1 {
+		return v.v.Conjuncts[0].Source()
+	}
+	return v.v.Value.Source()
 }
 
 // Err returns the error represented by v or nil v is not an error.
@@ -1000,19 +1022,10 @@
 // IsClosed reports whether a list of struct is closed. It reports false when
 // when the value is not a list or struct.
 func (v Value) IsClosed() bool {
-	switch v.Kind() {
-	case StructKind:
-		if st, ok := v.v.val().(*structLit); ok {
-			return st.closeStatus.shouldClose()
-		}
-	case ListKind:
-		if l, ok := v.v.val().(*list); ok {
-			if n, ok := l.len.(*numLit); ok {
-				return n.intValue(v.ctx()) == len(l.elem.Arcs)
-			}
-		}
+	if v.v == nil {
+		return false
 	}
-	return false
+	return v.v.IsClosed(v.ctx().opCtx)
 }
 
 // IsConcrete reports whether the current value is a concrete scalar value
@@ -1023,35 +1036,32 @@
 	if v.v == nil {
 		return false // any is neither concrete, not a list or struct.
 	}
-	x := v.v.v.evalPartial(v.ctx())
-
-	// Errors marked as incomplete are treated as not complete.
-	if isIncomplete(x) {
+	if b, ok := v.v.Value.(*adt.Bottom); ok {
+		return !b.IsIncomplete()
+	}
+	if !adt.IsConcrete(v.v) {
 		return false
 	}
-	// Other errors are considered ground.
-	return x.Kind().isConcrete()
+	if v.IncompleteKind() == adt.ListKind && !v.IsClosed() {
+		return false
+	}
+	return true
 }
 
-// Deprecated: IsIncomplete
-//
-// It indicates that the value cannot be fully evaluated due to
-// insufficient information.
-func (v Value) IsIncomplete() bool {
-	// TODO: remove
-	x := v.eval(v.ctx())
-	if !x.Kind().isConcrete() {
-		return true
-	}
-	return isIncomplete(x)
-}
+// // Deprecated: IsIncomplete
+// //
+// // It indicates that the value cannot be fully evaluated due to
+// // insufficient information.
+// func (v Value) IsIncomplete() bool {
+// 	panic("deprecated")
+// }
 
 // Exists reports whether this value existed in the configuration.
 func (v Value) Exists() bool {
 	if v.v == nil {
 		return false
 	}
-	return exists(v.eval(v.ctx()))
+	return exists(v.v.Value)
 }
 
 func (v Value) checkKind(ctx *context, want kind) *bottom {
@@ -1063,22 +1073,23 @@
 	if b, ok := x.(*bottom); ok {
 		return b
 	}
-	got := x.Kind()
+	k := x.Kind()
 	if want != bottomKind {
-		if got&want&concreteKind == bottomKind {
+		if k&want == bottomKind {
 			return ctx.mkErr(x, "cannot use value %v (type %s) as %s",
-				v.ctx().str(x), got, want)
+				ctx.opCtx.Str(x), k, want)
 		}
-		if !got.isGround() {
-			return ctx.mkErr(x, codeIncomplete,
-				"non-concrete value %v", got)
+		if !adt.IsConcrete(x) {
+			return ctx.mkErr(x, codeIncomplete, "non-concrete value %v", k)
 		}
 	}
 	return nil
 }
 
 func makeInt(v Value, x int64) Value {
-	return remakeValue(v, newInt(v.v.v.base(), base10).setInt64(x))
+	n := &adt.Num{K: intKind}
+	n.X.SetInt64(int64(x))
+	return remakeFinal(v, nil, n)
 }
 
 // Len returns the number of items of the underlying value.
@@ -1086,17 +1097,35 @@
 // number of fields, for bytes the number of bytes.
 func (v Value) Len() Value {
 	if v.v != nil {
-		switch x := v.v.v.evalPartial(v.ctx()).(type) {
-		case *list:
-			return remakeValue(v, x.len.evalPartial(v.ctx()))
+		switch x := v.eval(v.ctx()).(type) {
+		case *adt.Vertex:
+			if x.IsList() {
+				ctx := v.ctx()
+				n := &adt.Num{K: intKind}
+				n.X.SetInt64(int64(len(x.Elems())))
+				if x.IsClosed(ctx.opCtx) {
+					return remakeFinal(v, nil, n)
+				}
+				// Note: this HAS to be a Conjunction value and cannot be
+				// an adt.BinaryExpr, as the expressions would be considered
+				// to be self-contained and unresolvable when evaluated
+				// (can never become concrete).
+				c := &adt.Conjunction{Values: []adt.Value{
+					&adt.BasicType{K: adt.IntKind},
+					&adt.BoundValue{Op: adt.GreaterEqualOp, Value: n},
+				}}
+				return remakeFinal(v, nil, c)
+
+			}
 		case *bytesLit:
-			return makeInt(v, int64(x.len()))
+			return makeInt(v, int64(len(x.B)))
 		case *stringLit:
-			return makeInt(v, int64(x.len()))
+			return makeInt(v, int64(len([]rune(x.Str))))
 		}
 	}
 	const msg = "len not supported for type %v"
-	return remakeValue(v, v.ctx().mkErr(v.v.v, msg, v.Kind()))
+	return remakeValue(v, nil, v.ctx().mkErr(v.v, msg, v.Kind()))
+
 }
 
 // Elem returns the value of undefined element types of lists and structs.
@@ -1104,51 +1133,51 @@
 	if v.v == nil {
 		return Value{}, false
 	}
-	ctx := v.ctx()
-	switch x := v.v.Value.(type) {
-	case *structLit:
-		t, _ := x.optionals.constraint(ctx, nil)
-		if t == nil {
-			break
-		}
-		return v.makeElem(t), true
-	case *list:
-		return v.makeElem(x.typ), true
+	ctx := v.ctx().opCtx
+	x := &adt.Vertex{
+		Parent: v.v,
+		Label:  0,
 	}
-	return Value{}, false
+	v.v.Finalize(ctx)
+	v.v.MatchAndInsert(ctx, x)
+	if len(x.Conjuncts) == 0 {
+		return Value{}, false
+	}
+	x.Finalize(ctx)
+	return makeValue(v.idx, x), true
 }
 
-// BulkOptionals returns all bulk optional fields as key-value pairs.
-// See also Elem and Template.
-func (v Value) BulkOptionals() [][2]Value {
-	x, ok := v.v.Value.(*structLit)
-	if !ok {
-		return nil
-	}
-	return v.appendBulk(nil, x.optionals)
-}
+// // BulkOptionals returns all bulk optional fields as key-value pairs.
+// // See also Elem and Template.
+// func (v Value) BulkOptionals() [][2]Value {
+// 	x, ok := v.path.cache.(*structLit)
+// 	if !ok {
+// 		return nil
+// 	}
+// 	return v.appendBulk(nil, x.optionals)
+// }
 
-func (v Value) appendBulk(a [][2]Value, x *optionals) [][2]Value {
-	if x == nil {
-		return a
-	}
-	a = v.appendBulk(a, x.left)
-	a = v.appendBulk(a, x.right)
-	for _, set := range x.fields {
-		if set.key != nil {
-			ctx := v.ctx()
-			fn, ok := ctx.manifest(set.value).(*lambdaExpr)
-			if !ok {
-				// create error
-				continue
-			}
-			x := fn.call(ctx, set.value, &basicType{K: stringKind})
+// func (v Value) appendBulk(a [][2]Value, x *optionals) [][2]Value {
+// 	if x == nil {
+// 		return a
+// 	}
+// 	a = v.appendBulk(a, x.left)
+// 	a = v.appendBulk(a, x.right)
+// 	for _, set := range x.fields {
+// 		if set.key != nil {
+// 			ctx := v.ctx()
+// 			fn, ok := ctx.manifest(set.value).(*lambdaExpr)
+// 			if !ok {
+// 				// create error
+// 				continue
+// 			}
+// 			x := fn.call(ctx, set.value, &basicType{K: stringKind})
 
-			a = append(a, [2]Value{v.makeElem(set.key), v.makeElem(x)})
-		}
-	}
-	return a
-}
+// 			a = append(a, [2]Value{v.makeElem(set.key), v.makeElem(x)})
+// 		}
+// 	}
+// 	return a
+// }
 
 // List creates an iterator over the values of a list or reports an error if
 // v is not a list.
@@ -1158,8 +1187,13 @@
 	if err := v.checkKind(ctx, listKind); err != nil {
 		return Iterator{ctx: ctx}, v.toErr(err)
 	}
-	l := v.eval(ctx).(*list)
-	return Iterator{ctx: ctx, val: v, iter: l, len: len(l.elem.Arcs)}, nil
+	arcs := []field{}
+	for _, a := range v.v.Elems() {
+		if a.Label.IsInt() {
+			arcs = append(arcs, field{arc: a})
+		}
+	}
+	return Iterator{ctx: ctx, val: v, arcs: arcs}, nil
 }
 
 // Null reports an error if v is not null.
@@ -1243,97 +1277,78 @@
 
 // structVal returns an structVal or an error if v is not a struct.
 func (v Value) structValOpts(ctx *context, o options) (structValue, *bottom) {
-	v, _ = v.Default() // TODO: remove?
+	v, _ = v.Default()
 
-	obj, path, err := v.getStruct()
+	obj, err := v.getStruct()
 	if err != nil {
 		return structValue{}, err
 	}
 
-	// check if any fields can be omitted
-	needFilter := false
-	if o.omitHidden || o.omitOptional || o.omitDefinitions {
-		f := label(0)
-		for _, a := range obj.Arcs {
-			f |= a.Label
-			if a.optional && o.omitOptional {
-				needFilter = true
-				break
-			}
-			if a.definition && (o.omitDefinitions || o.concrete) {
-				needFilter = true
-				break
-			}
-		}
-		needFilter = needFilter || f.IsHidden()
-	}
+	features := export.VertexFeatures(obj)
 
-	if needFilter {
-		arcs := make([]arc, len(obj.Arcs))
-		k := 0
-		for _, a := range obj.Arcs {
-			if a.definition && (o.omitDefinitions || o.concrete) {
-				continue
-			}
-			if a.Label.IsHidden() && o.omitHidden {
-				continue
-			}
-			if o.omitOptional && a.optional {
-				continue
-			}
-			arcs[k] = a
-			k++
+	k := 0
+	for _, f := range features {
+		if f.IsDef() && (o.omitDefinitions || o.concrete) {
+			continue
 		}
-		arcs = arcs[:k]
-		return structValue{ctx, path, obj, arcs}, nil
+		if f.IsHidden() && o.omitHidden {
+			continue
+		}
+		if arc := obj.Lookup(f); arc == nil {
+			if o.omitOptional {
+				continue
+			}
+			// ensure it really exists.
+			v := adt.Vertex{
+				Parent: obj,
+				Label:  f,
+			}
+			obj.MatchAndInsert(ctx.opCtx, &v)
+			if len(v.Conjuncts) == 0 {
+				continue
+			}
+		}
+		features[k] = f
+		k++
 	}
-	return structValue{ctx, path, obj, obj.Arcs}, nil
+	features = features[:k]
+	return structValue{ctx, v, obj, features}, nil
 }
 
 // Struct returns the underlying struct of a value or an error if the value
 // is not a struct.
 func (v Value) Struct() (*Struct, error) {
-	obj, path, err := v.getStruct()
+	ctx := v.ctx()
+	obj, err := v.structValOpts(ctx, options{})
 	if err != nil {
 		return nil, v.toErr(err)
 	}
-	return &Struct{Value{v.idx, path}, obj}, nil
+	return &Struct{obj}, nil
 }
 
-func (v Value) getStruct() (*structLit, *valueData, *bottom) {
+func (v Value) getStruct() (*structLit, *bottom) {
 	ctx := v.ctx()
 	if err := v.checkKind(ctx, structKind); err != nil {
-		return nil, nil, err
+		if !err.HasRecursive ||
+			err.Value == nil ||
+			err.Value.Kind() != StructKind {
+			return nil, err
+		}
 	}
-	orig := v.eval(ctx).(*structLit)
-
-	// TODO: This is expansion appropriate?
-	obj, err := orig.expandFields(ctx)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	path := v.v
-	if obj != orig {
-		p := *path
-		p.arc.Value = obj
-		path = &p
-	}
-
-	return obj, path, nil
+	return v.v, nil
 }
 
 // Struct represents a CUE struct value.
 type Struct struct {
-	v Value
-	s *structLit
+	structValue
 }
 
 // FieldInfo contains information about a struct field.
 type FieldInfo struct {
-	Name  string
-	Pos   int
-	Value Value
+	Selector string
+	Name     string // Deprecated: use Selector
+	Pos      int
+	Value    Value
 
 	IsDefinition bool
 	IsOptional   bool
@@ -1341,31 +1356,18 @@
 }
 
 func (s *Struct) Len() int {
-	return len(s.s.Arcs)
+	return s.structValue.Len()
 }
 
 // field reports information about the ith field, i < o.Len().
 func (s *Struct) Field(i int) FieldInfo {
+	a, opt := s.at(i)
 	ctx := s.v.ctx()
-	a := s.s.Arcs[i]
-	a.Value = s.s.at(ctx, i)
 
-	// TODO: adding more technical debt here. The evaluator should be
-	// rewritten.
-	x := s.s
-	if x.optionals != nil {
-		name := ctx.LabelStr(x.Arcs[i].Label)
-		arg := &stringLit{x.baseValue, name, nil}
-
-		val, _ := x.optionals.constraint(ctx, arg)
-		if val != nil {
-			a.v = mkBin(ctx, x.Pos(), opUnify, a.v, val)
-		}
-	}
-
-	v := Value{ctx.index, &valueData{s.v.v, uint32(i), a}}
-	str := ctx.LabelStr(a.Label)
-	return FieldInfo{str, i, v, a.definition, a.optional, a.Label.IsHidden()}
+	v := makeValue(s.v.idx, a)
+	name := ctx.LabelStr(a.Label)
+	str := a.Label.SelectorString(ctx.opCtx)
+	return FieldInfo{str, name, i, v, a.Label.IsDef(), opt, a.Label.IsHidden()}
 }
 
 // FieldByName looks up a field for the given name. If isIdent is true, it will
@@ -1373,8 +1375,8 @@
 // it interprets name as an arbitrary string for a regular field.
 func (s *Struct) FieldByName(name string, isIdent bool) (FieldInfo, error) {
 	f := s.v.ctx().Label(name, isIdent)
-	for i, a := range s.s.Arcs {
-		if a.Label == f {
+	for i, a := range s.features {
+		if a == f {
 			return s.Field(i), nil
 		}
 	}
@@ -1397,16 +1399,13 @@
 	if err != nil {
 		return &Iterator{ctx: ctx}, v.toErr(err)
 	}
-	n := &structLit{
-		obj.obj.baseValue,   // baseValue
-		obj.obj.emit,        // emit
-		obj.obj.optionals,   // template
-		obj.obj.closeStatus, // closeStatus
-		nil,                 // comprehensions
-		obj.Arcs,            // arcs
-		nil,                 // attributes
+
+	arcs := []field{}
+	for i := range obj.features {
+		arc, isOpt := obj.at(i)
+		arcs = append(arcs, field{arc: arc, isOptional: isOpt})
 	}
-	return &Iterator{ctx: ctx, val: v, iter: n, len: len(n.Arcs)}, nil
+	return &Iterator{ctx: ctx, val: v, arcs: arcs}, nil
 }
 
 // Lookup reports the value at a path starting from v. The empty path returns v
@@ -1440,9 +1439,9 @@
 	}
 
 	f := v.ctx().Label(name, true)
-	for i, a := range o.Arcs {
-		if a.Label == f {
-			if f.IsHidden() || !a.definition || a.optional {
+	for i, a := range o.features {
+		if a == f {
+			if f.IsHidden() || !f.IsDef() { // optional not possible for now
 				break
 			}
 			return newChildValue(&o, i)
@@ -1455,8 +1454,7 @@
 			return alt
 		}
 	}
-	return newErrValue(v, ctx.mkErr(v.v.v,
-		"definition %q not found", name))
+	return newErrValue(v, ctx.mkErr(v.v, "definition %q not found", name))
 }
 
 var errNotFound = errors.Newf(token.NoPos, "field not found")
@@ -1516,16 +1514,15 @@
 		return v
 	}
 	ctx := v.ctx()
-	root := v.v.val()
 	for i := len(path) - 1; i >= 0; i-- {
 		x = map[string]interface{}{path[i]: x}
 	}
-	value := convertVal(ctx, root, true, x)
-	a := v.v.arc
-	a.v = mkBin(ctx, v.Pos(), opUnify, root, value)
-	a.Value = a.v.evalPartial(ctx)
-	// TODO: validate recursively?
-	return Value{v.idx, &valueData{v.v.parent, v.v.index, a}}
+	var value = convert.GoValueToExpr(ctx.opCtx, true, x)
+	n := &adt.Vertex{Parent: v.v.Parent}
+	n.AddConjunct(adt.MakeConjunct(nil, value))
+	n.Finalize(ctx.opCtx)
+	w := makeValue(v.idx, n)
+	return v.Unify(w)
 }
 
 // Template returns a function that represents the template definition for a
@@ -1536,23 +1533,18 @@
 // given its name.
 func (v Value) Template() func(label string) Value {
 	// TODO: rename to optional.
-	if v.v == nil {
+	if v.v == nil || v.v.Closed == nil {
 		return nil
 	}
 
-	ctx := v.ctx()
-	x, ok := v.v.Value.(*structLit)
-	if !ok || x.optionals.isEmpty() {
-		return nil
-	}
-
+	parent := v.v
+	ctx := v.ctx().opCtx
 	return func(label string) Value {
-		arg := &stringLit{x.baseValue, label, nil}
-
-		if val, _ := x.optionals.constraint(ctx, arg); val != nil {
-			return remakeValue(v, val)
-		}
-		return Value{}
+		f := ctx.StringLabel(label)
+		arc := &adt.Vertex{Parent: parent, Label: f}
+		v.v.MatchAndInsert(ctx, arc)
+		arc.Finalize(ctx)
+		return makeValue(v.idx, arc)
 	}
 }
 
@@ -1570,15 +1562,19 @@
 // Value v and w must be obtained from the same build.
 // TODO: remove this requirement.
 func (v Value) Subsume(w Value, opts ...Option) error {
-	var mode subsumeMode
 	o := getOptions(opts)
-	if o.final {
-		mode |= subFinal | subChoose
+	p := subsume.CUE
+	switch {
+	case o.final && o.ignoreClosedness:
+		p = subsume.FinalOpen
+	case o.final:
+		p = subsume.Final
+	case o.ignoreClosedness:
+		p = subsume.API
 	}
-	if o.ignoreClosedness {
-		mode |= subSchema
-	}
-	return subsumes(v, w, mode)
+	p.Defaults = true
+	ctx := v.ctx().opCtx
+	return p.Value(ctx, v.v, w.v)
 }
 
 // Deprecated: use Subsume.
@@ -1588,11 +1584,12 @@
 // Without options, Subsumes checks whether v is a backwards compatbile schema
 // of w.
 //
-// By default, Subsumes tests whether two values are compatib
+// By default, Subsumes tests whether two values are compatible
 // Value v and w must be obtained from the same build.
 // TODO: remove this requirement.
 func (v Value) Subsumes(w Value) bool {
-	return subsumes(v, w, subChoose) == nil
+	p := subsume.Profile{Defaults: true}
+	return p.Check(v.ctx().opCtx, v.v, w.v)
 }
 
 // Unify reports the greatest lower bound of v and w.
@@ -1600,29 +1597,20 @@
 // Value v and w must be obtained from the same build.
 // TODO: remove this requirement.
 func (v Value) Unify(w Value) Value {
-	ctx := v.ctx()
+	// ctx := v.ctx()
 	if v.v == nil {
 		return w
 	}
 	if w.v == nil {
 		return v
 	}
-	if v.Err() != nil {
-		// TODO: perhaps keep both errors.
-		return v
-	}
-	if w.Err() != nil {
-		return w
-	}
-	a := v.v.v
-	b := w.v.v
-	src := binSrc(token.NoPos, opUnify, a, b)
-	val := mkBin(ctx, src.Pos(), opUnify, a, b)
-	u := remakeValue(v, val)
-	if err := u.Validate(); err != nil {
-		u = newValueRoot(ctx, ctx.mkErr(src, err))
-	}
-	return u
+	n := &adt.Vertex{Parent: v.v.Parent, Label: v.v.Label}
+	n.AddConjunct(adt.MakeConjunct(nil, v.v))
+	n.AddConjunct(adt.MakeConjunct(nil, w.v))
+
+	ctx := v.idx.newContext()
+	n.Finalize(ctx.opCtx)
+	return makeValue(v.idx, n)
 }
 
 // Equals reports whether two values are equal, ignoring optional fields.
@@ -1631,9 +1619,8 @@
 	if v.v == nil || other.v == nil {
 		return false
 	}
-	x := v.v.val()
-	y := other.v.val()
-	return equals(v.ctx(), x, y)
+	return eval.Equal(v.ctx().opCtx, v.v, other.v)
+
 }
 
 // Format prints a debug version of a value.
@@ -1645,11 +1632,13 @@
 	}
 	switch {
 	case state.Flag('#'):
-		_, _ = io.WriteString(state, ctx.str(v.v.v))
+		_, _ = io.WriteString(state, ctx.str(v.v))
 	case state.Flag('+'):
-		_, _ = io.WriteString(state, debugStr(ctx, v.v.v))
+		_, _ = io.WriteString(state, debugStr(ctx, v.v))
 	default:
-		_, _ = io.WriteString(state, ctx.str(v.v.Value))
+		n, _ := export.Raw.Expr(v.idx.Runtime, v.v)
+		b, _ := format.Node(n)
+		_, _ = state.Write(b)
 	}
 }
 
@@ -1657,7 +1646,7 @@
 	if v.v == nil {
 		return nil
 	}
-	return v.ctx().getImportFromNode(v.v.v)
+	return v.ctx().getImportFromNode(v.v)
 }
 
 // Reference returns the instance and path referred to by this value such that
@@ -1666,154 +1655,72 @@
 // only return a reference if the index resolves to a concrete value.
 func (v Value) Reference() (inst *Instance, path []string) {
 	// TODO: don't include references to hidden fields.
-	if v.v == nil {
+	if v.v == nil || len(v.v.Conjuncts) != 1 {
 		return nil, nil
 	}
 	ctx := v.ctx()
-	var x value
-	var feature string
-	switch sel := v.v.v.(type) {
-	case *selectorExpr:
-		x = sel.X
-		feature = ctx.LabelStr(sel.Sel)
+	c := v.v.Conjuncts[0]
 
-	case *indexExpr:
-		e := sel.Index.evalPartial(ctx)
-		s, ok := e.(*stringLit)
-		if !ok {
-			return nil, nil
-		}
-		x = sel.X
-		feature = s.Str
+	return reference(ctx, c.Env, c.Expr())
+}
 
-	default:
+func reference(c *context, env *adt.Environment, r adt.Expr) (inst *Instance, path []string) {
+	ctx := c.opCtx
+	defer ctx.PopState(ctx.PushState(env, r.Source()))
+
+	switch x := r.(type) {
+	case *adt.FieldReference:
+		env := ctx.Env(x.UpCount)
+		inst, path = mkPath(c, nil, env.Vertex)
+		path = append(path, x.Label.SelectorString(c.Index))
+
+	case *adt.LabelReference:
+		env := ctx.Env(x.UpCount)
+		return mkPath(c, nil, env.Vertex)
+
+	case *adt.DynamicReference:
+		env := ctx.Env(x.UpCount)
+		inst, path = mkPath(c, nil, env.Vertex)
+		v, _ := ctx.Evaluate(env, x.Label)
+		str := ctx.StringValue(v)
+		path = append(path, str)
+
+	case *adt.ImportReference:
+		imp := x.ImportPath.StringValue(ctx)
+		inst = c.index.getImportFromPath(imp)
+
+	case *adt.SelectorExpr:
+		inst, path = reference(c, env, x.X)
+		path = append(path, x.Sel.SelectorString(ctx))
+
+	case *adt.IndexExpr:
+		inst, path = reference(c, env, x.X)
+		v, _ := ctx.Evaluate(env, x.Index)
+		str := ctx.StringValue(v)
+		path = append(path, str)
+	}
+	if inst == nil {
 		return nil, nil
 	}
-	imp, a := mkPath(ctx, v.v, x, feature, 0)
-	return imp, a
+	return inst, path
 }
 
-func mkPath(c *context, up *valueData, x value, feature string, d int) (imp *Instance, a []string) {
-	switch x := x.(type) {
-	case *selectorExpr:
-		imp, a = mkPath(c, up, x.X, c.LabelStr(x.Sel), d+1)
-		if imp == nil {
-			return nil, nil
-		}
-
-	case *indexExpr:
-		e := x.Index.evalPartial(c)
-		s, ok := e.(*stringLit)
-		if !ok {
-			return nil, nil
-		}
-		imp, a = mkPath(c, up, x.X, s.Str, d+1)
-		if imp == nil {
-			return nil, nil
-		}
-
-	case *nodeRef:
-		// the parent must exist.
-		var v value
-		if p := locateNode(up, x); p != nil {
-			v, a = mkFromRoot(c, p, d+2)
-		} else {
-			// Either this references another parent, or it is an embedding.
-			imp = c.getImportFromNode(x.node)
-			if imp != nil {
-				break
-			}
-			// This must be an embedding, go one up.
-			v, a = mkFromRoot(c, up.parent, d+2)
-		}
-		if v == nil {
-			v = x.node
-		}
-		imp = c.getImportFromNode(v)
-	default:
-		return nil, nil
+func mkPath(ctx *context, a []string, v *adt.Vertex) (inst *Instance, path []string) {
+	if v.Parent == nil {
+		return ctx.index.getImportFromNode(v), a
 	}
-	return imp, append(a, feature)
+	inst, path = mkPath(ctx, a, v.Parent)
+	path = append(path, v.Label.SelectorString(ctx.opCtx))
+	return inst, path
 }
 
-func mkFromRoot(c *context, up *valueData, d int) (root value, a []string) {
-	if up == nil {
-		return nil, make([]string, 0, d)
-	}
-	root, a = mkFromRoot(c, up.parent, d+1)
-	if up.parent != nil {
-		a = append(a, c.LabelStr(up.Label))
-	} else {
-		root = up.v
-	}
-	return root, a
-}
-
-// References reports all references used to evaluate this value. It does not
-// report references for sub fields if v is a struct.
-//
-// Deprecated: can be implemented in terms of Reference and Expr.
-func (v Value) References() [][]string {
-	// TODO: the pathFinder algorithm is quite broken. Using Reference and Expr
-	// will cast a much more accurate net on referenced values.
-	ctx := v.ctx()
-	pf := pathFinder{up: v.v}
-	raw := v.v.v
-	if raw == nil {
-		return nil
-	}
-	rewrite(ctx, raw, pf.find)
-	return pf.paths
-}
-
-type pathFinder struct {
-	paths [][]string
-	stack []label
-	up    *valueData
-}
-
-func (p *pathFinder) find(ctx *context, v value) (value, bool) {
-	switch x := v.(type) {
-	case *selectorExpr:
-		i := len(p.stack)
-		p.stack = append(p.stack, x.Sel)
-		rewrite(ctx, x.X, p.find)
-		p.stack = p.stack[:i]
-		return v, false
-
-	case *nodeRef:
-		i := len(p.stack)
-		up := p.up
-		for ; up != nil && up.Value != x.node.(value); up = up.parent {
-		}
-		for ; up != nil && up.Label > 0; up = up.parent {
-			p.stack = append(p.stack, up.Label)
-		}
-		path := make([]string, len(p.stack))
-		for i, v := range p.stack {
-			path[len(path)-1-i] = ctx.LabelStr(v)
-		}
-		p.paths = append(p.paths, path)
-		p.stack = p.stack[:i]
-		return v, false
-
-	case *structLit:
-		// If the stack is empty, we do not descend, as we are not evaluating
-		// sub fields.
-		if len(p.stack) == 0 {
-			return v, false
-		}
-
-		stack := p.stack
-		p.stack = nil
-		for _, a := range x.Arcs {
-			rewrite(ctx, a.v, p.find)
-		}
-		p.stack = stack
-		return v, false
-	}
-	return v, true
-}
+// // References reports all references used to evaluate this value. It does not
+// // report references for sub fields if v is a struct.
+// //
+// // Deprecated: can be implemented in terms of Reference and Expr.
+// func (v Value) References() [][]string {
+// 	panic("deprecated")
+// }
 
 type options struct {
 	concrete          bool // enforce that values are concrete
@@ -1950,108 +1857,18 @@
 // more than one error, retrievable with errors.Errors, if more than one
 // exists.
 func (v Value) Validate(opts ...Option) error {
-	x := validator{}
 	o := options{}
 	o.updateOptions(opts)
-	// Logically, errors are always permitted in logical fields, so we
-	// force-disable them.
-	// TODO: consider whether we should honor the option to allow checking
-	// optional fields.
-	o.omitOptional = true
-	x.walk(v, o)
-	return errors.Sanitize(x.errs)
-}
 
-type validator struct {
-	errs  errors.Error
-	depth int
-}
-
-func (x *validator) before(v Value, o options) bool {
-	if err := v.checkKind(v.ctx(), bottomKind); err != nil {
-		if !o.concrete && isIncomplete(err) {
-			if o.disallowCycles && err.Code == codeCycle {
-				x.errs = errors.Append(x.errs, v.toErr(err))
-			}
-			return false
-		}
-		x.errs = errors.Append(x.errs, v.toErr(err))
-		if len(errors.Errors(x.errs)) > 50 {
-			return false // mostly to avoid some hypothetical cycle issue
-		}
+	cfg := &validate.Config{
+		Concrete:       o.concrete,
+		DisallowCycles: o.disallowCycles,
+		AllErrors:      true,
 	}
-	if o.concrete {
-		ctx := v.ctx()
-		if err := isGroundRecursive(ctx, v.eval(ctx)); err != nil {
-			x.errs = errors.Append(x.errs, v.toErr(err))
-		}
-	}
-	return true
-}
 
-func (x *validator) walk(v Value, opts options) {
-	// TODO(#42): we can get rid of the arbitrary evaluation depth once CUE has
-	// proper structural cycle detection. See Issue #42. Currently errors
-	// occurring at a depth > internal.MaxDepth will not be detected.
-	if x.depth > internal.MaxDepth {
-		return
-	}
-	ctx := v.ctx()
-	switch v.Kind() {
-	case StructKind:
-		if !x.before(v, opts) {
-			return
-		}
-		x.depth++
-		obj, err := v.structValOpts(ctx, opts)
-		if err != nil {
-			if !isIncomplete(err) && opts.concrete {
-				x.errs = errors.Append(x.errs, v.toErr(err))
-			}
-		}
-		for i := 0; i < obj.Len(); i++ {
-			_, v := obj.At(i)
-			opts := opts
-			if obj.Arcs[i].definition {
-				opts.concrete = false
-			}
-			x.walk(v, opts)
-		}
-		x.depth--
-
-	case ListKind:
-		if !x.before(v, opts) {
-			return
-		}
-		x.depth++
-		list, _ := v.List()
-		for list.Next() {
-			x.walk(list.Value(), opts)
-		}
-		x.depth--
-
-	default:
-		x.before(v, opts)
-	}
-}
-
-func isGroundRecursive(ctx *context, v value) *bottom {
-	switch x := v.(type) {
-	case *bottom:
-		if isIncomplete(x) {
-			return x
-		}
-	case *list:
-		for i := 0; i < len(x.elem.Arcs); i++ {
-			v := ctx.manifest(x.at(ctx, i))
-			if err := isGroundRecursive(ctx, v); err != nil {
-				return err
-			}
-		}
-	default:
-		if !x.Kind().isGround() {
-			return ctx.mkErr(v, "incomplete value (%v)", ctx.str(v))
-		}
+	b := validate.Validate(v.idx.Runtime, v.v, cfg)
+	if b != nil {
+		return b.Err
 	}
 	return nil
 }
@@ -2094,15 +1911,18 @@
 // is no attribute for the requested key.
 func (v Value) Attribute(key string) Attribute {
 	// look up the attributes
-	if v.v == nil || v.v.attrs == nil {
+	if v.v == nil {
 		return Attribute{internal.NewNonExisting(key)}
 	}
-	for _, a := range v.v.attrs.attr {
-		if a.key() != key {
+	// look up the attributes
+	for _, a := range export.ExtractFieldAttrs(v.v.Conjuncts) {
+		k, body := a.Split()
+		if key != k {
 			continue
 		}
-		return Attribute{internal.ParseAttrBody(token.NoPos, a.body())}
+		return Attribute{internal.ParseAttrBody(token.NoPos, body)}
 	}
+
 	return Attribute{internal.NewNonExisting(key)}
 }
 
@@ -2167,79 +1987,193 @@
 	if v.v == nil {
 		return NoOp, nil
 	}
+
+	var expr adt.Expr
+	var env *adt.Environment
+
+	if v.v.IsData() {
+		switch x := v.v.Value.(type) {
+		case *adt.ListMarker, *adt.StructMarker:
+			expr = v.v
+		default:
+			expr = x
+		}
+
+	} else {
+		switch len(v.v.Conjuncts) {
+		case 0:
+			if v.v.Value == nil {
+				return NoOp, []Value{makeValue(v.idx, v.v)}
+			}
+			expr = v.v.Value
+
+		case 1:
+			// the default case, processed below.
+			c := v.v.Conjuncts[0]
+			env = c.Env
+			expr = c.Expr()
+			if v, ok := expr.(*adt.Vertex); ok {
+				switch x := v.Value.(type) {
+				case *adt.ListMarker, *adt.StructMarker:
+				default:
+					expr = x
+				}
+			}
+
+		default:
+			a := []Value{}
+			ctx := v.ctx().opCtx
+			for _, c := range v.v.Conjuncts {
+				n := &adt.Vertex{
+					Parent: v.v.Parent,
+					Label:  v.v.Label,
+				}
+				n.AddConjunct(c)
+				n.Finalize(ctx)
+				a = append(a, makeValue(v.idx, n))
+			}
+			return adt.AndOp, a
+		}
+	}
+
 	// TODO: replace appends with []Value{}. For not leave.
 	a := []Value{}
 	op := NoOp
-	switch x := v.v.v.(type) {
+	switch x := expr.(type) {
 	case *binaryExpr:
-		a = append(a, remakeValue(v, x.X))
-		a = append(a, remakeValue(v, x.Y))
-		op = opToOp[x.Op]
+		a = append(a, remakeValue(v, env, x.X))
+		a = append(a, remakeValue(v, env, x.Y))
+		op = x.Op
 	case *unaryExpr:
-		a = append(a, remakeValue(v, x.X))
-		op = opToOp[x.Op]
-	case *bound:
-		a = append(a, remakeValue(v, x.Expr))
-		op = opToOp[x.Op]
-	case *unification:
+		a = append(a, remakeValue(v, env, x.X))
+		op = x.Op
+	case *boundExpr:
+		a = append(a, remakeValue(v, env, x.Expr))
+		op = x.Op
+	case *boundValue:
+		a = append(a, remakeValue(v, env, x.Value))
+		op = x.Op
+	case *adt.Conjunction:
 		// pre-expanded unification
 		for _, conjunct := range x.Values {
-			a = append(a, remakeValue(v, conjunct))
+			a = append(a, remakeValue(v, env, conjunct))
 		}
 		op = AndOp
-	case *disjunction:
+	case *adt.Disjunction:
+		for _, disjunct := range x.Values {
+			a = append(a, makeValue(v.idx, disjunct))
+		}
+		op = OrOp
+
+	case *adt.DisjunctionExpr:
 		// Filter defaults that are subsumed by another value.
 		count := 0
-	outer:
+		// outer:
 		for _, disjunct := range x.Values {
-			if disjunct.Default {
-				for _, n := range x.Values {
-					s := subsumer{ctx: v.ctx()}
-					if !n.Default && s.subsumes(n.Val, disjunct.Val) {
-						continue outer
-					}
-				}
-			}
+			// if disjunct.marked {
+			// 	for _, n := range x.Values {
+			// 		s := subsumer{ctx: v.ctx()}
+			// 		if !n.marked && s.subsumes(n.val, disjunct.val) {
+			// 			continue outer
+			// 		}
+			// 	}
+			// }
 			count++
-			a = append(a, remakeValue(v, disjunct.Val))
+			a = append(a, remakeValue(v, env, disjunct.Val))
 		}
 		if count > 1 {
-			op = OrOp
+			op = adt.OrOp
 		}
 	case *interpolation:
 		for _, p := range x.Parts {
-			a = append(a, remakeValue(v, p))
+			a = append(a, remakeValue(v, env, p))
 		}
 		op = InterpolationOp
+
+	case *adt.FieldReference:
+		// TODO: allow hard link
+		ctx := v.ctx().opCtx
+		f := ctx.PushState(env, x.Src)
+		env := ctx.Env(x.UpCount)
+		a = append(a, remakeValue(v, nil, &adt.NodeLink{Node: env.Vertex}))
+		a = append(a, remakeValue(v, nil, ctx.NewString(x.Label.SelectorString(ctx))))
+		_ = ctx.PopState(f)
+		op = SelectorOp
+
 	case *selectorExpr:
-		a = append(a, remakeValue(v, x.X))
-		a = append(a, remakeValue(v, &stringLit{
-			x.baseValue,
-			v.ctx().LabelStr(x.Sel),
-			nil,
+		a = append(a, remakeValue(v, env, x.X))
+		// A string selector is quoted.
+		a = append(a, remakeValue(v, env, &adt.String{
+			Str: x.Sel.SelectorString(v.idx.Index),
 		}))
 		op = SelectorOp
+
 	case *indexExpr:
-		a = append(a, remakeValue(v, x.X))
-		a = append(a, remakeValue(v, x.Index))
+		a = append(a, remakeValue(v, env, x.X))
+		a = append(a, remakeValue(v, env, x.Index))
 		op = IndexOp
 	case *sliceExpr:
-		a = append(a, remakeValue(v, x.X))
-		a = append(a, remakeValue(v, x.Lo))
-		a = append(a, remakeValue(v, x.Hi))
+		a = append(a, remakeValue(v, env, x.X))
+		a = append(a, remakeValue(v, env, x.Lo))
+		a = append(a, remakeValue(v, env, x.Hi))
 		op = SliceOp
 	case *callExpr:
-		a = append(a, remakeValue(v, x.Fun))
+		a = append(a, remakeValue(v, env, x.Fun))
 		for _, arg := range x.Args {
-			a = append(a, remakeValue(v, arg))
+			a = append(a, remakeValue(v, env, arg))
 		}
 		op = CallOp
 	case *customValidator:
-		a = append(a, remakeValue(v, x.Builtin))
+		a = append(a, remakeValue(v, env, x.Builtin))
 		for _, arg := range x.Args {
-			a = append(a, remakeValue(v, arg))
+			a = append(a, remakeValue(v, env, arg))
 		}
 		op = CallOp
+
+	case *adt.StructLit:
+		// Simulate old embeddings.
+		envEmbed := &adt.Environment{
+			Up:     env,
+			Vertex: v.v,
+		}
+		fields := []adt.Decl{}
+		ctx := v.ctx().opCtx
+		for _, d := range x.Decls {
+			switch x := d.(type) {
+			case adt.Expr:
+				// embedding
+				n := &adt.Vertex{
+					Parent: v.v.Parent,
+					Label:  v.v.Label}
+				c := adt.MakeConjunct(envEmbed, x)
+				n.AddConjunct(c)
+				n.Finalize(ctx)
+				a = append(a, makeValue(v.idx, n))
+
+			default:
+				fields = append(fields, d)
+			}
+		}
+		if len(a) == 0 {
+			a = append(a, v)
+			break
+		}
+
+		if len(fields) > 0 {
+			n := &adt.Vertex{
+				Parent: v.v.Parent,
+				Label:  v.v.Label,
+			}
+			c := adt.MakeConjunct(env, &adt.StructLit{
+				Decls: fields,
+			})
+			n.AddConjunct(c)
+			n.Finalize(ctx)
+			a = append(a, makeValue(v.idx, n))
+		}
+
+		op = adt.AndOp
+
 	default:
 		a = append(a, v)
 	}
diff --git a/internal/legacy/cue/types_test.go b/internal/legacy/cue/types_test.go
index cea8a14..5ba255b 100644
--- a/internal/legacy/cue/types_test.go
+++ b/internal/legacy/cue/types_test.go
@@ -30,6 +30,8 @@
 	"cuelang.org/go/cue/ast"
 	"cuelang.org/go/cue/errors"
 	"cuelang.org/go/internal"
+	"cuelang.org/go/internal/core/adt"
+	"cuelang.org/go/internal/core/debug"
 )
 
 func getInstance(t *testing.T, body ...string) *Instance {
@@ -175,6 +177,12 @@
 		concrete: false,
 	}, {
 		value: `import "time"
+		v: time.Time`,
+		kind:           BottomKind,
+		incompleteKind: StringKind,
+		concrete:       false,
+	}, {
+		value: `import "time"
 		v: {a: time.Time}.a`,
 		kind:           BottomKind,
 		incompleteKind: StringKind,
@@ -567,7 +575,7 @@
 		res:   "[1,2,3,]",
 	}, {
 		value: `>=5*[1,2,3, ...int]`,
-		err:   "incomplete",
+		err:   "non-concrete value >=5 in operand to *",
 	}, {
 		value: `[for x in #y if x > 1 { x }]
 		#y: [1,2,3]`,
@@ -602,6 +610,9 @@
 		res   string
 		err   string
 	}{{
+		value: `{ #def: 1, _hidden: 2, opt?: 3, reg: 4 }`,
+		res:   "{reg:4,}",
+	}, {
 		value: `_|_`,
 		err:   "from source",
 	}, {
@@ -680,6 +691,9 @@
 	}, {
 		value: `{_a:"a"}`,
 		res:   `{_a:"a",}`,
+	}, {
+		value: `{_a:"a", b?: "b", #c: 3}`,
+		res:   `{_a:"a",b?:"b",#c:3,}`,
 	}}
 	for _, tc := range testCases {
 		t.Run(tc.value, func(t *testing.T) {
@@ -692,6 +706,9 @@
 			buf := []byte{'{'}
 			for iter.Next() {
 				buf = append(buf, iter.Label()...)
+				if iter.IsOptional() {
+					buf = append(buf, '?')
+				}
 				buf = append(buf, ':')
 				b, err := iter.Value().MarshalJSON()
 				checkFatal(t, err, tc.err, "Obj.At")
@@ -731,7 +748,7 @@
 		eval string
 	}{{
 		ref:  []string{"v", "x"},
-		raw:  "(int & <=9223372036854775807 & int & >=-9223372036854775808)",
+		raw:  ">=-9223372036854775808 & <=9223372036854775807 & int",
 		eval: "int64",
 	}}
 	for _, tc := range testCases {
@@ -788,6 +805,7 @@
 	return x
 }
 
+// TODO: Exporting of Vertex as Conjunct
 func TestFill(t *testing.T) {
 	r := &Runtime{}
 
@@ -838,10 +856,13 @@
 			path = strings.Split(tc.path, ",")
 		}
 
-		v := compileT(t, r, tc.in).Value().Fill(tc.x, path...)
+		v := compileT(t, r, tc.in).Value()
+		v = v.Fill(tc.x, path...)
+
 		w := compileT(t, r, tc.out).Value()
 
-		if !reflect.DeepEqual(goValue(v), goValue(w)) {
+		if !cmp.Equal(goValue(v), goValue(w)) {
+			t.Error(cmp.Diff(goValue(v), goValue(w)))
 			t.Errorf("\ngot:  %s\nwant: %s", v, w)
 		}
 	}
@@ -854,6 +875,8 @@
 	#Provider: {
 		ID: string
 		notConcrete: bool
+		a: int
+		b: int
 	}
 	`)
 
@@ -869,9 +892,24 @@
 	}
 
 	got := fmt.Sprint(root.Value())
-
-	if got != `{#Provider: C{ID: string, notConcrete: bool}, providers: {myprovider: C{ID: (string & "12345"), notConcrete: bool}}}` {
-		t.Error(got)
+	want := `{
+	#Provider: {
+		ID:          string
+		notConcrete: bool
+		a:           int
+		b:           int
+	}
+	providers: {
+		myprovider: {
+			ID:          "12345"
+			notConcrete: bool
+			a:           int
+			b:           int
+		}
+	}
+}`
+	if got != want {
+		t.Errorf("got:  %s\nwant: %s", got, want)
 	}
 }
 
@@ -890,11 +928,11 @@
 	}, {
 		in:  `_foo: 3`,
 		def: "_foo",
-		out: `_|_(definition "_foo" not found)`,
+		out: `_|_ // definition "_foo" not found`,
 	}, {
 		in:  `_#foo: 3`,
 		def: "_#foo",
-		out: `_|_(definition "_#foo" not found)`,
+		out: `_|_ // definition "_#foo" not found`,
 	}}
 
 	for _, tc := range testCases {
@@ -910,6 +948,7 @@
 	}
 }
 
+// TODO: trim down to individual defaults?
 func TestDefaults(t *testing.T) {
 	testCases := []struct {
 		value string
@@ -928,12 +967,12 @@
 		ok:    true,
 	}, {
 		value: `*{a:1,b:2}|{a:1}|{b:2}`,
-		def:   "{a: 1, b: 2}",
+		def:   "{a:1,b:2}",
 		val:   "{a: 1}|{b: 2}",
 		ok:    true,
 	}, {
 		value: `{a:1}&{b:2}`,
-		def:   `{a: 1, b: 2}`,
+		def:   `({a:1} & {b:2})`,
 		val:   ``,
 		ok:    false,
 	}}
@@ -946,11 +985,11 @@
 				t.Errorf("hasDefault: got %v; want %v", ok, tc.ok)
 			}
 
-			if got := fmt.Sprint(d); got != tc.def {
+			if got := compactRawStr(d); got != tc.def {
 				t.Errorf("default: got %v; want %v", got, tc.def)
 			}
 
-			op, val := v.Expr()
+			op, val := d.Expr()
 			if op != OrOp {
 				return
 			}
@@ -987,7 +1026,7 @@
 		// 	length: "2",
 	}, {
 		input:  "3",
-		length: "_|_(len not supported for type int)",
+		length: "_|_ // len not supported for type int",
 	}}
 	for _, tc := range testCases {
 		t.Run(tc.input, func(t *testing.T) {
@@ -1036,7 +1075,7 @@
 		a: foo: b: [Bar=string]: { d: Bar }
 		`,
 		path: []string{"a", "foo", "b", ""},
-		want: `{"c":"foolabel","d":"label"}`,
+		want: `{"d":"label","c":"foolabel"}`,
 	}}
 	for _, tc := range testCases {
 		t.Run("", func(t *testing.T) {
@@ -1059,6 +1098,67 @@
 	}
 }
 
+func TestElem(t *testing.T) {
+	testCases := []struct {
+		value string
+		path  []string
+		want  string
+	}{{
+		value: `
+		a: [...int]
+		`,
+		path: []string{"a", ""},
+		want: `int`,
+	}, {
+		value: `
+		[Name=string]: { a: Name }
+		`,
+		path: []string{"", "a"},
+		want: `string`,
+	}, {
+		value: `
+		[Name=string]: { a: Name }
+		`,
+		path: []string{""},
+		want: "{\n\ta: string\n}",
+	}, {
+		value: `
+		a: [Foo=string]: [Bar=string]: { b: Foo+Bar }
+		`,
+		path: []string{"a", "", ""},
+		want: "{\n\tb: string + string\n}",
+	}, {
+		value: `
+		a: [Foo=string]: b: [Bar=string]: { c: Foo+Bar }
+		a: foo: b: [Bar=string]: { d: Bar }
+		`,
+		path: []string{"a", "foo", "b", ""},
+		want: "{\n\td: string\n\tc: string + string\n}",
+	}}
+	for _, tc := range testCases {
+		t.Run("", func(t *testing.T) {
+			v := getInstance(t, tc.value).Value()
+			v.v.Finalize(v.ctx().opCtx) // TODO: do in instance.
+			for _, p := range tc.path {
+				if p == "" {
+					var ok bool
+					v, ok = v.Elem()
+					if !ok {
+						t.Fatal("expected element")
+					}
+				} else {
+					v = v.Lookup(p)
+				}
+			}
+			got := fmt.Sprint(v)
+			// got := debug.NodeString(v.ctx().opCtx, v.v, &debug.Config{Compact: true})
+			if got != tc.want {
+				t.Errorf("\n got: %q\nwant: %q", got, tc.want)
+			}
+		})
+	}
+}
+
 func TestSubsumes(t *testing.T) {
 	a := []string{"a"}
 	b := []string{"b"}
@@ -1281,6 +1381,7 @@
 	}
 }
 
+// TODO: options: disallow cycles.
 func TestValidate(t *testing.T) {
 	testCases := []struct {
 		desc string
@@ -1475,7 +1576,7 @@
 					v = v.Lookup(e)
 				}
 			}
-			got, _ := v.v.appendPath(nil, v.idx)
+			got := v.appendPath(nil)
 			if !reflect.DeepEqual(got, tc) {
 				t.Errorf("got %v; want %v", got, tc)
 			}
@@ -1514,7 +1615,7 @@
 	}, {
 		config: config,
 		path:   strList(),
-		str:    "{a: {a: 0, b: 1, c: 2}, b: {d: a.a, e: int}",
+		str:    "{a:{a:0,b:1,c:2},b:{d:0,e:int}",
 	}, {
 		config: config,
 		path:   strList("a", "a"),
@@ -1522,7 +1623,7 @@
 	}, {
 		config: config,
 		path:   strList("a"),
-		str:    "{a: 0, b: 1, c: 2}",
+		str:    "{a:0,b:1,c:2}",
 	}, {
 		config: config,
 		path:   strList("b", "d"),
@@ -1544,7 +1645,7 @@
 				t.Errorf("exists: got %v; want %v", got, tc.notExists)
 			}
 
-			got := fmt.Sprint(v)
+			got := v.ctx().opCtx.Str(v.v)
 			if tc.str == "" {
 				t.Fatalf("str empty, got %q", got)
 			}
@@ -1843,6 +1944,7 @@
 	}
 }
 
+// TODO: duplicate docs.
 func TestValueDoc(t *testing.T) {
 	const config = `
 	// foobar defines at least foo.
@@ -1923,21 +2025,19 @@
 	}, {
 		val:  v1,
 		path: "foos MyFoo field1",
-		doc: `field1 is an int.
+		doc: `local field comment.
 
-local field comment.
+field1 is an int.
 `,
 	}, {
 		val:  v1,
 		path: "foos MyFoo field2",
 		doc:  "other field comment.\n",
 	}, {
+		// Duplicates are now removed.
 		val:  v1,
 		path: "foos MyFoo dup3",
-		doc: `duplicate field comment
-
-duplicate field comment
-`,
+		doc:  "duplicate field comment\n",
 	}, {
 		val:  v1,
 		path: "bar field1",
@@ -1945,9 +2045,9 @@
 	}, {
 		val:  v1,
 		path: "baz field1",
-		doc: `comment from baz on field 1
+		doc: `comment from bar on field 1
 
-comment from bar on field 1
+comment from baz on field 1
 `,
 	}, {
 		val:  v1,
@@ -1961,9 +2061,9 @@
 	}, {
 		val:  both,
 		path: "Foo",
-		doc: `Another Foo.
+		doc: `A Foo fooses stuff.
 
-A Foo fooses stuff.
+Another Foo.
 `,
 	}}
 	for _, tc := range testCases {
@@ -1992,6 +2092,8 @@
 	return doc
 }
 
+// TODO: unwrap marshal error
+// TODO: improve error messages
 func TestMarshalJSON(t *testing.T) {
 	testCases := []struct {
 		value string
@@ -2048,7 +2150,7 @@
 		err:   `0: cannot convert incomplete value`,
 	}, {
 		value: `(>=3 * [1, 2])`,
-		err:   "incomplete error", // TODO: improve error
+		err:   "cue: marshal error: non-concrete value >=3 in operand to *",
 	}, {
 		value: `{}`,
 		json:  `{}`,
@@ -2117,11 +2219,11 @@
 	}, {
 		// Issue #326
 		value: `x: "\(string)": "v"`,
-		err:   `x: incomplete value 'string' in interpolation`,
+		err:   `x: invalid interpolation`,
 	}, {
 		// Issue #326
 		value: `x: "\(bool)": "v"`,
-		err:   `x: expression in interpolation must evaluate to a number kind or string (found bool)`,
+		err:   `invalid interpolation`,
 	}, {
 		// Issue #326
 		value: `
@@ -2173,8 +2275,8 @@
 		out:   "_|_(from source)",
 	}, {
 		value: `(a.b)
-		a: {}`,
-		out: `_|_(undefined field "b")`,
+			a: {}`,
+		out: `_|_(undefined field b)`,
 	}, {
 		value: `true`,
 		out:   `true`,
@@ -2190,15 +2292,18 @@
 	}, {
 		value: `12_000`,
 		out:   `12000`,
+		// out:   `12_000`,
 	}, {
 		value: `12.000`,
 		out:   `12.000`,
 	}, {
 		value: `12M`,
 		out:   `12000000`,
+		// out:   `12M`,
 	}, {
 		value: `3.0e100`,
 		out:   `3.0e+100`,
+		// out:   `3.0e100`,
 	}, {
 		value: `[]`,
 		out:   `[]`,
@@ -2228,8 +2333,11 @@
 				}
 			}
 			inst.Value().Walk(func(v Value) bool {
-				if k, ok := v.Label(); ok {
-					buf = append(buf, k+":"...)
+				v = v.Eval()
+				if !v.v.Label.IsInt() {
+					if k, ok := v.Label(); ok {
+						buf = append(buf, k+":"...)
+					}
 				}
 				switch v.Kind() {
 				case StructKind:
@@ -2237,6 +2345,11 @@
 				case ListKind:
 					buf = append(buf, '[')
 				default:
+					if b, _ := v.v.Value.(*adt.Bottom); b != nil {
+						s := debugStr(v.ctx(), b)
+						buf = append(buf, fmt.Sprint(s, ",")...)
+						return true
+					}
 					buf = append(buf, fmt.Sprint(v, ",")...)
 				}
 				return true
@@ -2283,6 +2396,7 @@
 	testCases := []struct {
 		input string
 		want  string
+		alt   string
 	}{{
 		input: "v: w: x: _|_",
 		want:  "",
@@ -2327,6 +2441,14 @@
 		a: 1
 		`,
 		want: "a",
+	}, {
+		input: `
+		import "math"
+
+		v: w: x: math.Pi
+		`,
+		want: "Pi",
+		alt:  "3.14159265358979323846264338327950288419716939937510582097494459",
 	}}
 	for _, tc := range testCases {
 		t.Run("", func(t *testing.T) {
@@ -2339,15 +2461,20 @@
 			}
 
 			if tc.want != "" {
-				v := inst.Lookup(a...)
-				if x, _ := v.Int64(); x != 1 {
-					t.Errorf("path resolved to %s; want 1", v)
+				want := "1"
+				if tc.alt != "" {
+					want = tc.alt
+				}
+				v := fmt.Sprint(inst.Lookup(a...))
+				if v != want {
+					t.Errorf("path resolved to %s; want %s", v, want)
 				}
 			}
 		})
 	}
 }
 
+// TODO: stack overflow
 func TestPathCorrection(t *testing.T) {
 	testCases := []struct {
 		input  string
@@ -2355,34 +2482,39 @@
 		want   string
 		skip   bool
 	}{{
+		// // TODO: structural cycle.
+		// input: `
+		// a: b: {
+		// 	c: d: b
+		// }
+		// `,
+		// lookup: func(i *Instance) Value {
+		// 	_, a := i.Lookup("a", "b", "c", "d").Expr()
+		// 	return a[0].Lookup("b", "c", "d")
+		// },
+		// want: "a.b",
+		// }, {
+
+		// TODO: embedding: have field operators.
+		// input: `
+		// 	a: {
+		// 		c: 3
+		// 		{x: c}
+		// 	}
+		// 	`,
+		// lookup: func(i *Instance) Value {
+		// 	_, a := i.Lookup("a").Expr()
+		// 	return a[1].Lookup("x")
+		// },
+		// want: "a.c",
+		// }, {
+
+		// TODO: implement proper Elem()
 		input: `
-		a: b: {
-			c: d: b
-		}
-		`,
-		lookup: func(i *Instance) Value {
-			_, a := i.Lookup("a", "b", "c", "d").Expr()
-			return a[0].Lookup("b", "c", "d")
-		},
-		want: "a.b",
-	}, {
-		input: `
-		a: {
-			c: 3
-			{x: c}
-		}
-		`,
-		lookup: func(i *Instance) Value {
-			_, a := i.Lookup("a").Expr()
-			return a[1].Lookup("x")
-		},
-		want: "a.c",
-	}, {
-		input: `
-		a: b: [...T]
-		a: b: [...T]
-		T: 1
-		`,
+			a: b: [...T]
+			a: b: [...T]
+			T: int
+			`,
 		lookup: func(i *Instance) Value {
 			v, _ := i.Lookup("a", "b").Elem()
 			_, a := v.Expr()
@@ -2391,12 +2523,12 @@
 		want: "T",
 	}, {
 		input: `
-			#S: {
-				b?: [...#T]
-				b?: [...#T]
-			}
-			#T: int
-			`,
+				#S: {
+					b?: [...#T]
+					b?: [...#T]
+				}
+				#T: int
+				`,
 		lookup: func(i *Instance) Value {
 			v := i.LookupDef("#S")
 			f, _ := v.LookupField("b")
@@ -2407,43 +2539,65 @@
 		want: "#T",
 	}, {
 		input: `
-			#a: {
-				#T: {b: 3}
-				close({}) | close({c: #T}) | close({d: string})
-			}
-			`,
+		#S: {
+			a?: [...#T]
+			b?: [...#T]
+		}
+		#T: int
+		`,
 		lookup: func(i *Instance) Value {
-			f, _ := i.LookupField("#a")
-			_, a := f.Value.Expr() // &
-			_, a = a[1].Expr()     // |
-			return a[1].Lookup("c")
+			v := i.LookupDef("#S")
+			f, _ := v.LookupField("a")
+			x := f.Value
+			f, _ = v.LookupField("b")
+			y := f.Value
+			u := x.Unify(y)
+			v, _ = u.Elem()
+			_, a := v.Expr()
+			return a[0]
 		},
-		want: "#a.#T",
+		want: "#T",
+		// }, {
+		// 	input: `
+		// 		#a: {
+		// 			#T: {b: 3}
+		// 			close({}) | close({c: #T}) | close({d: string})
+		// 		}
+		// 		`,
+		// 	lookup: func(i *Instance) Value {
+		// 		f, _ := i.LookupField("#a")
+		// 		_, a := f.Value.Expr() // &
+		// 		_, a = a[1].Expr()     // |
+		// 		return a[1].Lookup("c")
+		// 	},
+		// 	want: "#a.#T",
 	}, {
-		input: `
-		package foo
+		// TODO: iterate over Definitions
+		// input: `
+		// 	package foo
 
-		#Struct: {
-			#T: int
+		// 	#Struct: {
+		// 		#T: int
 
-			{b?: #T}
-		}`,
-		want: "#Struct.#T",
-		lookup: func(inst *Instance) Value {
-			// Locate Struct
-			i, _ := inst.Value().Fields(Definitions(true))
-			if !i.Next() {
-				t.Fatal("no fields")
-			}
-			// Locate b
-			i, _ = i.Value().Fields(Definitions(true), Optional(true))
-			if !(i.Next() && i.Next()) {
-				t.Fatal("no fields")
-			}
-			v := i.Value()
-			return v
-		},
-	}, {
+		// 		{b?: #T}
+		// 	}`,
+		// want: "#Struct.#T",
+		// lookup: func(inst *Instance) Value {
+		// 	// Locate Struct
+		// 	i, _ := inst.Value().Fields(Definitions(true))
+		// 	if !i.Next() {
+		// 		t.Fatal("no fields")
+		// 	}
+		// 	// Locate b
+		// 	i, _ = i.Value().Fields(Definitions(true), Optional(true))
+		// 	if !(i.Next() && i.Next()) {
+		// 		t.Fatal("no fields")
+		// 	}
+		// 	v := i.Value()
+		// 	return v
+		// },
+		// }, {
+
 		input: `
 		package foo
 
@@ -2463,75 +2617,80 @@
 			v = v.Lookup("a")
 			return v
 		},
-	}, {
-		input: `
-		package foo
+		// }, {
 
-		#A: #B: #T
+		// TODO: record additionalItems in list
+		// input: `
+		// 	package foo
 
-		#T: {
-			a: [...#S]
-			#S: {}
-		}
-		`,
-		want: "#T.#S",
-		lookup: func(inst *Instance) Value {
-			f, _ := inst.Value().LookupField("#A")
-			f, _ = f.Value.LookupField("#B")
-			v := f.Value
-			v = Dereference(v)
-			v, _ = v.Lookup("a").Elem()
-			return v
-		},
-	}, {
-		input: `
-		#A: {
-			b: #T
-		}
+		// 	#A: #B: #T
 
-		#T: {
-			a: #S
-			#S: {}
-		}
-		`,
-		want: "#T.#S",
-		lookup: func(inst *Instance) Value {
-			f, _ := inst.Value().LookupField("#A")
-			v := f.Value.Lookup("b")
-			v = Dereference(v)
-			v = v.Lookup("a")
-			return v
-		},
-	}, {
-		// TODO(eval): embedded structs are currently represented at the same
-		// level as the enclosing struct. This means that the parent of an
-		// embedded struct skips the struct in which it is embedded. Treat
-		// embedded structs as "anonymous" fields.
-		// This could perhaps be made fixed with dereferencing as well.
-		skip: true,
-		input: `
-		#Tracing: {
-			#T: { address?: string }
-			#S: { ip?: string }
+		// 	#T: {
+		// 		a: [...#S]
+		// 		#S: {}
+		// 	}
+		// 	`,
+		// want: "#T.#S",
+		// lookup: func(inst *Instance) Value {
+		// 	f, _ := inst.Value().LookupField("#A")
+		// 	f, _ = f.Value.LookupField("#B")
+		// 	v := f.Value
+		// 	v = Dereference(v)
+		// 	v, _ = v.Lookup("a").Elem()
+		// 	return v
+		// },
+		// }, {
 
-			close({}) | close({
-				t: #T
-			}) | close({
-				s: S
-			})
-		}
-		#X: {}
-		#X // Disconnect top-level struct from the one visible by close.
-		`,
-		want: "",
-		lookup: func(inst *Instance) Value {
-			f, _ := inst.Value().LookupField("#Tracing")
-			v := f.Value.Eval()
-			_, args := v.Expr()
-			v = args[1].Lookup("t")
-			v = Dereference(v)
-			return v
-		},
+		// YAY: works.
+		// input: `
+		// 	#A: {
+		// 		b: #T
+		// 	}
+
+		// 	#T: {
+		// 		a: #S
+		// 		#S: {}
+		// 	}
+		// 	`,
+		// want: "#T.#S",
+		// lookup: func(inst *Instance) Value {
+		// 	f, _ := inst.Value().LookupField("#A")
+		// 	v := f.Value.Lookup("b")
+		// 	v = Dereference(v)
+		// 	v = v.Lookup("a")
+		// 	return v
+		// },
+		// }, {
+
+		// 	// TODO(eval): embedded structs are currently represented at the same
+		// 	// level as the enclosing struct. This means that the parent of an
+		// 	// embedded struct skips the struct in which it is embedded. Treat
+		// 	// embedded structs as "anonymous" fields.
+		// 	// This could perhaps be made fixed with dereferencing as well.
+		// 	skip: true,
+		// input: `
+		// 	#Tracing: {
+		// 		#T: { address?: string }
+		// 		#S: { ip?: string }
+
+		// 		close({}) | close({
+		// 			t: #T
+		// 		}) | close({
+		// 			s: #S
+		// 		})
+		// 	}
+		// 	#X: {}
+		// 	#X // Disconnect top-level struct from the one visible by close.
+		// 	`,
+		// want: "",
+		// lookup: func(inst *Instance) Value {
+		// 	f, _ := inst.Value().LookupField("#Tracing")
+		// 	v := f.Value.Eval()
+		// 	_, args := v.Expr()
+		// 	v = args[1].Lookup("t")
+		// 	v = Dereference(v)
+		// 	return v
+		// },
 	}}
 	for _, tc := range testCases {
 		if tc.skip {
@@ -2556,64 +2715,64 @@
 	}
 }
 
-func TestReferences(t *testing.T) {
-	config1 := `
-	a: {
-		b: 3
-	}
-	c: {
-		d: a.b
-		e: c.d
-		f: a
-	}
-	`
-	config2 := `
-	a: { c: 3 }
-	b: { c: int, d: 4 }
-	r: (a & b).c
-	c: {args: s1 + s2}.args
-	s1: string
-	s2: string
-	d: ({arg: b}).arg.c
-	e: f.arg.c
-	f: {arg: b}
-	`
-	testCases := []struct {
-		config string
-		in     string
-		out    string
-	}{
-		{config1, "c.d", "a.b"},
-		{config1, "c.e", "c.d"},
-		{config1, "c.f", "a"},
+// func TestReferences(t *testing.T) {
+// 	config1 := `
+// 	a: {
+// 		b: 3
+// 	}
+// 	c: {
+// 		d: a.b
+// 		e: c.d
+// 		f: a
+// 	}
+// 	`
+// 	config2 := `
+// 	a: { c: 3 }
+// 	b: { c: int, d: 4 }
+// 	r: (a & b).c
+// 	c: {args: s1 + s2}.args
+// 	s1: string
+// 	s2: string
+// 	d: ({arg: b}).arg.c
+// 	e: f.arg.c
+// 	f: {arg: b}
+// 	`
+// 	testCases := []struct {
+// 		config string
+// 		in     string
+// 		out    string
+// 	}{
+// 		{config1, "c.d", "a.b"},
+// 		{config1, "c.e", "c.d"},
+// 		{config1, "c.f", "a"},
 
-		{config2, "r", "a.c b.c"},
-		{config2, "c", "s1 s2"},
-		// {config2, "d", "b.c"}, // TODO: make this work as well.
-		{config2, "e", "f.arg.c"}, // TODO: should also report b.c.
-	}
-	for _, tc := range testCases {
-		t.Run(tc.in, func(t *testing.T) {
-			ctx, st := compileFile(t, tc.config)
-			v := newValueRoot(ctx, st)
-			for _, k := range strings.Split(tc.in, ".") {
-				obj, err := v.structValFull(ctx)
-				if err != nil {
-					t.Fatal(err)
-				}
-				v = obj.Lookup(k)
-			}
-			got := []string{}
-			for _, r := range v.References() {
-				got = append(got, strings.Join(r, "."))
-			}
-			want := strings.Split(tc.out, " ")
-			if !reflect.DeepEqual(got, want) {
-				t.Errorf("got %v; want %v", got, want)
-			}
-		})
-	}
-}
+// 		{config2, "r", "a.c b.c"},
+// 		{config2, "c", "s1 s2"},
+// 		// {config2, "d", "b.c"}, // TODO: make this work as well.
+// 		{config2, "e", "f.arg.c"}, // TODO: should also report b.c.
+// 	}
+// 	for _, tc := range testCases {
+// 		t.Run(tc.in, func(t *testing.T) {
+// 			ctx, st := compileFile(t, tc.config)
+// 			v := newValueRoot(ctx, st)
+// 			for _, k := range strings.Split(tc.in, ".") {
+// 				obj, err := v.structValFull(ctx)
+// 				if err != nil {
+// 					t.Fatal(err)
+// 				}
+// 				v = obj.Lookup(k)
+// 			}
+// 			got := []string{}
+// 			for _, r := range v.References() {
+// 				got = append(got, strings.Join(r, "."))
+// 			}
+// 			want := strings.Split(tc.out, " ")
+// 			if !reflect.DeepEqual(got, want) {
+// 				t.Errorf("got %v; want %v", got, want)
+// 			}
+// 		})
+// 	}
+// }
 
 func checkErr(t *testing.T, err error, str, name string) bool {
 	t.Helper()
@@ -2659,13 +2818,16 @@
 		input: "v: 3 + 4",
 		want:  "+(3 4)",
 	}, {
-		input: "v: !a, a: 3",
-		want:  `!(.(<0> "a"))`,
+		input: "v: !a, a: bool",
+		want:  `!(.(〈〉 "a"))`,
+	}, {
+		input: "v: !a, a: 3", // TODO: Should still look up.
+		want:  `!(.(〈〉 "a"))`,
 	}, {
 		input: "v: 1 | 2 | 3 | *4",
 		want:  "|(1 2 3 4)",
 	}, {
-		input: "v: 2 & 5",
+		input: "v: 2 & 5", // Allow even with error.
 		want:  "&(2 5)",
 	}, {
 		input: "v: 2 | 5",
@@ -2681,7 +2843,7 @@
 		want:  "==(2 5)",
 	}, {
 		input: "v: !b, b: true",
-		want:  `!(.(<0> "b"))`,
+		want:  `!(.(〈〉 "b"))`,
 	}, {
 		input: "v: 2 != 5",
 		want:  "!=(2 5)",
@@ -2729,31 +2891,31 @@
 		want:  "mod(2 5)",
 	}, {
 		input: "v: a.b, a: b: 4",
-		want:  `.(.(<0> "a") "b")`,
+		want:  `.(.(〈〉 "a") "b")`,
 	}, {
 		input: `v: a["b"], a: b: 3 `,
-		want:  `[](.(<0> "a") "b")`,
+		want:  `[](.(〈〉 "a") "b")`,
 	}, {
 		input: "v: a[2:5], a: [1, 2, 3, 4, 5]",
-		want:  `[:](.(<0> "a") 2 5)`,
+		want:  `[:](.(〈〉 "a") 2 5)`,
 	}, {
 		input: "v: len([])",
 		want:  "()(len [])",
 	}, {
 		input: "v: a.b, a: { b: string }",
-		want:  `.(.(<0> "a") "b")`,
+		want:  `.(.(〈〉 "a") "b")`,
 	}, {
 		input: `v: "Hello, \(x)! Welcome to \(place)", place: string, x: string`,
-		want:  `\()("Hello, " .(<0> "x") "! Welcome to " .(<0> "place") "")`,
+		want:  `\()("Hello, " .(〈〉 "x") "! Welcome to " .(〈〉 "place") "")`,
 	}, {
 		input: `v: { a, b: 1 }, a: 2`,
-		want:  `&(<0>{b: 1} .(<0> "a"))`,
+		want:  `&(.(〈〉 "a") {b:1})`,
 	}, {
 		input: `v: { {c: a}, b: a }, a: int`,
-		want:  `&(<0>{b: <1>.a} <0>{c: <1>.a})`,
+		want:  `&({c:a} {b:a})`,
 	}, {
 		input: `v: [...number] | *[1, 2, 3]`,
-		want:  `([, ...number] | *[1,2,3])`,
+		want:  `|([...number] [1,2,3])`,
 	}}
 	for _, tc := range testCases {
 		t.Run(tc.input, func(t *testing.T) {
@@ -2765,10 +2927,11 @@
 		})
 	}
 }
+
 func exprStr(v Value) string {
 	op, operands := v.Expr()
 	if op == NoOp {
-		return debugStr(v.ctx(), v.v.v)
+		return compactRawStr(v)
 	}
 	s := op.String()
 	s += "("
@@ -2781,3 +2944,15 @@
 	s += ")"
 	return s
 }
+
+func compactRawStr(v Value) string {
+	ctx := v.ctx()
+	cfg := &debug.Config{Compact: true, Raw: true}
+	return debug.NodeString(ctx.opCtx, v.v, cfg)
+}
+
+func compactValueStr(v Value) string {
+	ctx := v.ctx()
+	cfg := &debug.Config{Compact: true}
+	return debug.NodeString(ctx.opCtx, v.v, cfg)
+}