diff --git a/cmd/cue/cmd/testdata/script/cmd_baddisplay.txt b/cmd/cue/cmd/testdata/script/cmd_baddisplay.txt
index 101c0d9..71d9d02 100644
--- a/cmd/cue/cmd/testdata/script/cmd_baddisplay.txt
+++ b/cmd/cue/cmd/testdata/script/cmd_baddisplay.txt
@@ -3,7 +3,7 @@
 cmp stderr cmd_baddisplay.out
 
 -- cmd_baddisplay.out --
-text: conflicting values 42 and string (mismatched types int and string):
+command.baddisplay.display.text: conflicting values 42 and string (mismatched types int and string):
     ./task_tool.cue:6:9
     tool/cli:4:9
 -- task.cue --
diff --git a/cue/op.go b/cue/op.go
index f465692..a1d7812 100644
--- a/cue/op.go
+++ b/cue/op.go
@@ -64,7 +64,10 @@
 )
 
 var opToOp = map[op]Op{
-	opUnify:          AndOp,
+	opUnify: AndOp,
+	// TODO(eval): opUnifyUnchecked is not the same as opUnify and should have its own
+	// category, if needed. More likely opUnifyUnchecked, should be
+	// represented as a separate embedding method.
 	opUnifyUnchecked: AndOp,
 	opDisjunction:    OrOp,
 	opLand:           BooleanAndOp,
diff --git a/cue/types.go b/cue/types.go
index 7481905..9b71831 100644
--- a/cue/types.go
+++ b/cue/types.go
@@ -648,6 +648,82 @@
 	return Value{obj.ctx.index, &valueData{obj.path, uint32(i), a}}
 }
 
+// Dereference reports to the value v refers to if v is a reference or v itself
+// otherwise.
+func Dereference(v Value) Value {
+	if v.path == nil {
+		return v
+	}
+
+	ctx := v.ctx()
+	a, n := appendPath(ctx, make([]label, 0, 3), v.path.v)
+
+	if n == nil {
+		return v
+
+	}
+
+	p := locateNode(v.path, 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, cache: imp.rootStruct}}
+	}
+
+	cached := p.cache
+	if cached != nil {
+		cached = p.v.evalPartial(ctx)
+	}
+	s := cached.(*structLit)
+	for _, f := range a {
+		a := s.lookup(ctx, f)
+		p = &valueData{parent: p, arc: a} // index
+		s, _ = a.cache.(*structLit)
+	}
+
+	v = Value{v.idx, p}
+	return v
+}
+
+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.feature)
+
+	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
+	}
+	return a, n
+}
+
 func remakeValue(base Value, v value) Value {
 	p := base.path
 	if n, ok := v.(*nodeRef); ok {
@@ -1100,7 +1176,7 @@
 // Elem returns the value of undefined element types of lists and structs.
 func (v Value) Elem() (Value, bool) {
 	ctx := v.ctx()
-	switch x := v.path.v.(type) {
+	switch x := v.path.cache.(type) {
 	case *structLit:
 		t, _ := x.optionals.constraint(ctx, nil)
 		if t == nil {
@@ -1491,11 +1567,11 @@
 		return nil
 	}
 
-	return func(label string) (v Value) {
+	return func(label string) Value {
 		arg := &stringLit{x.baseValue, label, nil}
 
-		if v, _ := x.optionals.constraint(ctx, arg); v != nil {
-			return newValueRoot(ctx, v)
+		if val, _ := x.optionals.constraint(ctx, arg); val != nil {
+			return remakeValue(v, val)
 		}
 		return v
 	}
@@ -1563,7 +1639,7 @@
 	b := w.path.v
 	src := binSrc(token.NoPos, opUnify, a, b)
 	val := mkBin(ctx, src.Pos(), opUnify, a, b)
-	u := newValueRoot(ctx, val)
+	u := remakeValue(v, val)
 	if err := u.Validate(); err != nil {
 		u = newValueRoot(ctx, ctx.mkErr(src, err))
 	}
@@ -1588,7 +1664,14 @@
 		fmt.Fprint(state, "<nil>")
 		return
 	}
-	_, _ = io.WriteString(state, ctx.str(v.path.cache))
+	switch {
+	case state.Flag('#'):
+		_, _ = io.WriteString(state, ctx.str(v.path.v))
+	case state.Flag('+'):
+		_, _ = io.WriteString(state, debugStr(ctx, v.path.v))
+	default:
+		_, _ = io.WriteString(state, ctx.str(v.path.cache))
+	}
 }
 
 func (v Value) instance() *Instance {
@@ -1652,9 +1735,18 @@
 
 	case *nodeRef:
 		// the parent must exist.
-		up = locateNode(up, x)
 		var v value
-		v, a = mkFromRoot(c, up, d+2)
+		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
 		}
diff --git a/cue/types_test.go b/cue/types_test.go
index a4c7b0b..0160f4f 100644
--- a/cue/types_test.go
+++ b/cue/types_test.go
@@ -2267,25 +2267,194 @@
 }
 
 func TestPathCorrection(t *testing.T) {
-	var r Runtime
-	inst, err := r.Compile("in", `
-	a: b: {
-		c: d: b
-	}
-	`)
-	if err != nil {
-		t.Fatal(err)
-	}
-	_, a := inst.Lookup("a", "b", "c", "d").Expr()
-	v := a[0].Lookup("b", "c", "d")
-	gotInst, ref := v.Reference()
-	if gotInst != inst {
-		t.Error("reference not in original instance")
-	}
-	gotPath := strings.Join(ref, ".")
-	wantPath := "a.b"
-	if gotPath != wantPath {
-		t.Errorf("got path %s; want %s", gotPath, wantPath)
+	testCases := []struct {
+		input  string
+		lookup func(i *Instance) Value
+		want   string
+		skip   bool
+	}{{
+		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
+		`,
+		lookup: func(i *Instance) Value {
+			v, _ := i.Lookup("a", "b").Elem()
+			_, a := v.Expr()
+			return a[0]
+		},
+		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
+
+		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
+		},
+	}, {
+		input: `
+		package foo
+
+		A :: B :: T
+
+		T :: {
+			a: S.U
+			S :: U:: {}
+		}
+		`,
+		want: "T.S.U",
+		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")
+			return v
+		},
+	}, {
+		input: `
+		package foo
+
+		A :: B :: T
+
+		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
+		}
+
+		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 {
+			continue
+		}
+		t.Run("", func(t *testing.T) {
+			var r Runtime
+			inst, err := r.Compile("in", tc.input)
+			if err != nil {
+				t.Fatal(err)
+			}
+			v := tc.lookup(inst)
+			gotInst, ref := v.Reference()
+			if gotInst != inst {
+				t.Error("reference not in original instance")
+			}
+			gotPath := strings.Join(ref, ".")
+			if gotPath != tc.want {
+				t.Errorf("got path %s; want %s", gotPath, tc.want)
+			}
+		})
 	}
 }
 
diff --git a/internal/filetypes/filetypes_test.go b/internal/filetypes/filetypes_test.go
index 4a38607..29bc9fc 100644
--- a/internal/filetypes/filetypes_test.go
+++ b/internal/filetypes/filetypes_test.go
@@ -42,7 +42,7 @@
 	}{{
 		name: "must specify encoding",
 		in:   build.File{},
-		out:  `encoding: non-concrete value string`,
+		out:  `FileInfo.encoding: non-concrete value string`,
 	}, {
 		// Default without any
 		name: "cue",