diff --git a/cue/testdata/comprehensions/incomplete.txtar b/cue/testdata/comprehensions/incomplete.txtar
index 1d4b4cf..5381c49 100644
--- a/cue/testdata/comprehensions/incomplete.txtar
+++ b/cue/testdata/comprehensions/incomplete.txtar
@@ -1,19 +1,26 @@
 -- in.cue --
 cond: bool
-src: {}
+src:  {}
+top:  _
 a: [ if cond {} ]
 b: [ for x in src.foo {} ]
+c: { for x in top {} }
 -- out/eval --
 (struct){
   cond: (bool){ bool }
   src: (struct){
   }
+  top: (_){ _ }
   a: (_|_){
     // [incomplete] a: incomplete bool value 'bool'
   }
   b: (_|_){
     // [incomplete] b: undefined field foo:
-    //     ./in.cue:4:19
+    //     ./in.cue:5:19
+  }
+  c: (_|_){
+    // [incomplete] c: incomplete feed source value top (type _):
+    //     ./in.cue:6:15
   }
 }
 -- out/compile --
@@ -21,10 +28,14 @@
 {
   cond: bool
   src: {}
+  top: _
   a: [
     if 〈0;cond〉 {},
   ]
   b: [
     for _, x in 〈0;src〉.foo {},
   ]
+  c: {
+    for _, x in 〈1;top〉 {}
+  }
 }
