diff --git a/cmd/cue/cmd/eval.go b/cmd/cue/cmd/eval.go
index e68f614..a63a7d6 100644
--- a/cmd/cue/cmd/eval.go
+++ b/cmd/cue/cmd/eval.go
@@ -110,6 +110,8 @@
 			fmt.Fprintf(w, "\n// %s\n", inst.Dir)
 		}
 		syn := []cue.Option{
+			cue.Final(), // for backwards compatibility
+			cue.Definitions(true),
 			cue.Attributes(flagAttributes.Bool(cmd)),
 			cue.Optional(flagAll.Bool(cmd) || flagOptional.Bool(cmd)),
 		}
diff --git a/cmd/cue/cmd/testdata/script/eval_rec.txt b/cmd/cue/cmd/testdata/script/eval_rec.txt
index 5522df3..5d3a94c 100644
--- a/cmd/cue/cmd/testdata/script/eval_rec.txt
+++ b/cmd/cue/cmd/testdata/script/eval_rec.txt
@@ -15,21 +15,15 @@
 }
 -- expect-stdout --
 Foo: {
-    foo?: {
-        bar: string
-        baz: bar + "2"
-    }
-    bar: string
-    baz: bar + "2"
+    foo?: Foo
+    bar:  string
+    baz:  bar + "2"
 }
 foo: {
     foo: {
-        foo?: {
-            bar: string
-            baz: bar + "2"
-        }
-        bar: "barNested"
-        baz: "barNested2"
+        foo?: Foo
+        bar:  "barNested"
+        baz:  "barNested2"
     }
     bar: "barParent"
     baz: "barParent2"
diff --git a/cue/builtin.go b/cue/builtin.go
index a7479d7..3f8c7b9 100644
--- a/cue/builtin.go
+++ b/cue/builtin.go
@@ -299,8 +299,12 @@
 			ret = err.err
 			ret = ctx.mkErr(src, x, ret, "error in call to %s: %v", x.name(ctx), err)
 		default:
-			// TODO: store the underlying error explicitly
-			ret = ctx.mkErr(src, x, "error in call to %s: %v", x.name(ctx), err)
+			if call.err == internal.ErrIncomplete {
+				ret = ctx.mkErr(src, codeIncomplete, "incomplete value")
+			} else {
+				// TODO: store the underlying error explicitly
+				ret = ctx.mkErr(src, x, "error in call to %s: %v", x.name(ctx), err)
+			}
 		}
 	}()
 	x.Func(&call)
