diff --git a/internal/core/export/adt.go b/internal/core/export/adt.go
new file mode 100644
index 0000000..49bb789
--- /dev/null
+++ b/internal/core/export/adt.go
@@ -0,0 +1,392 @@
+// 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 export
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"cuelang.org/go/cue/ast"
+	"cuelang.org/go/cue/ast/astutil"
+	"cuelang.org/go/cue/token"
+	"cuelang.org/go/internal/core/adt"
+)
+
+func (e *exporter) ident(x adt.Feature) *ast.Ident {
+	s := e.ctx.IndexToString(int64(x.Index()))
+	if !ast.IsValidIdent(s) {
+		panic(s + " is not a valid identifier")
+	}
+	return ast.NewIdent(s)
+}
+
+func (e *exporter) adt(expr adt.Expr, conjuncts []adt.Conjunct) ast.Expr {
+	switch x := expr.(type) {
+	case adt.Value:
+		return e.expr(x)
+
+	case *adt.ListLit:
+		a := []ast.Expr{}
+		for _, x := range x.Elems {
+			a = append(a, e.elem(x))
+		}
+		return ast.NewList(a...)
+
+	case *adt.StructLit:
+		// TODO: should we use pushFrame here?
+		// _, saved := e.pushFrame([]adt.Conjunct{adt.MakeConjunct(nil, x)})
+		// defer e.popFrame(saved)
+		// s := e.frame(0).scope
+
+		s := &ast.StructLit{}
+
+		for _, d := range x.Decls {
+			s.Elts = append(s.Elts, e.decl(d))
+		}
+		return s
+
+	case *adt.FieldReference:
+		f := e.frame(x.UpCount)
+		ident := e.ident(x.Label)
+		entry := f.fields[x.Label]
+		entry.references = append(entry.references, ident)
+		return ident
+
+	case *adt.LabelReference:
+		// get potential label from Source. Otherwise use X.
+		f := e.frame(x.UpCount)
+		var ident *ast.Ident
+		if f.field == nil {
+			// This can happen when the LabelReference is evaluated outside of
+			// normal evaluation, that is, if a pattern constraint or
+			// additional constraint is evaluated by itself.
+			return ast.NewIdent("string")
+		}
+		list, ok := f.field.Label.(*ast.ListLit)
+		if !ok || len(list.Elts) != 1 {
+			panic("label reference to non-pattern constraint field or invalid list")
+		}
+		if a, ok := list.Elts[0].(*ast.Alias); ok {
+			ident = ast.NewIdent(a.Ident.Name)
+		} else {
+			ident = ast.NewIdent("X" + strconv.Itoa(e.unique))
+			e.unique++
+			list.Elts[0] = &ast.Alias{
+				Ident: ast.NewIdent(ident.Name),
+				Expr:  list.Elts[0],
+			}
+		}
+		ident.Scope = f.field
+		ident.Node = f.labelExpr
+		return ident
+
+	case *adt.DynamicReference:
+		// get potential label from Source. Otherwise use X.
+		ident := ast.NewIdent("X")
+		f := e.frame(x.UpCount)
+		ident.Scope = f.field
+		ident.Node = f.field
+		return ident
+
+	case *adt.ImportReference:
+		importPath := x.ImportPath.StringValue(e.index)
+		spec := ast.NewImport(nil, importPath)
+
+		info, _ := astutil.ParseImportSpec(spec)
+		name := info.PkgName
+		if x.Label != 0 {
+			name = x.Label.StringValue(e.index)
+			if name != info.PkgName {
+				spec.Name = ast.NewIdent(name)
+			}
+		}
+		ident := ast.NewIdent(name)
+		ident.Node = spec
+		return ident
+
+	case *adt.LetReference:
+		f := e.frame(x.UpCount)
+		let := f.let[x.X]
+		if let == nil {
+			if f.let == nil {
+				f.let = map[adt.Expr]*ast.LetClause{}
+			}
+			let = &ast.LetClause{Expr: e.expr(x.X)}
+			f.let[x.X] = let
+		}
+		ident := e.ident(x.Label)
+		ident.Node = let
+		ident.Scope = f.scope
+		return ident
+
+	case *adt.SelectorExpr:
+		return &ast.SelectorExpr{
+			X:   e.expr(x.X),
+			Sel: e.ident(x.Sel),
+		}
+
+	case *adt.IndexExpr:
+		return &ast.IndexExpr{
+			X:     e.expr(x.X),
+			Index: e.expr(x.Index),
+		}
+
+	case *adt.SliceExpr:
+		var lo, hi ast.Expr
+		if x.Lo != nil {
+			lo = e.expr(x.Lo)
+		}
+		if x.Hi != nil {
+			hi = e.expr(x.Hi)
+		}
+		// TODO: Stride not yet? implemented.
+		// if x.Stride != nil {
+		// 	stride = e.expr(x.Stride)
+		// }
+		return &ast.SliceExpr{X: e.expr(x.X), Low: lo, High: hi}
+
+	case *adt.Interpolation:
+		t := &ast.Interpolation{}
+		multiline := false
+		// TODO: mark formatting in interpolation itself.
+		for i := 0; i < len(x.Parts); i += 2 {
+			str := x.Parts[i].(*adt.String).Str
+			if strings.IndexByte(str, '\n') >= 0 {
+				multiline = true
+				break
+			}
+		}
+		quote := `"`
+		if multiline {
+			quote = `"""`
+		}
+		prefix := quote
+		suffix := `\(`
+		for i, elem := range x.Parts {
+			if i%2 == 1 {
+				t.Elts = append(t.Elts, e.expr(elem))
+			} else {
+				buf := []byte(prefix)
+				if i == len(x.Parts)-1 {
+					suffix = quote
+				}
+				str := elem.(*adt.String).Str
+				if multiline {
+					buf = appendEscapeMulti(buf, str, '"')
+				} else {
+					buf = appendEscaped(buf, str, '"', true)
+				}
+				buf = append(buf, suffix...)
+				t.Elts = append(t.Elts, &ast.BasicLit{
+					Kind:  token.STRING,
+					Value: string(buf),
+				})
+			}
+			prefix = ")"
+		}
+		return t
+
+	case *adt.BoundExpr:
+		return &ast.UnaryExpr{
+			Op: x.Op.Token(),
+			X:  e.expr(x.Expr),
+		}
+
+	case *adt.UnaryExpr:
+		return &ast.UnaryExpr{
+			Op: x.Op.Token(),
+			X:  e.expr(x.X),
+		}
+
+	case *adt.BinaryExpr:
+		return &ast.BinaryExpr{
+			Op: x.Op.Token(),
+			X:  e.expr(x.X),
+			Y:  e.expr(x.Y),
+		}
+
+	case *adt.CallExpr:
+		a := []ast.Expr{}
+		for _, arg := range x.Args {
+			v := e.expr(arg)
+			if v == nil {
+				e.expr(arg)
+				panic("")
+			}
+			a = append(a, v)
+		}
+		fun := e.expr(x.Fun)
+		return &ast.CallExpr{Fun: fun, Args: a}
+
+	case *adt.DisjunctionExpr:
+		a := []ast.Expr{}
+		for _, d := range x.Values {
+			v := e.expr(d.Val)
+			if d.Default {
+				v = &ast.UnaryExpr{Op: token.MUL, X: v}
+			}
+			a = append(a, v)
+		}
+		return ast.NewBinExpr(token.OR, a...)
+
+	default:
+		panic(fmt.Sprintf("unknown field %T", x))
+	}
+}
+
+func (e *exporter) decl(d adt.Decl) ast.Decl {
+	switch x := d.(type) {
+	case adt.Elem:
+		return e.elem(x)
+
+	case *adt.Field:
+		e.setDocs(x)
+		f := &ast.Field{
+			Label: e.stringLabel(x.Label),
+			Value: e.expr(x.Value),
+		}
+		e.addField(x.Label, f.Value)
+		// extractDocs(nil)
+		return f
+
+	case *adt.OptionalField:
+		e.setDocs(x)
+		f := &ast.Field{
+			Label:    e.stringLabel(x.Label),
+			Optional: token.NoSpace.Pos(),
+			Value:    e.expr(x.Value),
+		}
+		e.addField(x.Label, f.Value)
+		// extractDocs(nil)
+		return f
+
+	case *adt.BulkOptionalField:
+		e.setDocs(x)
+		// set bulk in frame.
+		frame := e.frame(0)
+
+		expr := e.expr(x.Filter)
+		frame.labelExpr = expr // see astutil.Resolve.
+
+		if x.Label != 0 {
+			expr = &ast.Alias{Ident: e.ident(x.Label), Expr: expr}
+		}
+		f := &ast.Field{
+			Label: ast.NewList(expr),
+		}
+
+		frame.field = f
+
+		f.Value = e.expr(x.Value)
+
+		return f
+
+	case *adt.DynamicField:
+		e.setDocs(x)
+		key := e.expr(x.Key)
+		if _, ok := key.(*ast.Interpolation); !ok {
+			key = &ast.ParenExpr{X: key}
+		}
+		f := &ast.Field{
+			Label: key.(ast.Label),
+		}
+
+		frame := e.frame(0)
+		frame.field = f
+		frame.labelExpr = key
+		// extractDocs(nil)
+
+		f.Value = e.expr(x.Value)
+
+		return f
+
+	default:
+		panic(fmt.Sprintf("unknown field %T", x))
+	}
+}
+
+func (e *exporter) elem(d adt.Elem) ast.Expr {
+
+	switch x := d.(type) {
+	case adt.Expr:
+		return e.expr(x)
+
+	case *adt.Ellipsis:
+		t := &ast.Ellipsis{}
+		if x.Value != nil {
+			t.Type = e.expr(x.Value)
+		}
+		return t
+
+	case adt.Yielder:
+		return e.comprehension(x)
+
+	default:
+		panic(fmt.Sprintf("unknown field %T", x))
+	}
+}
+
+func (e *exporter) comprehension(y adt.Yielder) ast.Expr {
+	c := &ast.Comprehension{}
+
+	for {
+		switch x := y.(type) {
+		case *adt.ForClause:
+			value := e.ident(x.Value)
+			clause := &ast.ForClause{
+				Value:  value,
+				Source: e.expr(x.Src),
+			}
+			c.Clauses = append(c.Clauses, clause)
+
+			_, saved := e.pushFrame(nil)
+			defer e.popFrame(saved)
+
+			if x.Key != 0 {
+				key := e.ident(x.Key)
+				clause.Key = key
+				e.addField(x.Key, clause)
+			}
+			e.addField(x.Value, clause)
+
+			y = x.Dst
+
+		case *adt.IfClause:
+			clause := &ast.IfClause{Condition: e.expr(x.Condition)}
+			c.Clauses = append(c.Clauses, clause)
+			y = x.Dst
+
+		case *adt.LetClause:
+			clause := &ast.LetClause{Expr: e.expr(x.Expr)}
+			c.Clauses = append(c.Clauses, clause)
+
+			_, saved := e.pushFrame(nil)
+			defer e.popFrame(saved)
+
+			e.addField(x.Label, clause)
+
+			y = x.Dst
+
+		case *adt.ValueClause:
+			c.Value = e.expr(x.StructLit)
+			return c
+
+		default:
+			panic(fmt.Sprintf("unknown field %T", x))
+		}
+	}
+
+}
diff --git a/internal/core/export/export.go b/internal/core/export/export.go
index 76bbe8a..9c507f4 100644
--- a/internal/core/export/export.go
+++ b/internal/core/export/export.go
@@ -18,50 +18,80 @@
 	"cuelang.org/go/cue/ast"
 	"cuelang.org/go/cue/ast/astutil"
 	"cuelang.org/go/cue/errors"