diff --git a/cue/testdata/scalars/embed.txtar b/cue/testdata/scalars/embed.txtar
new file mode 100644
index 0000000..e3c9e28
--- /dev/null
+++ b/cue/testdata/scalars/embed.txtar
@@ -0,0 +1,125 @@
+-- in.cue --
+import "strings"
+
+a1: {
+    2
+}
+a2: {
+    v: {
+        3
+        #foo: a2.v + 1
+    }
+    w: v
+    x: v.#foo
+}
+a3: a1 + a2.v
+
+b3: {
+    [1, 2]
+    #foo: 1
+}
+b4: b3 + b3
+b5: b3[1]
+b6: b3[5]
+b7: b4[a1] // 1
+
+s1: {
+    "foo"
+    #bar: "bar"
+}
+s2: [ s1, { s1.#bar, #baz: 4 } ]
+s3: strings.Join(s2, "--")
+
+-- out/eval --
+Errors:
+b6: invalid list index 5 (out of bounds):
+    ./in.cue:22:8
+
+Result:
+(_|_){
+  // [eval]
+  a1: (int){ 2 }
+  a2: (struct){
+    v: (int){
+      3
+      #foo: (int){ 4 }
+    }
+    w: (int){
+      3
+      #foo: (int){ 4 }
+    }
+    x: (int){ 4 }
+  }
+  a3: (int){ 5 }
+  b3: (#list){
+    #foo: (int){ 1 }
+    0: (int){ 1 }
+    1: (int){ 2 }
+  }
+  b4: (#list){
+    0: (int){ 1 }
+    1: (int){ 2 }
+    2: (int){ 1 }
+    3: (int){ 2 }
+  }
+  b5: (int){ 2 }
+  b6: (_|_){
+    // [eval] b6: invalid list index 5 (out of bounds):
+    //     ./in.cue:22:8
+  }
+  b7: (int){ 1 }
+  s1: (string){
+    "foo"
+    #bar: (string){ "bar" }
+  }
+  s2: (#list){
+    0: (string){
+      "foo"
+      #bar: (string){ "bar" }
+    }
+    1: (string){
+      "bar"
+      #baz: (int){ 4 }
+    }
+  }
+  s3: (string){ "foo--bar" }
+}
+-- out/compile --
+--- in.cue
+{
+  a1: {
+    2
+  }
+  a2: {
+    v: {
+      3
+      #foo: (〈2;a2〉.v + 1)
+    }
+    w: 〈0;v〉
+    x: 〈0;v〉.#foo
+  }
+  a3: (〈0;a1〉 + 〈0;a2〉.v)
+  b3: {
+    [
+      1,
+      2,
+    ]
+    #foo: 1
+  }
+  b4: (〈0;b3〉 + 〈0;b3〉)
+  b5: 〈0;b3〉[1]
+  b6: 〈0;b3〉[5]
+  b7: 〈0;b4〉[〈0;a1〉]
+  s1: {
+    "foo"
+    #bar: "bar"
+  }
+  s2: [
+    〈0;s1〉,
+    {
+      〈1;s1〉.#bar
+      #baz: 4
+    },
+  ]
+  s3: 〈import;strings〉.Join(〈0;s2〉, "--")
+}
diff --git a/internal/core/adt/composite.go b/internal/core/adt/composite.go
index 2e8806c..e5aeba4 100644
--- a/internal/core/adt/composite.go
+++ b/internal/core/adt/composite.go
@@ -228,10 +228,6 @@
 	// nodeContext to allow reusing the computations done so far.
 	Partial
 
-	// FieldSetDefined indicates that the value and conjuncts of all fields have
-	// been completed, but that the individual arcs are not yet evaluated.
-	FieldSetDefined
-
 	// EvaluatingArcs indicates that the arcs of the Vertex are currently being
 	// evaluated. If this is encountered it indicates a structural cycle.
 	// Value does not have to be nil
diff --git a/internal/core/adt/context.go b/internal/core/adt/context.go
index 5b52a18..3ae8892 100644
--- a/internal/core/adt/context.go
+++ b/internal/core/adt/context.go
@@ -387,7 +387,7 @@
 
 	v, complete := c.Evaluate(env, x)
 
-	v, ok := c.getDefault(v)
+	v, ok := c.getDefault(v, true)
 	if !ok {
 		return v, false
 	}
@@ -406,13 +406,14 @@
 	return v, true
 }
 
-func (c *OpContext) getDefault(v Value) (result Value, ok bool) {
+func (c *OpContext) getDefault(v Value, scalar bool) (result Value, ok bool) {
 	var d *Disjunction
 	switch x := v.(type) {
 	default:
 		return v, true
 
 	case *Vertex:
+		// TODO: return vertex if not disjunction.
 		switch t := x.Value.(type) {
 		case *Disjunction:
 			d = t
@@ -420,7 +421,13 @@
 		case *StructMarker, *ListMarker:
 			return v, true
 
+		case *Vertex:
+			return c.getDefault(t, scalar)
+
 		default:
+			if !scalar {
+				return v, true
+			}
 			return t, true
 		}
 
@@ -433,7 +440,7 @@
 			"unresolved disjunction %s (type %s)", c.Str(d), d.Kind())
 		return nil, false
 	}
-	return c.getDefault(d.Values[0])
+	return c.getDefault(d.Values[0], scalar)
 }
 
 // Evaluate evaluates an expression within the given environment and indicates
@@ -473,12 +480,14 @@
 func (c *OpContext) value(x Expr) (result Value) {
 	v := c.evalState(x, Partial)
 
-	v, _ = c.getDefault(v)
+	v, _ = c.getDefault(v, true)
 	return v
 }
 
-func (c *OpContext) eval(v Expr) (result Value) {
-	return c.evalState(v, Partial)
+func (c *OpContext) eval(x Expr) (result Value) {
+	v := c.evalState(x, Partial)
+	return v
+
 }
 
 func (c *OpContext) evalState(v Expr, state VertexStatus) (result Value) {
@@ -626,36 +635,43 @@
 	return x.Source().Pos()
 }
 
-func (c *OpContext) node(x Expr, state VertexStatus) *Vertex {
-	v := c.evalState(x, state)
+func (c *OpContext) node(x Expr, scalar bool) *Vertex {
+	v := c.evalState(x, EvaluatingArcs)
 
-	v, ok := c.getDefault(v)
+	v, ok := c.getDefault(v, scalar)
 	if !ok {
 		// Error already generated by getDefault.
 		return emptyNode
 	}
 
 	node, ok := v.(*Vertex)
-	if !ok {
-		if isError(v) {
-			if v == nil {
-				c.addErrf(IncompleteError, pos(x), "incomplete value %s", c.Str(x))
-				return emptyNode
-			}
-		}
+	if ok {
+		v = node.Value
+	}
+	switch nv := v.(type) {
+	case nil:
+		c.addErrf(IncompleteError, pos(x), "incomplete value %s", c.Str(x))
+		return emptyNode
+
+	case *Bottom:
+		c.AddBottom(nv)
+		return emptyNode
+
+	case *StructMarker, *ListMarker:
+
+	default:
 		if v.Kind()&StructKind != 0 {
 			c.addErrf(IncompleteError, pos(x),
 				"incomplete feed source value %s (type %s)",
 				x.Source(), v.Kind())
-		} else if b, ok := v.(*Bottom); ok {
-			c.AddBottom(b)
-		} else {
+			return emptyNode
+
+		} else if !ok {
 			c.addErrf(0, pos(x), // TODO(error): better message.
 				"invalid operand %s (found %s, want list or struct)",
 				x.Source(), v.Kind())
-
+			return emptyNode
 		}
-		return emptyNode
 	}
 	return node.Default()
 }
diff --git a/internal/core/adt/expr.go b/internal/core/adt/expr.go
index e0f7819..a2dd75f 100644
--- a/internal/core/adt/expr.go
+++ b/internal/core/adt/expr.go
@@ -585,7 +585,7 @@
 }
 
 func (x *SelectorExpr) resolve(c *OpContext) *Vertex {
-	n := c.node(x.X, FieldSetDefined)
+	n := c.node(x.X, x.Sel.IsRegular())
 	return c.lookup(n, x.Src.Sel.Pos(), x.Sel)
 }
 
@@ -608,7 +608,7 @@
 
 func (x *IndexExpr) resolve(ctx *OpContext) *Vertex {
 	// TODO: support byte index.
-	n := ctx.node(x.X, EvaluatingArcs)
+	n := ctx.node(x.X, true)
 	i := ctx.value(x.Index)
 	f := ctx.Label(i)
 	return ctx.lookup(n, x.Src.Index.Pos(), f)
@@ -1174,7 +1174,7 @@
 }
 
 func (x *ForClause) yield(c *OpContext, f YieldFunc) {
-	n := c.node(x.Src, EvaluatingArcs)
+	n := c.node(x.Src, true)
 	for _, a := range n.Arcs {
 		c.Unify(c, a, Partial)
 
diff --git a/internal/core/eval/eval.go b/internal/core/eval/eval.go
index 885a719..d323938 100644
--- a/internal/core/eval/eval.go
+++ b/internal/core/eval/eval.go
@@ -145,6 +145,7 @@
 // can be the only value in a valid configuration. This means that an error
 // may go undetected at this point, as long as it is caught later.
 //
+// TODO: return *adt.Vertex
 func (e *Evaluator) Evaluate(c *adt.OpContext, v *adt.Vertex) adt.Value {
 	var resultValue adt.Value
 
@@ -235,17 +236,14 @@
 		// TODO: Store if concrete and fully resolved.
 	}
 
-	switch v.Value.(type) {
-	case nil:
-		// Error saved in result.
-		return resultValue // incomplete
-
-	case *adt.ListMarker, *adt.StructMarker:
-		return v
-
-	default:
-		return v.Value
+	// TODO: Use this and ensure that each use of Evaluate handles
+	// struct numbers correctly. E.g. by using a function that
+	// gets the concrete value.
+	//
+	if v.Value == nil {
+		return resultValue
 	}
+	return v
 }
 
 // Unify implements adt.Unifier.
diff --git a/internal/core/export/export.go b/internal/core/export/export.go
index 5902187..880f49f 100644
--- a/internal/core/export/export.go
+++ b/internal/core/export/export.go
@@ -385,6 +385,11 @@
 	frame.fields[label] = entry
 }
 
+func (e *exporter) addEmbed(x ast.Expr) {
+	frame := e.top()
+	frame.scope.Elts = append(frame.scope.Elts, x)
+}
+
 func (e *exporter) pushFrame(conjuncts []adt.Conjunct) (s *ast.StructLit, saved []frame) {
 	saved = e.stack
 	s = &ast.StructLit{}
diff --git a/internal/core/export/testdata/embedscalar.txtar b/internal/core/export/testdata/embedscalar.txtar
new file mode 100644
index 0000000..4302de6
--- /dev/null
+++ b/internal/core/export/testdata/embedscalar.txtar
@@ -0,0 +1,87 @@
+-- in.cue --
+#top: 4
+sub: {
+    #sub: 5
+    a: {
+        3
+        #foo: 4
+    }
+    b: {
+        [1, 2]
+        #bar: 5
+        #baz: "foo"
+    }
+}
+-- out/definition --
+#top: 4
+sub: {
+	#sub: 5
+	a: {
+		3
+		#foo: 4
+	}
+	b: {
+		[1, 2]
+		#bar: 5
+		#baz: "foo"
+	}
+}
+-- out/doc --
+[]
+[#top]
+[sub]
+[sub #sub]
+[sub a]
+[sub a #foo]
+[sub b]
+[sub b #bar]
+[sub b #baz]
+[sub b 0]
+[sub b 1]
+-- out/value --
+== Simplified
+{
+	sub: {
+		a: 3
+		b: [1, 2]
+	}
+}
+== Raw
+{
+	#top: 4
+	sub: {
+		#sub: 5
+		a: {
+			3
+			#foo: 4
+		}
+		b: {
+			#bar: 5
+			#baz: "foo"
+			[1, 2]
+		}
+	}
+}
+== Final
+{
+	sub: {
+		a: 3
+		b: [1, 2]
+	}
+}
+== All
+{
+	#top: 4
+	sub: {
+		#sub: 5
+		a: {
+			3
+			#foo: 4
+		}
+		b: {
+			#bar: 5
+			#baz: "foo"
+			[1, 2]
+		}
+	}
+}
diff --git a/internal/core/export/value.go b/internal/core/export/value.go
index 7bf8f11..7b5e99f 100644
--- a/internal/core/export/value.go
+++ b/internal/core/export/value.go
@@ -48,7 +48,11 @@
 		result = e.structComposite(n)
 
 	case *adt.ListMarker:
-		result = e.listComposite(n)
+		if e.showArcs(n) {
+			result = e.structComposite(n)
+		} else {
+			result = e.listComposite(n)
+		}
 
 	case *adt.Bottom:
 		if !x.IsIncomplete() || len(n.Conjuncts) == 0 {
@@ -64,7 +68,11 @@
 		result = ast.NewBinExpr(token.AND, a...)
 
 	default:
-		result = e.value(n.Value, n.Conjuncts...)
+		if e.showArcs(n) {
+			result = e.structComposite(n)
+		} else {
+			result = e.value(n.Value, n.Conjuncts...)
+		}
 	}
 	return result
 }
@@ -297,6 +305,22 @@
 	return l
 }
 
+func (e exporter) showArcs(v *adt.Vertex) bool {
+	p := e.cfg
+	if !p.ShowHidden && !p.ShowDefinitions {
+		return false
+	}
+	for _, a := range v.Arcs {
+		switch {
+		case a.Label.IsDef() && p.ShowDefinitions:
+			return true
+		case a.Label.IsHidden() && p.ShowHidden:
+			return true
+		}
+	}
+	return false
+}
+
 func (e *exporter) structComposite(v *adt.Vertex) ast.Expr {
 	s, saved := e.pushFrame(v.Conjuncts)
 	e.top().upCount++
@@ -305,18 +329,32 @@
 		e.popFrame(saved)
 	}()
 
+	showRegular := false
+	switch x := v.Value.(type) {
+	case *adt.StructMarker:
+		showRegular = true
+	case *adt.ListMarker:
+		// As lists may be long, put them at the end.
+		defer e.addEmbed(e.listComposite(v))
+	default:
+		e.addEmbed(e.value(x))
+	}
+
 	p := e.cfg
 	for _, label := range VertexFeatures(v) {
-		if label.IsDef() && !p.ShowDefinitions {
+		show := false
+		switch label.Typ() {
+		case adt.StringLabel:
+			show = showRegular
+		case adt.IntLabel:
 			continue
+		case adt.DefinitionLabel:
+			show = p.ShowDefinitions
+		case adt.HiddenLabel, adt.HiddenDefinitionLabel:
+			show = p.ShowHidden && label.PkgID(e.ctx) == e.pkgID
 		}
-		if label.IsHidden() {
-			if !p.ShowHidden {
-				continue
-			}
-			if label.PkgID(e.ctx) != e.pkgID {
-				continue
-			}
+		if !show {
+			continue
 		}
 
 		f := &ast.Field{Label: e.stringLabel(label)}