diff --git a/cue/export.go b/cue/export.go
index 5ab732f..80d2255 100644
--- a/cue/export.go
+++ b/cue/export.go
@@ -35,7 +35,7 @@
 }
 
 func export(ctx *context, v value, m options) (n ast.Node, imports []string) {
-	e := exporter{ctx, m, nil, map[label]bool{}, map[string]importInfo{}, false}
+	e := exporter{ctx, m, nil, map[label]bool{}, map[string]importInfo{}, false, nil}
 	top, ok := v.evalPartial(ctx).(*structLit)
 	if ok {
 		top, err := top.expandFields(ctx)
@@ -94,6 +94,12 @@
 	top     map[label]bool        // label to alias or ""
 	imports map[string]importInfo // pkg path to info
 	inDef   bool                  // TODO(recclose):use count instead
+
+	incomplete []source
+}
+
+func (p *exporter) addIncomplete(v value) {
+	// TODO: process incomplete values
 }
 
 type importInfo struct {
@@ -260,7 +266,7 @@
 func (p *exporter) closeOrOpen(s *ast.StructLit, isClosed bool) ast.Expr {
 	// Note, there is no point in printing close if we are dropping optional
 	// fields, as by this the meaning of close will change anyway.
-	if !p.showOptional() {
+	if !p.showOptional() || p.mode.final {
 		return s
 	}
 	if isClosed && !p.inDef && !hasTemplate(s) {
@@ -277,9 +283,20 @@
 	case *numLit, *stringLit, *bytesLit, *nullLit, *boolLit:
 		return true
 	case *list:
+		if p.mode.final || !all {
+			return true
+		}
+		if x.isOpen() {
+			return false
+		}
+		for i := range x.elem.arcs {
+			if !p.isComplete(x.at(p.ctx, i), all) {
+				return false
+			}
+		}
 		return true
 	case *structLit:
-		return !all
+		return !all && p.mode.final
 	case *bottom:
 		return !isIncomplete(x)
 	case *closeIfStruct:
@@ -299,16 +316,39 @@
 }
 
 func (p *exporter) recExpr(v value, e evaluated, optional bool) ast.Expr {
-	m := p.ctx.manifest(e)
-	if optional || (!p.isComplete(m, false) && (!p.mode.concrete)) {
+	var m evaluated
+	if !p.mode.final {
+		m = e.evalPartial(p.ctx)
+	} else {
+		m = p.ctx.manifest(e)
+	}
+	isComplete := p.isComplete(m, false)
+	if optional || (!isComplete && (!p.mode.concrete)) {
+		resolve := p.mode.resolveReferences && !optional
+		if !p.mode.final && v.kind().hasReferences() && !resolve {
+			return p.expr(v)
+		}
+		if p.mode.concrete && !m.kind().isGround() {
+			p.addIncomplete(v)
+		}
 		// TODO: do something more principled than this hack.
 		// This likely requires disjunctions to keep track of original
 		// values (so using arcs instead of values).
-		p := &exporter{p.ctx, options{concrete: true, raw: true}, p.stack, p.top, p.imports, p.inDef}
+		opts := options{concrete: true, raw: true}
+		p := &exporter{p.ctx, opts, p.stack, p.top, p.imports, p.inDef, nil}
 		if isDisjunction(v) || isBottom(e) {
 			return p.expr(v)
 		}
-		return p.expr(e)
+		if v.kind()&structKind == 0 {
+			return p.expr(e)
+		}
+		if optional {
+			// Break cycles: final and resolveReferences really should not be
+			// used with optional.
+			p.mode.resolveReferences = false
+			p.mode.final = false
+			return p.expr(v)
+		}
 	}
 	return p.expr(e)
 }
@@ -332,14 +372,25 @@
 	// as well.
 	if doEval(p.mode) || p.mode.concrete {
 		e := v.evalPartial(p.ctx)
-		x := p.ctx.manifest(e)
+		x := e
+		if p.mode.final {
+			x = p.ctx.manifest(e)
+		}
 
 		if !p.isComplete(x, true) {
+			if p.mode.concrete && !x.kind().isGround() {
+				p.addIncomplete(v)
+			}
 			if isBottom(e) {
-				p = &exporter{p.ctx, options{raw: true}, p.stack, p.top, p.imports, p.inDef}
+				if p.mode.concrete {
+					p.addIncomplete(v)
+				}
+				p = &exporter{p.ctx, options{raw: true}, p.stack, p.top, p.imports, p.inDef, nil}
 				return p.expr(v)
 			}
-			if doEval(p.mode) {
+			switch {
+			case !p.mode.final && v.kind().hasReferences() && !p.mode.resolveReferences:
+			case doEval(p.mode):
 				v = e
 			}
 		} else {
diff --git a/cue/export_test.go b/cue/export_test.go
index 51f5202..2f8a27a 100644
--- a/cue/export_test.go
+++ b/cue/export_test.go
@@ -318,7 +318,7 @@
 			job: {
 				list: {
 					name:     "list"
-					replicas: 1 @protobuf(10)
+					replicas: >=0 | *1 @protobuf(10)
 					command:  "ls"
 				}
 				nginx: {
@@ -396,23 +396,14 @@
 				bar: baz: 3
 			}
 			def :: {
-				a: 1
-				sub: {
-					foo: 1
-					bar: baz: 3
-				}
+				a:   1
+				sub: reg
 			}
-			val: {
-				a: 1
-				sub: {
-					foo: 1
-					bar: baz: 3
-				}
-			}
+			val: def
 			def2 :: {
 				a: b: int
 			}
-			val2: a: b: int
+			val2: def2
 		}`),
 	}, {
 		raw:  true,
@@ -437,7 +428,7 @@
 				}
 			}][a]
 			a: int
-			c: 1
+			c: *1 | 2
 		}`),
 	}, {
 		raw: true,
@@ -485,7 +476,7 @@
 				FindInMap :: {
 					"Fn::FindInMap" :: [string | FindInMap]
 				}
-				a: []
+				a: [...string]
 			}`)}, {
 		raw:   true,
 		eval:  true,
@@ -501,14 +492,15 @@
 		out: unindent(`
 			{
 				And :: {
-					"Fn::And": []
+					"Fn::And": [...3 | And]
 				}
-				Ands: "Fn::And": [3 | And]
+				Ands: And & {
+					"Fn::And": [_]
+				}
 			}`),
 	}, {
-		raw:   true,
-		eval:  true,
-		noOpt: true,
+		raw:  true,
+		eval: true,
 		in: `{
 			Foo :: {
 				sgl: Bar
@@ -527,19 +519,13 @@
 		out: unindent(`
 		{
 			FOO = Foo
-			FOO658221 = Foo
 			Foo :: {
-				Foo: 2
-				sgl: string
-				ref: null | {
-					Foo:  2
-					sgl:  Bar
-					ref:  (null | FOO) & (null | FOO)
-					ext:  Bar | null
-					ref2: null | FOO.sgl
-				}
+				Foo:  2
+				sgl:  Bar
+				ref:  (null | FOO) & (null | FOO)
 				ext:  Bar | null
-				ref2: null | FOO658221.sgl
+				ref2: null | FOO.sgl
+				...
 			}
 			Bar :: string
 		}`),
@@ -553,7 +539,7 @@
 		out: unindent(`
 		{
 			A: [>=0]
-			B: [10] | [192]
+			B: A & ([10] | [192])
 		}`),
 	}, {
 		in: `{
@@ -694,6 +680,9 @@
 
 		B: {}
 		B: {a: int} | {b: int}
+
+		C :: [D]: int
+		D :: string
 		`,
 		out: unindent(`
 		{
@@ -706,6 +695,11 @@
 			} | {
 				b: int
 			})
+			C :: {
+				[D]: int
+				[D]: int
+			}
+			D :: string
 		}`),
 	}, {
 		in: `
@@ -725,6 +719,7 @@
 		// a closed struct unified with a struct with a template restrictions is
 		// exported as a conjunction of two structs.
 		eval: true,
+		opts: []Option{ResolveReferences(true)},
 		in: `
 		A :: { b: int }
 		a: A & { [string]: <10 }
@@ -744,6 +739,7 @@
 		}`),
 	}, {
 		eval: true,
+		opts: []Option{Final()},
 		in: `{
 			reg: { foo: 1, bar: { baz: 3 } }
 			def :: {
@@ -759,27 +755,17 @@
 				foo: 1
 				bar: baz: 3
 			}
-			def :: {
-				a: 1
-				sub: {
-					foo: 1
-					bar: {
-						baz: 3
-						...
-					}
-					...
-				}
-			}
-			val: close({
+			val: {
 				a: 1
 				sub: {
 					foo: 1
 					bar: baz: 3
 				}
-			})
+			}
 		}`),
 	}, {
 		eval: true,
+		opts: []Option{ResolveReferences(true)},
 		in: `
 			T :: {
 				[_]: int64
@@ -805,7 +791,7 @@
 		}`),
 	}, {
 		eval: true,
-		opts: []Option{Optional(false)},
+		opts: []Option{Optional(false), ResolveReferences(true)},
 		in: `
 		T :: {
 			[_]: int64
@@ -826,6 +812,7 @@
 		}`),
 	}, {
 		eval: true,
+		opts: []Option{ResolveReferences(true)},
 		in: `{
 				reg: { foo: 1, bar: { baz: 3 } }
 				def :: {
@@ -888,6 +875,7 @@
 		}`),
 	}, {
 		eval: true,
+		opts: []Option{ResolveReferences(true)},
 		in: `
 		A :: {
 			[=~"^[a-s]*$"]: int
@@ -937,10 +925,93 @@
 			x: [string]: int
 			a: [P=string]: {
 				b: x[P]
-				c: string
+				c: P
 				e: len(P)
 			}
 		}`),
+	}, {
+		eval: true,
+		in: `
+		list: [...string]
+		foo: 1 | 2 | *3
+		foo: int
+		`,
+		out: unindent(`
+		{
+			list: [...string]
+			foo: 1 | 2 | *3
+		}`),
+	}, {
+		eval: true,
+		opts: []Option{Final()},
+		in: `
+		list: [...string]
+		foo: 1 | 2 | *3
+		foo: int
+		`,
+		out: unindent(`
+		{
+			list: []
+			foo: 3
+		}`),
+	}, {
+		// Expand final values, not values that may still be incomplete.
+		eval: true,
+		in: `
+		import "math"
+		import "tool/exec"
+
+		A :: {
+			b: 3
+		}
+
+		a:   A
+		pi:  math.Pi
+		run: exec.Run
+		`,
+		out: unindent(`
+		import "tool/exec"
+
+		A :: {
+			b: 3
+		}
+		a:   A
+		pi:  3.14159265358979323846264338327950288419716939937510582097494459
+		run: exec.Run`),
+	}, {
+		// Change mode midway to break cycle.
+		eval: true,
+		opts: []Option{Final(), Optional(true)},
+		in: `
+		Foo: {
+			foo?: Foo
+			bar:  string
+			baz:  bar + "2"
+		}
+
+		foo: Foo & {
+			foo: {
+				bar: "barNested"
+			}
+			bar: "barParent"
+		}`,
+		out: unindent(`
+		{
+			Foo: {
+				foo?: Foo
+				bar:  string
+				baz:  bar + "2"
+			}
+			foo: {
+				foo: {
+					foo?: Foo
+					bar:  "barNested"
+					baz:  "barNested2"
+				}
+				bar: "barParent"
+				baz: "barParent2"
+			}
+		}`),
 	}}
 	for _, tc := range testCases {
 		t.Run("", func(t *testing.T) {
diff --git a/cue/types.go b/cue/types.go
index ed269a7..79024cc 100644
--- a/cue/types.go
+++ b/cue/types.go
@@ -1636,15 +1636,16 @@
 }
 
 type options struct {
-	concrete        bool // enforce that values are concrete
-	raw             bool // show original values
-	hasHidden       bool
-	omitHidden      bool
-	omitDefinitions bool
-	omitOptional    bool
-	omitAttrs       bool
-	final           bool
-	disallowCycles  bool // implied by concrete
+	concrete          bool // enforce that values are concrete
+	raw               bool // show original values
+	hasHidden         bool
+	omitHidden        bool
+	omitDefinitions   bool
+	omitOptional      bool
+	omitAttrs         bool
+	resolveReferences bool
+	final             bool
+	disallowCycles    bool // implied by concrete
 }
 
 // An Option defines modes of evaluation.
@@ -1655,7 +1656,12 @@
 // Final indicates a value is final. It implicitly closes all structs and lists
 // in a value and selects defaults.
 func Final() Option {
-	return func(o *options) { o.final = true }
+	return func(o *options) {
+		o.final = true
+		o.omitDefinitions = true
+		o.omitOptional = true
+		o.omitHidden = true
+	}
 }
 
 // Concrete ensures that all values are concrete.
@@ -1666,6 +1672,7 @@
 	return func(p *options) {
 		if concrete {
 			p.concrete = true
+			p.final = true
 			if !p.hasHidden {
 				p.omitHidden = true
 				p.omitDefinitions = true
@@ -1680,6 +1687,12 @@
 	return func(p *options) { p.disallowCycles = disallow }
 }
 
+// ResolveReferences forces the evaluation of references when outputting.
+// This implies the input cannot have cycles.
+func ResolveReferences(resolve bool) Option {
+	return func(p *options) { p.resolveReferences = resolve }
+}
+
 // Raw tells Syntax to generate the value as is without any simplifications.
 func Raw() Option {
 	return func(p *options) { p.raw = true }
diff --git a/internal/internal.go b/internal/internal.go
index 16f1e44..17af682 100644
--- a/internal/internal.go
+++ b/internal/internal.go
@@ -26,6 +26,7 @@
 	"github.com/cockroachdb/apd/v2"
 
 	"cuelang.org/go/cue/ast"
+	"cuelang.org/go/cue/errors"
 	"cuelang.org/go/cue/token"
 )
 
@@ -37,6 +38,10 @@
 // DebugStr prints a syntax node.
 var DebugStr func(x interface{}) string
 
+// ErrIncomplete can be used by builtins to signal the evaluation was
+// incomplete.
+var ErrIncomplete = errors.New("incomplete value")
+
 // EvalExpr evaluates an expression within an existing struct value.
 // Identifiers only resolve to values defined within the struct.
 //