+	"cuelang.org/go/internal"
 	"cuelang.org/go/internal/core/adt"
 	"cuelang.org/go/internal/core/eval"
 )
 
+const debug = false
+
 type Profile struct {
 	Simplify bool
 
 	// TODO:
 	// IncludeDocs
+	ShowOptional    bool
+	ShowDefinitions bool
+	ShowHidden      bool
+	ShowDocs        bool
+	ShowAttributes  bool
+
+	// AllowErrorType
+	// Use unevaluated conjuncts for these error types
+	// IgnoreRecursive
+
+	// TODO: recurse over entire tree to determine transitive closure
+	// of what needs to be printed.
+	// IncludeDependencies bool
 }
 
 var Simplified = &Profile{
 	Simplify: true,
+	ShowDocs: true,
 }
 
-var Raw = &Profile{}
+var Raw = &Profile{
+	ShowOptional:    true,
+	ShowDefinitions: true,
+	ShowHidden:      true,
+	ShowDocs:        true,
+}
+
+var All = &Profile{
+	Simplify:        true,
+	ShowOptional:    true,
+	ShowDefinitions: true,
+	ShowHidden:      true,
+	ShowDocs:        true,
+	ShowAttributes:  true,
+}
 
 // Concrete
 
 // Def exports v as a definition.
 func Def(r adt.Runtime, v *adt.Vertex) (*ast.File, errors.Error) {
-	p := Profile{}
-	return p.Def(r, v)
+	return All.Def(r, v)
 }
 
 // Def exports v as a definition.
 func (p *Profile) Def(r adt.Runtime, v *adt.Vertex) (*ast.File, errors.Error) {
 	e := newExporter(p, r, v)
+	if v.Label.IsDef() {
+		e.inDefinition++
+	}
 	expr := e.expr(v)
-	return e.toFile(expr)
+	if v.Label.IsDef() {
+		e.inDefinition--
+		if s, ok := expr.(*ast.StructLit); ok {
+			expr = ast.NewStruct(
+				ast.Embed(ast.NewIdent("#_def")),
+				ast.NewIdent("#_def"), s,
+			)
+		}
+	}
+	return e.toFile(v, expr)
 }
 
-// // TODO: remove: must be able to fall back to arcs if there are no
-// // conjuncts.
-// func Conjuncts(conjuncts ...adt.Conjunct) (*ast.File, errors.Error) {
-// 	var e Exporter
-// 	// for now just collect and turn into an big conjunction.
-// 	var a []ast.Expr
-// 	for _, c := range conjuncts {
-// 		a = append(a, e.expr(c.Expr()))
-// 	}
-// 	return e.toFile(ast.NewBinExpr(token.AND, a...))
-// }
-
 func Expr(r adt.Runtime, n adt.Expr) (ast.Expr, errors.Error) {
 	return Simplified.Expr(r, n)
 }
@@ -71,20 +101,43 @@
 	return e.expr(n), nil
 }
 
-func (e *exporter) toFile(x ast.Expr) (*ast.File, errors.Error) {
+func (e *exporter) toFile(v *adt.Vertex, x ast.Expr) (*ast.File, errors.Error) {
 	f := &ast.File{}
 
+	pkgName := ""
+	pkg := &ast.Package{}
+	for _, c := range v.Conjuncts {
+		f, _ := c.Source().(*ast.File)
+		if f == nil {
+			continue
+		}
+
+		if _, name, _ := internal.PackageInfo(f); name != "" {
+			pkgName = name
+		}
+
+		if e.cfg.ShowDocs {
+			if doc := internal.FileComment(f); doc != nil {
+				ast.AddComment(pkg, doc)
+			}
+		}
+	}
+
+	if pkgName != "" {
+		pkg.Name = ast.NewIdent(pkgName)
+		f.Decls = append(f.Decls, pkg)
+	}
+
 	switch st := x.(type) {
 	case nil:
 		panic("null input")
 
 	case *ast.StructLit:
-		f.Decls = st.Elts
+		f.Decls = append(f.Decls, st.Elts...)
 
 	default:
 		f.Decls = append(f.Decls, &ast.EmbedDecl{Expr: x})
 	}
-
 	if err := astutil.Sanitize(f); err != nil {
 		err := errors.Promote(err, "export")
 		return f, errors.Append(e.errs, err)
@@ -106,15 +159,17 @@
 	}
 	v := e.value(n, n.Conjuncts...)
 
-	return e.toFile(v)
+	return e.toFile(n, v)
 }
 
 func Value(r adt.Runtime, n adt.Value) (ast.Expr, errors.Error) {
 	return Simplified.Value(r, n)
 }
 
+// Should take context.
 func (p *Profile) Value(r adt.Runtime, n adt.Value) (ast.Expr, errors.Error) {
 	e := exporter{
+		ctx:   eval.NewContext(r, nil),
 		cfg:   p,
 		index: r,
 	}
@@ -123,9 +178,8 @@
 }
 
 type exporter struct {
-	cfg      *Profile
-	errs     errors.Error
-	concrete bool
+	cfg  *Profile // Make value todo
+	errs errors.Error
 
 	ctx *adt.OpContext
 
@@ -133,6 +187,10 @@
 
 	// For resolving up references.
 	stack []frame
+
+	inDefinition int // for close() wrapping.
+
+	unique int
 }
 
 func newExporter(p *Profile, r adt.Runtime, v *adt.Vertex) *exporter {
@@ -149,23 +207,85 @@
 	scope *ast.StructLit
 	todo  []completeFunc
 
+	docSources []adt.Conjunct
+
+	// For resolving dynamic fields.
+	field     *ast.Field
+	labelExpr ast.Expr
+	upCount   int32 // for off-by-one handling
+
+	// labeled fields
+	fields map[adt.Feature]entry
+	let    map[adt.Expr]*ast.LetClause
+
 	// field to new field
 	mapped map[adt.Node]ast.Node
 }
 
-// func (e *Exporter) pushFrame(d *adt.StructLit, s *ast.StructLit) (saved []frame) {
-// 	saved := e.stack
-// 	e.stack = append(e.stack, frame{scope: s, mapped: map[adt.Node]ast.Node{}})
-// 	return saved
-// }
+type entry struct {
+	node ast.Node
 
-// func (e *Exporter) popFrame(saved []frame) {
-// 	f := e.stack[len(e.stack)-1]
+	references []*ast.Ident
+}
 
-// 	for _, f
+func (e *exporter) addField(label adt.Feature, n ast.Node) {
+	frame := e.top()
+	entry := frame.fields[label]
+	entry.node = n
+	frame.fields[label] = entry
+}
 
-// 	e.stack = saved
-// }
+func (e *exporter) pushFrame(conjuncts []adt.Conjunct) (s *ast.StructLit, saved []frame) {
+	saved = e.stack
+	s = &ast.StructLit{}
+	e.stack = append(e.stack, frame{
+		scope:      s,
+		mapped:     map[adt.Node]ast.Node{},
+		fields:     map[adt.Feature]entry{},
+		docSources: conjuncts,
+	})
+	return s, saved
+}
+
+func (e *exporter) popFrame(saved []frame) {
+	top := e.stack[len(e.stack)-1]
+
+	for _, f := range top.fields {
+		for _, r := range f.references {
+			r.Node = f.node
+		}
+	}
+
+	e.stack = saved
+}
+
+func (e *exporter) top() *frame {
+	return &(e.stack[len(e.stack)-1])
+}
+
+func (e *exporter) frame(upCount int32) *frame {
+	for i := len(e.stack) - 1; i >= 0; i-- {
+		f := &(e.stack[i])
+		if upCount <= (f.upCount - 1) {
+			return f
+		}
+		upCount -= f.upCount
+	}
+	if debug {
+		// This may be valid when exporting incomplete references. These are
+		// not yet handled though, so find a way to catch them when debugging
+		// printing of values that are supposed to be complete.
+		panic("unreachable reference")
+	}
+
+	return &frame{}
+}
+
+func (e *exporter) setDocs(x adt.Node) {
+	f := e.stack[len(e.stack)-1]
+	f.docSources = []adt.Conjunct{adt.MakeConjunct(nil, x)}
+	e.stack[len(e.stack)-1] = f
+}
 
 // func (e *Exporter) promise(upCount int32, f completeFunc) {
 // 	e.todo = append(e.todo, f)
diff --git a/internal/core/export/export_test.go b/internal/core/export/export_test.go
index 8c7bc83..77032b0 100644
--- a/internal/core/export/export_test.go
+++ b/internal/core/export/export_test.go
@@ -22,6 +22,7 @@
 	"cuelang.org/go/cue/errors"
 	"cuelang.org/go/cue/format"
 	"cuelang.org/go/internal/core/compile"
+	"cuelang.org/go/internal/core/eval"
 	"cuelang.org/go/internal/core/runtime"
 	"cuelang.org/go/internal/cuetxtar"
 	"github.com/rogpeppe/go-internal/txtar"
@@ -45,6 +46,10 @@
 		if errs != nil {
 			t.Fatal(errs)
 		}
+		v.Finalize(eval.NewContext(r, v))
+
+		// TODO: do we need to evaluate v? In principle not necessary.
+		// v.Finalize(eval.NewContext(r, v))
 
 		file, errs := Def(r, v)
 		errors.Print(t, errs, nil)
@@ -70,20 +75,56 @@
 -- in.cue --
 package test
 
-import pkg2 "example.com/foo/pkg1"
-#pkg1: pkg2.Object
+// // Foo
+// a: [X=string]: [Y=string]: {
+// 	name: X+Y
+// }
 
-"Hello \(#pkg1)!"
+// [Y=string]: [X=string]: name: {Y+X}
+// {
+// 	name:  X.other + Y
+// 	other: string
+// }
+
+// c: [X=string]: X
+
+// #pkg1: Object
+
+// "Hello \(#pkg1)!"
+
+
+// Object: "World"
+
+// // A Foo fooses stuff.
+// foos are instances of Foo.
+// foos: [string]: {}
+
+// // // My first little foo.
+// foos: MyFoo: {}
+
+bar: 3
+d2: C="foo\(bar)": {
+    name: "xx"
+    foo: C.name
+}
+
 	`
 
 	archive := txtar.Parse([]byte(in))
 	a := cuetxtar.Load(archive, "/tmp/test")
+	if err := a[0].Err; err != nil {
+		t.Fatal(err)
+	}
+
+	// x := a[0].Files[0]
+	// astutil.Sanitize(x)
 
 	r := runtime.New()
 	v, errs := compile.Files(nil, r, a[0].Files...)
 	if errs != nil {
 		t.Fatal(errs)
 	}
+	v.Finalize(eval.NewContext(r, v))
 
 	file, errs := Def(r, v)
 	if errs != nil {
diff --git a/internal/core/export/expr.go b/internal/core/export/expr.go
index c73e556..3edc5f5 100644
--- a/internal/core/export/expr.go
+++ b/internal/core/export/expr.go
@@ -52,26 +52,28 @@
 		return nil
 
 	case *adt.Vertex:
-		if len(x.Conjuncts) == 0 {
+		if len(x.Conjuncts) == 0 || x.IsData() {
 			// Treat as literal value.
 			return e.value(x)
+		} // Should this be the arcs label?
+
+		a := []conjunct{}
+		for _, c := range x.Conjuncts {
+			a = append(a, conjunct{c, 0})
 		}
-		return e.mergeValues(x.Conjuncts...)
+
+		return e.mergeValues(adt.InvalidLabel, x, a, x.Conjuncts...)
 
 	case *adt.StructLit:
-		return e.mergeValues(adt.MakeConjunct(nil, x))
+		c := adt.MakeConjunct(nil, x)
+		return e.mergeValues(adt.InvalidLabel, nil, []conjunct{{c: c, up: 0}}, c)
 
 	case adt.Value:
-		e.value(x)
+		return e.value(x) // Use conjuncts.
 
 	default:
-		if f, ok := x.Source().(*ast.File); ok {
-			return &ast.StructLit{Elts: f.Decls}
-		}
-
-		return v.Source().(ast.Expr)
+		return e.adt(v, nil)
 	}
-	return nil
 }
 
 // Piece out values:
@@ -79,17 +81,25 @@
 // For a struct, piece out conjuncts that are already values. Those can be
 // unified. All other conjuncts are added verbatim.
 
-func (x *exporter) mergeValues(a ...adt.Conjunct) ast.Expr {
+func (x *exporter) mergeValues(label adt.Feature, src *adt.Vertex, a []conjunct, orig ...adt.Conjunct) ast.Expr {
+
 	e := conjuncts{
 		exporter: x,
 		values:   &adt.Vertex{},
-		fields:   map[adt.Feature][]adt.Conjunct{},
+		fields:   map[adt.Feature]field{},
 	}
 
+	_, saved := e.pushFrame(orig)
+	defer e.popFrame(saved)
+
 	for _, c := range a {
-		e.addExpr(c.Env, c.Expr())
+		e.top().upCount = c.up
+		x := c.c.Expr()
+		e.addExpr(c.c.Env, x)
 	}
 
+	s := x.top().scope
+
 	// Unify values only for one level.
 	if len(e.values.Conjuncts) > 0 {
 		e.values.Finalize(e.ctx)
@@ -97,14 +107,23 @@
 	}
 
 	// Collect and order set of fields.
+
 	fields := []adt.Feature{}
 	for f := range e.fields {
 		fields = append(fields, f)
 	}
-	m := sortArcs(e.exporter.extractFeatures(e.structs))
+
+	// Sort fields in case features lists are missing to ensure
+	// predictability. Also sort in reverse order, so that bugs
+	// are more likely exposed.
+	sort.Slice(fields, func(i, j int) bool {
+		return fields[i] > fields[j]
+	})
+
+	m := sortArcs(extractFeatures(e.structs))
 	sort.SliceStable(fields, func(i, j int) bool {
-		if m[fields[i]] == 0 {
-			return m[fields[j]] != 0
+		if m[fields[j]] == 0 {
+			return m[fields[i]] != 0
 		}
 		return m[fields[i]] > m[fields[j]]
 	})
@@ -112,6 +131,9 @@
 	if len(e.fields) == 0 && !e.hasEllipsis {
 		switch len(e.exprs) {
 		case 0:
+			if len(e.structs) > 0 {
+				return ast.NewStruct()
+			}
 			return ast.NewIdent("_")
 		case 1:
 			return e.exprs[0]
@@ -121,52 +143,96 @@
 		}
 	}
 
-	s := &ast.StructLit{}
 	for _, x := range e.exprs {
 		s.Elts = append(s.Elts, &ast.EmbedDecl{Expr: x})
 	}
 
 	for _, f := range fields {
-		c := e.fields[f]
-		merged := e.mergeValues(c...)
+		field := e.fields[f]
+		c := field.conjuncts
+
 		label := e.stringLabel(f)
+
+		if f.IsDef() {
+			x.inDefinition++
+		}
+
+		a := []adt.Conjunct{}
+		for _, cc := range c {
+			a = append(a, cc.c)
+		}
+
+		merged := e.mergeValues(f, nil, c, a...)
+
+		if f.IsDef() {
+			x.inDefinition--
+		}
+
 		d := &ast.Field{Label: label, Value: merged}
-		if isOptional(c) {
+		if isOptional(a) {
 			d.Optional = token.Blank.Pos()
 		}
+		if x.cfg.ShowDocs {
+			docs := extractDocs(src, a)
+			ast.SetComments(d, docs)
+		}
+		if x.cfg.ShowAttributes {
+			d.Attrs = ExtractFieldAttrs(a)
+		}
 		s.Elts = append(s.Elts, d)
 	}
 	if e.hasEllipsis {
 		s.Elts = append(s.Elts, &ast.Ellipsis{})
+	} else if src != nil && src.IsClosed(e.ctx) && e.inDefinition == 0 {
+		return ast.NewCall(ast.NewIdent("close"), s)
 	}
 
 	return s
 }
 
-// A conjuncts collects values of a single vertex.
+// Conjuncts if for collecting values of a single vertex.
 type conjuncts struct {
 	*exporter
 	// Values is used to collect non-struct values.
 	values      *adt.Vertex
 	exprs       []ast.Expr
 	structs     []*adt.StructLit
-	fields      map[adt.Feature][]adt.Conjunct
+	fields      map[adt.Feature]field
 	hasEllipsis bool
 }
 
+func (c *conjuncts) addConjunct(f adt.Feature, env *adt.Environment, n adt.Node) {
+
+	x := c.fields[f]
+	v := adt.MakeConjunct(env, n)
+	x.conjuncts = append(x.conjuncts, conjunct{
+		c:  v,
+		up: c.top().upCount,
+	})
+	// x.upCounts = append(x.upCounts, c.top().upCount)
+	c.fields[f] = x
+}
+
+type field struct {
+	docs      []*ast.CommentGroup
+	conjuncts []conjunct
+}
+
+type conjunct struct {
+	c  adt.Conjunct
+	up int32
+}
+
 func (e *conjuncts) addExpr(env *adt.Environment, x adt.Expr) {
 	switch x := x.(type) {
 	case *adt.StructLit:
+		e.top().upCount++
+
 		// Only add if it only has no bulk fields or elipsis.
 		if isComplexStruct(x) {
-			switch src := x.Src.(type) {
-			case nil:
-				panic("now allowed")
-			case *ast.StructLit:
-				e.exprs = append(e.exprs, src)
-			case *ast.File:
-				e.exprs = append(e.exprs, &ast.StructLit{Elts: src.Decls})
-			}
+			_, saved := e.pushFrame(nil)
+			e.exprs = append(e.exprs, e.adt(x, nil))
+			e.popFrame(saved)
 			return
 		}
 		// Used for sorting.
@@ -178,9 +244,11 @@
 			case *adt.Field:
 				label = f.Label
 			case *adt.OptionalField:
+				// TODO: mark optional here.
 				label = f.Label
 			case *adt.Ellipsis:
 				e.hasEllipsis = true
+				continue
 			case adt.Expr:
 				e.addExpr(env, f)
 				continue
@@ -189,21 +257,33 @@
 			default:
 				panic("unreachable")
 			}
-			c := adt.MakeConjunct(env, d)
-			e.fields[label] = append(e.fields[label], c)
+			e.addConjunct(label, env, d)
 		}
+		e.top().upCount--
 
 	case adt.Value: // other values.
 		if v, ok := x.(*adt.Vertex); ok {
 			// if !v.IsList() {
-			// 	panic("what to do?")
+			// 	panic("what to do?") // TO
 			// }
+			e.structs = append(e.structs, v.Structs...)
+
 			// generated, only consider arcs.
-			e.exprs = append(e.exprs, e.value(v, v.Conjuncts...))
-			return
+			for _, a := range v.Arcs {
+				a.Finalize(e.ctx) // TODO: should we do this?
+
+				e.addConjunct(a.Label, env, a)
+			}
+			x = v.Value
+			// e.exprs = append(e.exprs, e.value(v, v.Conjuncts...))
+			// return
 		}
 
-		e.values.AddConjunct(adt.MakeConjunct(env, x))
+		switch x.(type) {
+		case *adt.StructMarker, *adt.Top:
+		default:
+			e.values.AddConjunct(adt.MakeConjunct(env, x)) // GOBBLE TOP
+		}
 
 	case *adt.BinaryExpr:
 		switch {
@@ -225,9 +305,16 @@
 	}
 }
 
+// TODO: find a better way to annotate optionality. Maybe a special conjunct
+// or store it in the field information?
 func isOptional(a []adt.Conjunct) bool {
+	if len(a) == 0 {
+		return false
+	}
 	for _, c := range a {
 		switch f := c.Source().(type) {
+		case nil:
+			return false
 		case *ast.Field:
 			if f.Optional == token.NoPos {
 				return false
diff --git a/internal/core/export/extract.go b/internal/core/export/extract.go
index c3b11ef..22d901a 100644
--- a/internal/core/export/extract.go
+++ b/internal/core/export/extract.go
@@ -29,10 +29,14 @@
 //     foo: bar: 2
 //
 func ExtractDoc(v *adt.Vertex) (docs []*ast.CommentGroup) {
+	return extractDocs(v, v.Conjuncts)
+}
+
+func extractDocs(v *adt.Vertex, a []adt.Conjunct) (docs []*ast.CommentGroup) {
 	fields := []*ast.Field{}
 
 	// Collect docs directly related to this Vertex.
-	for _, x := range v.Conjuncts {
+	for _, x := range a {
 		f, ok := x.Source().(*ast.Field)
 		if !ok || hasShorthandValue(f) {
 			continue
@@ -46,6 +50,10 @@
 		}
 	}
 
+	if v == nil {
+		return docs
+	}
+
 	// Collect docs from parent scopes in collapsed fields.
 	for p := v.Parent; p != nil; p = p.Parent {
 
diff --git a/internal/core/export/label.go b/internal/core/export/label.go
index 0ece0a3..be73089 100644
--- a/internal/core/export/label.go
+++ b/internal/core/export/label.go
@@ -16,7 +16,6 @@
 
 import (
 	"strconv"
-	"strings"
 
 	"cuelang.org/go/cue/ast"
 	"cuelang.org/go/cue/token"
@@ -24,11 +23,25 @@
 )
 
 func (e *exporter) stringLabel(f adt.Feature) ast.Label {
-	str := f.SelectorString(e.index)
-	if strings.HasPrefix(str, "#") && !f.IsDef() ||
-		strings.HasPrefix(str, "_") && !f.IsHidden() ||
-		!ast.IsValidIdent(str) {
-		return ast.NewLit(token.STRING, strconv.Quote(str))
+	if f == 0 {
+		return ast.NewIdent("_")
 	}
-	return &ast.Ident{Name: str}
+	x := f.Index()
+	switch f.Typ() {
+	case adt.IntLabel:
+		return ast.NewLit(token.INT, strconv.Itoa(int(x)))
+
+	case adt.DefinitionLabel, adt.HiddenLabel, adt.HiddenDefinitionLabel:
+		return ast.NewIdent(e.ctx.IndexToString(int64(x)))
+
+	case adt.StringLabel:
+		s := e.ctx.IndexToString(int64(x))
+		if !ast.IsValidIdent(s) {
+			return ast.NewLit(token.STRING, strconv.Quote(s))
+		}
+		fallthrough
+
+	default:
+		return ast.NewIdent(e.ctx.IndexToString(int64(x)))
+	}
 }
diff --git a/internal/core/export/testdata/adt.txtar b/internal/core/export/testdata/adt.txtar
new file mode 100644
index 0000000..aaabe3f
--- /dev/null
+++ b/internal/core/export/testdata/adt.txtar
@@ -0,0 +1,198 @@
+-- in.cue --
+import mystrings "strings"
+
+p1: [X=string]: name: X
+
+d1: "foo\(bar)": int
+bar: "bar"
+
+// XXX: reference not resolving.
+d2: C="foo\(bar)": {
+    name: "xx"
+    foo: C.name
+}
+
+c1: mystrings.Contains("aa", "a")
+
+s1: """
+    multi
+    \(bar)
+    line
+    """
+
+l1: [3, ...int]
+l2: [...int]
+l3: []
+l4: [1, 2]
+
+n1: 1.0
+n10: 10
+
+// Ignored comment.
+
+// t is true
+t: true
+
+// Dangling comment.
+
+e1: <n1
+e2: >n1 & <n10
+e3: l4[2]
+e4: l4[2:3]
+e5: e1 + e2 - e3
+e6: !t
+e7: !t || !false
+e8?: !false
+
+m1: {
+    // this is a pattern constraint
+    {[string]: int}
+    // foo is an optional field
+    foo?: 3
+
+    // Dangling comment.
+
+    // bar is a field
+    bar: 4
+
+    // a comment too many.
+
+    ...
+}
+
+if true {
+    x: int
+}
+
+y1: {
+    src: [1, 2, 3]
+    for i, v in src for j, w in src if i < j {
+        "foo\(i)": v
+        "bar\(j)": w
+    }
+
+    for i, v in src {
+        "foo\(i)": v
+    }
+
+}
+
+-- out/definition --
+import mystrings "strings"
+
+p1: {
+	[X=string]: {
+		name: X
+	}
+}
+d1: {
+	"foo\(bar)": int
+}
+bar: "bar"
+d2: {
+	"foo\(bar)": {
+		name: "xx"
+		foo:  X.name
+	}
+}
+c1: mystrings.Contains("aa", "a")
+s1: """multi
+        
+        \(bar)
+        line
+        """
+l1: [3, ...int]
+l2: [...int]
+l3: []
+l4: [1, 2]
+n1:  1.0
+n10: 10
+t:   true
+e1:  <n1
+e2:  >n1 & <n10
+e3:  l4[2]
+e4:  l4[2:3]
+e5:  e1 + e2 - e3
+e6:  !t
+e7:  !t || !false
+e8?: !false
+m1: {
+	{
+		[string]: int
+	}
+
+	// foo is an optional field
+	foo?: 3
+
+	// bar is a field
+	bar: 4
+	...
+}
+if true {
+	x: int
+}
+y1: {
+	src: [1, 2, 3]
+	for i, v in src for j, w in src if i < j {
+		"foo\(i)": v
+		"bar\(j)": w
+	}
+	for i, v in src {
+		"foo\(i)": v
+	}
+}
+-- out/doc --
+[]
+[p1]
+[d1]
+[d1 foobar]
+[bar]
+[d2]
+- XXX: reference not resolving.
+
+[d2 foobar]
+[d2 foobar name]
+[d2 foobar foo]
+[c1]
+[s1]
+[l1]
+[l1 0]
+[l2]
+[l3]
+[l4]
+[l4 0]
+[l4 1]
+[n1]
+[n10]
+[t]
+- t is true
+
+[e1]
+[e2]
+[e3]
+[e4]
+[e5]
+[e6]
+[e7]
+[m1]
+[m1 bar]
+- bar is a field
+
+[y1]
+[y1 src]
+[y1 src 0]
+[y1 src 1]
+[y1 src 2]
+[y1 foo0]
+[y1 bar1]
+[y1 bar2]
+[y1 foo1]
+[y1 foo2]
+[x]
+-- out/value --
+== Simplified
+_|_ // undefined field 2
+== Raw
+_|_ // undefined field 2
+== All
+_|_ // undefined field 2
diff --git a/internal/core/export/testdata/docs.txtar b/internal/core/export/testdata/docs.txtar
index 63fd83a..55a8a77 100644
--- a/internal/core/export/testdata/docs.txtar
+++ b/internal/core/export/testdata/docs.txtar
@@ -91,34 +91,48 @@
 - comment from bar on field 2
 
 -- out/definition --
+// foobar defines at least foo.
+package foobar
+
+// A Foo fooses stuff.
 Foo: {
+	// field1 is an int.
 	field1: int
 	field2: int
-	dup3:   int
+
+	// duplicate field comment
+	dup3: int
 }
+
+// foos are instances of Foo.
 foos: {
 	{
-		[string]: Foo_1
+		[string]: Foo
 	}
 	MyFoo: {
+		// local field comment.
 		field1: 0
+
+		// other field comment.
 		field2: 1
-		dup3:   int
+
+		// duplicate field comment
+		dup3: int
 	}
 }
 bar: {
+	// comment from bar on field 1
 	field1: int
+	// comment from bar on field 2
 	field2: int
 }
 baz: {
-	bar_5
+	bar
+
+	// comment from baz on field 1
 	field1: int
 	field2: int
 }
-
-let Foo_1 = Foo
-
-let bar_5 = bar
 -- out/value --
 == Simplified
 {
@@ -206,3 +220,46 @@
 		field2: int
 	}
 }
+== All
+{
+	// A Foo fooses stuff.
+	Foo: {
+		// field1 is an int.
+		field1: int
+		field2: int
+
+		// duplicate field comment
+		dup3: int
+	}
+
+	// foos are instances of Foo.
+	foos: {
+		// My first little foo.
+		MyFoo: {
+			// local field comment.
+
+			// field1 is an int.
+			field1: 0
+
+			// other field comment.
+			field2: 1
+
+			// duplicate field comment
+			dup3: int
+		}
+	}
+	bar: {
+		// comment from bar on field 1
+		field1: int
+		// comment from bar on field 2
+		field2: int
+	}
+	baz: {
+		// comment from bar on field 1
+
+		// comment from baz on field 1
+		field1: int
+		// comment from bar on field 2
+		field2: int
+	}
+}
diff --git a/internal/core/export/testdata/scalardef.txtar b/internal/core/export/testdata/scalardef.txtar
index 3e5b5b3..b328ff5 100644
--- a/internal/core/export/testdata/scalardef.txtar
+++ b/internal/core/export/testdata/scalardef.txtar
@@ -22,6 +22,8 @@
 []
 [#pkg1]
 -- out/definition --
+package test
+
 import pkg2 "example.com/foo/pkg1"
 
 "Hello \(#pkg1)!"
diff --git a/internal/core/export/testdata/simplify.txtar b/internal/core/export/testdata/simplify.txtar
index c8d27e8..2ddd23b 100644
--- a/internal/core/export/testdata/simplify.txtar
+++ b/internal/core/export/testdata/simplify.txtar
@@ -28,3 +28,9 @@
 		y: >=-9223372036854775808 & <=9223372036854775807 & int
 	}
 }
+== All
+{
+	x: {
+		y: int64
+	}
+}
diff --git a/internal/core/export/testdata/topo.txtar b/internal/core/export/testdata/topo.txtar
index 2d582aa..0d40a0f 100644
--- a/internal/core/export/testdata/topo.txtar
+++ b/internal/core/export/testdata/topo.txtar
@@ -47,3 +47,12 @@
 	f: 4
 	g: 4
 }
+== All
+{
+	a: 1
+	b: 1
+	c: 2
+	e: 3
+	f: 4
+	g: 4
+}
diff --git a/internal/core/export/value.go b/internal/core/export/value.go
index bf9500a..1761dfb 100644
--- a/internal/core/export/value.go
+++ b/internal/core/export/value.go
@@ -15,6 +15,8 @@
 package export
 
 import (
+	"fmt"
+
 	"cuelang.org/go/cue/ast"
 	"cuelang.org/go/cue/ast/astutil"
 	"cuelang.org/go/cue/token"
@@ -22,16 +24,23 @@
 )
 
 func (e *exporter) bareValue(v adt.Value) ast.Expr {
+	switch x := v.(type) {
+	case *adt.Vertex:
+		return e.vertex(x)
+	case adt.Value:
+		a := &adt.Vertex{Value: x}
+		return e.vertex(a)
+	default:
+		panic("unreachable")
+	}
 	// TODO: allow a Value context wrapper.
-	a := &adt.Vertex{Value: v}
-	return e.vertex(a)
 }
 
 // TODO: if the original value was a single reference, we could replace the
 // value with a reference in graph mode.
 
 func (e *exporter) vertex(n *adt.Vertex) (result ast.Expr) {
-	switch n.Value.(type) {
+	switch x := n.Value.(type) {
 	case nil:
 		// bare
 	case *adt.StructMarker:
@@ -40,12 +49,36 @@
 	case *adt.ListMarker:
 		result = e.listComposite(n)
 
+	case *adt.Bottom:
+		if x.IsIncomplete() {
+			// fall back to expression mode
+			result = stripRefs(e.expr(n))
+			break
+		}
+		result = e.bottom(x)
+
 	default:
 		result = e.value(n.Value, n.Conjuncts...)
 	}
 	return result
 }
 
+// TODO: do something more principled. Best would be to have a similar
+// mechanism in ast.Ident as others do.
+func stripRefs(x ast.Expr) ast.Expr {
+	ast.Walk(x, nil, func(n ast.Node) {
+		switch x := n.(type) {
+		case *ast.Ident:
+			switch x.Node.(type) {
+			case *ast.ImportSpec:
+			default:
+				x.Node = nil
+			}
+		}
+	})
+	return x
+}
+
 func (e *exporter) value(n adt.Value, a ...adt.Conjunct) (result ast.Expr) {
 	// Evaluate arc if needed?
 
@@ -81,6 +114,9 @@
 	case *adt.BoundValue:
 		result = e.boundValue(x)
 
+	case *adt.Builtin:
+		result = e.builtin(x)
+
 	case *adt.BuiltinValidator:
 		result = e.builtinValidator(x)
 
@@ -88,27 +124,51 @@
 		result = e.vertex(x)
 
 	case *adt.Conjunction:
-		if len(x.Values) == 0 {
-			result = ast.NewIdent("_")
-			break
+		switch len(x.Values) {
+		case 0:
+			return ast.NewIdent("_")
+		case 1:
+			if e.cfg.Simplify {
+				return e.expr(x.Values[0])
+			}
+			return e.bareValue(x.Values[0])
 		}
 
-		a := []ast.Expr{}
+		a := []adt.Value{}
 		b := boundSimplifier{e: e}
 		for _, v := range x.Values {
 			if !e.cfg.Simplify || !b.add(v) {
-				a = append(a, e.bareValue(v))
+				a = append(a, v)
 			}
 		}
 
-		if !e.cfg.Simplify {
-			return ast.NewBinExpr(token.AND, a...)
+		result = b.expr(e.ctx)
+		if result == nil {
+			a = x.Values
 		}
 
-		result = b.expr(e.ctx) // e.bareValue(x.Values[0])
-		for _, c := range a {
-			result = &ast.BinaryExpr{X: result, Op: token.AND, Y: c}
+		for _, x := range a {
+			result = wrapBin(result, e.bareValue(x), adt.AndOp)
 		}
+
+	case *adt.Disjunction:
+		a := []ast.Expr{}
+		for i, v := range x.Values {
+			var expr ast.Expr
+			if e.cfg.Simplify {
+				expr = e.bareValue(v)
+			} else {
+				expr = e.expr(v)
+			}
+			if i < x.NumDefaults {
+				expr = &ast.UnaryExpr{Op: token.MUL, X: expr}
+			}
+			a = append(a, expr)
+		}
+		result = ast.NewBinExpr(token.OR, a...)
+
+	default:
+		panic(fmt.Sprintf("unsupported type %T", x))
 	}
 
 	// TODO: Add comments from original.
@@ -120,16 +180,6 @@
 	err := &ast.BottomLit{}
 	if x := n.Err; x != nil {
 		msg := x.Error()
-		// if len(x.sub) > 0 {
-		// 	buf := strings.Builder{}
-		// 	for i, b := range x.sub {
-		// 		if i > 0 {
-		// 			buf.WriteString("; ")
-		// 			buf.WriteString(b.msg())
-		// 		}
-		// 	}
-		// 	msg = buf.String()
-		// }
 		comment := &ast.Comment{Text: "// " + msg}
 		err.AddComment(&ast.CommentGroup{
 			Line:     true,
@@ -237,24 +287,64 @@
 }
 
 func (e *exporter) structComposite(v *adt.Vertex) ast.Expr {
-	s := &ast.StructLit{}
-	saved := e.stack
-	e.stack = append(e.stack, frame{scope: s})
-	defer func() { e.stack = saved }()
+	s, saved := e.pushFrame(v.Conjuncts)
+	e.top().upCount++
+	defer func() {
+		e.top().upCount--
+		e.popFrame(saved)
+	}()
 
-	for _, a := range e.sortedArcs(v) {
-		if a.Label.IsDef() || a.Label.IsHidden() {
+	p := e.cfg
+	for _, label := range VertexFeatures(v) {
+		if label.IsDef() && !p.ShowDefinitions {
+			continue
+		}
+		if label.IsHidden() && !p.ShowHidden {
 			continue
 		}
 
-		f := &ast.Field{
-			Label: e.stringLabel(a.Label),
-			Value: e.vertex(a),
-			Attrs: ExtractFieldAttrs(a.Conjuncts),
+		f := &ast.Field{Label: e.stringLabel(label)}
+
+		if label.IsDef() {
+			e.inDefinition++
 		}
 
-		docs := ExtractDoc(a)
-		ast.SetComments(f, docs)
+		arc := v.Lookup(label)
+		switch {
+		case arc == nil:
+			if !p.ShowOptional {
+				continue
+			}
+			f.Optional = token.NoSpace.Pos()
+
+			arc = &adt.Vertex{Label: label}
+			v.MatchAndInsert(e.ctx, arc)
+			if len(v.Conjuncts) == 0 {
+				continue
+			}
+
+			// fall back to expression mode.
+			f.Value = stripRefs(e.expr(arc))
+
+			// TODO: remove use of stripRefs.
+			// f.Value = e.expr(arc)
+
+		default:
+			f.Value = e.vertex(arc)
+		}
+
+		if label.IsDef() {
+			e.inDefinition--
+		}
+
+		if p.ShowAttributes {
+			f.Attrs = ExtractFieldAttrs(arc.Conjuncts)
+		}
+
+		if p.ShowDocs {
+			docs := ExtractDoc(arc)
+			ast.SetComments(f, docs)
+		}
 
 		s.Elts = append(s.Elts, f)
 	}
diff --git a/internal/core/export/value_test.go b/internal/core/export/value_test.go
index 6b89513..2467c3d 100644
--- a/internal/core/export/value_test.go
+++ b/internal/core/export/value_test.go
@@ -59,6 +59,7 @@
 		}{
 			{"Simplified", Simplified.Value},
 			{"Raw", Raw.Value},
+			{"All", All.Value},
 		} {
 			fmt.Fprintln(t, "==", tc.name)
 			x, errs := tc.fn(r, v)