diff --git a/cmd/cue/cmd/testdata/script/vet_expr.txt b/cmd/cue/cmd/testdata/script/vet_expr.txt
index e96888c..5381795 100644
--- a/cmd/cue/cmd/testdata/script/vet_expr.txt
+++ b/cmd/cue/cmd/testdata/script/vet_expr.txt
@@ -2,14 +2,19 @@
 cmp stderr expect-stderr
 
 -- expect-stderr --
+translations.hello.lang: incomplete value (string):
+    ./vet.cue:3:11
+translations.hello.lang: conflicting values false and string (mismatched types bool and string):
+    ./data.yaml:13:11
+    ./vet.cue:3:11
 field "skip" not allowed in closed struct:
-    ./vet.cue:4:9
+    ./vet.cue:1:9
 -- vet.cue --
-
-translations <_> lang: string
-
 File :: {
-	translations: {...}
+	translations <_>: {
+    lang: string
+    text: string
+  }
 }
 -- data.yaml --
 # translated messages
diff --git a/cue/ast.go b/cue/ast.go
index a4ac89f..f134276 100644
--- a/cue/ast.go
+++ b/cue/ast.go
@@ -277,7 +277,9 @@
 		if v.ctx().inDefinition > 0 {
 			// For embeddings this is handled in binOp, in which case the
 			// isClosed bit is cleared if a template is introduced.
-			obj.isClosed = obj.template == nil
+			if obj.template == nil {
+				obj.closeStatus = toClose
+			}
 		}
 		if passDoc {
 			v.doc = v1.doc // signal usage of document back to parent.
diff --git a/cue/binop.go b/cue/binop.go
index 0bec239..152b8ac 100644
--- a/cue/binop.go
+++ b/cue/binop.go
@@ -625,7 +625,7 @@
 		binSrc(src.Pos(), op, x, other), // baseValue
 		x.emit,                          // emit
 		nil,                             // template
-		x.isClosed || y.isClosed,        // isClosed
+		x.closeStatus | y.closeStatus,   // closeStatus
 		nil,                             // comprehensions
 		arcs,                            // arcs
 		nil,                             // attributes
@@ -725,7 +725,7 @@
 	sort.Stable(obj)
 
 	if unchecked && obj.template != nil {
-		obj.isClosed = false
+		obj.closeStatus = 0
 	}
 
 	return obj
diff --git a/cue/copy.go b/cue/copy.go
index 335a29d..6c80735 100644
--- a/cue/copy.go
+++ b/cue/copy.go
@@ -31,7 +31,7 @@
 	case *structLit:
 		arcs := make(arcs, len(x.arcs))
 
-		obj := &structLit{x.baseValue, nil, nil, x.isClosed, nil, arcs, nil}
+		obj := &structLit{x.baseValue, nil, nil, x.closeStatus, nil, arcs, nil}
 
 		defer ctx.pushForwards(x, obj).popForwards()
 
diff --git a/cue/debug.go b/cue/debug.go
index bb130bf..ca3e970 100644
--- a/cue/debug.go
+++ b/cue/debug.go
@@ -273,7 +273,7 @@
 		if p.showNodeRef {
 			p.writef("<%s>", p.ctx.ref(x))
 		}
-		if x.isClosed {
+		if x.closeStatus != 0 {
 			write("C")
 		}
 		write("{")
@@ -301,7 +301,7 @@
 				p.write(", ")
 			}
 		}
-		if topDefault && !x.isClosed {
+		if topDefault && x.closeStatus == 0 {
 			if len(x.arcs) > 0 {
 				p.write(", ")
 			}
diff --git a/cue/eval.go b/cue/eval.go
index 7a3dea9..59e1ffd 100644
--- a/cue/eval.go
+++ b/cue/eval.go
@@ -67,7 +67,7 @@
 		}
 		if n.val() == nil {
 			field := ctx.labelStr(x.feature)
-			if st, ok := sc.(*structLit); ok && !st.isClosed {
+			if st, ok := sc.(*structLit); ok && !st.isClosed() {
 				return ctx.mkErr(x, codeIncomplete, "undefined field %q", field)
 			}
 			//	m.foo undefined (type map[string]bool has no field or method foo)
@@ -109,7 +109,7 @@
 				return ctx.mkErr(x, index, codeIncomplete, "field %q is optional", s)
 			}
 			if n.val() == nil {
-				if !v.isClosed {
+				if !v.isClosed() {
 					return ctx.mkErr(x, index, codeIncomplete, "undefined field %q", s)
 				}
 				return ctx.mkErr(x, index, "undefined field %q", s)
diff --git a/cue/export.go b/cue/export.go
index e599c31..86376c1 100644
--- a/cue/export.go
+++ b/cue/export.go
@@ -422,13 +422,13 @@
 		return bin
 
 	case *structLit:
-		st, err := p.structure(x, !x.isClosed)
+		st, err := p.structure(x, !x.isClosed())
 		if err != nil {
 			return p.expr(err)
 		}
-		expr := p.closeOrOpen(st, x.isClosed)
+		expr := p.closeOrOpen(st, x.isClosed())
 		switch {
-		case x.isClosed && x.template != nil:
+		case x.isClosed() && x.template != nil:
 			l, ok := x.template.evalPartial(p.ctx).(*lambdaExpr)
 			if !ok {
 				break
@@ -632,7 +632,7 @@
 	case !doEval(p.mode) && x.template != nil && addTempl:
 		l, ok := x.template.evalPartial(p.ctx).(*lambdaExpr)
 		if ok {
-			if _, ok := l.value.(*top); ok && !x.isClosed {
+			if _, ok := l.value.(*top); ok && !x.isClosed() {
 				break
 			}
 			obj.Elts = append(obj.Elts, &ast.Field{
@@ -735,7 +735,7 @@
 			break
 		}
 		s.Elts = append(s.Elts, st.Elts...)
-		return x.isClosed
+		return x.isClosed()
 
 	case *binaryExpr:
 		if x.op != opUnifyUnchecked {
diff --git a/cue/resolve_test.go b/cue/resolve_test.go
index f3bac0a..9572a63 100644
--- a/cue/resolve_test.go
+++ b/cue/resolve_test.go
@@ -1155,6 +1155,7 @@
 				}
 			}
 
+			// Allowed
 			Foo1 :: { field: int }
 			Foo1 :: { field2: string }
 
@@ -1184,14 +1185,56 @@
 			`,
 		out: `<0>{` +
 			`Foo :: <1>C{field: int, recursive: <2>C{field: string}}, ` +
-			`Foo1 :: _|_((<3>C{field: int} & <4>C{field2: string}):field "field" not allowed in closed struct), ` +
+			`Foo1 :: <3>C{field: int, field2: string}, ` +
 			`foo: _|_(2:field "feild" not allowed in closed struct), ` +
-			`foo1: <5>C{field: 2, recursive: _|_(2:field "feild" not allowed in closed struct)}, ` +
-			`Bar :: <6>{<>: <7>(A: string)->int, field: int}, ` +
-			`bar: <8>{<>: <9>(A: string)->int, field: int, feild: 2}, ` +
+			`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: _|_(field "Mixed" declared as definition and regular field), ` +
 			`mixedRec: _|_(field "Mixed" declared as definition and regular field)}`,
 	}, {
+		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: <5>C{a: "A", b: "B", c: "C"}, def :: <6>C{a: "A", b: "B"}}, ` +
+			`D2 :: <7>C{a: int, b: int}, ` +
+			`D3 :: <8>C{env: <9>C{a: "A", b: "B"}}, ` +
+			`D4 :: <10>C{env: _|_(int:field "b" not allowed in closed struct)}, ` +
+			`DC :: <11>C{a: int}` +
+			`}`,
+	}, {
 		desc: "definitions with oneofs",
 		in: `
 			Foo :: {
@@ -1228,20 +1271,16 @@
 			b: 3
 		}
 
-		// error: literal struct is closed before unify
-		e1 :: S & { a c: 4 }
-		// no such issue here
-		v1: S & { a c: 4 }
-
 		// adding a field to a nested struct that is closed.
-		e2: S & { a d: 4 }
+		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>.S & <6>C{a: <7>C{c: 4}}):field "b" not allowed in closed struct), ` +
-			`v1: <8>C{a: <9>C{b: int, c: 4}, b: 3}, ` +
-			`e2: <10>C{a: _|_(4:field "d" not allowed in closed struct), 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: "closing structs",
 		in: `
@@ -1310,8 +1349,8 @@
 	}, {
 		desc: "closing with failed optional",
 		in: `
-		k1 :: {a: int, b?: int} & {a: int} // closed({a: int})
-		k2 :: {a: int} & {a: int, b?: int} // closed({a: int})
+		k1 :: {a: int, b?: int} & A // closed({a: int})
+		k2 :: A & {a: int, b?: int} // closed({a: int})
 
 		o1: {a?: 3} & {a?: 4} // {a?: _|_}
 
@@ -1320,14 +1359,18 @@
 
 		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}, ` +
-			`k2 :: <2>C{a: int}, ` +
-			`o1: <3>{a?: _|_((3 & 4):conflicting values 3 and 4)}, ` +
-			`o2 :: <4>C{a?: _|_((3 & 4):conflicting values 3 and 4)}, ` +
-			`d1 :: (<5>C{a?: 2, b: 4} | <6>C{a?: 3, c: 5}), ` +
-			`v1: <7>C{a?: _|_((2 & 3):conflicting values 2 and 3), b: 4}}`,
+			`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: `
@@ -2392,7 +2435,12 @@
 
 	// Don't remove. For debugging.
 	testCases := []testCase{{
-		in: ``,
+		in: `
+		Foo :: { a: int }
+
+		Foo
+		b: int
+		`,
 	}}
 	rewriteHelper(t, testCases, evalFull)
 }
diff --git a/cue/rewrite_test.go b/cue/rewrite_test.go
index 0e1fa08..2673e41 100644
--- a/cue/rewrite_test.go
+++ b/cue/rewrite_test.go
@@ -75,7 +75,7 @@
 			t = v
 		}
 		emit := testResolve(ctx, x.emit, m)
-		obj := &structLit{x.baseValue, emit, t, x.isClosed, nil, arcs, nil}
+		obj := &structLit{x.baseValue, emit, t, x.closeStatus, nil, arcs, nil}
 		return obj
 	case *list:
 		elm := rewriteRec(ctx, x.elem, x.elem, m).(*structLit)
diff --git a/cue/subsume.go b/cue/subsume.go
index cacc6fa..1c928e0 100644
--- a/cue/subsume.go
+++ b/cue/subsume.go
@@ -113,7 +113,7 @@
 			}
 		}
 		// For closed structs, all arcs in b must exist in a.
-		if x.isClosed {
+		if x.isClosed() {
 			for _, b := range o.arcs {
 				a := x.lookup(ctx, b.feature)
 				if a.val() == nil {
diff --git a/cue/types.go b/cue/types.go
index 4fe7942..34edee1 100644
--- a/cue/types.go
+++ b/cue/types.go
@@ -1148,13 +1148,13 @@
 		}
 		arcs = arcs[:k]
 		obj = &structLit{
-			obj.baseValue, // baseValue
-			obj.emit,      // emit
-			obj.template,  // template
-			obj.isClosed,  // isClosed
-			nil,           // comprehensions
-			arcs,          // arcs
-			nil,           // attributes
+			obj.baseValue,   // baseValue
+			obj.emit,        // emit
+			obj.template,    // template
+			obj.closeStatus, // isClosed
+			nil,             // comprehensions
+			arcs,            // arcs
+			nil,             // attributes
 		}
 	}
 	return structValue{ctx, v.path, obj}, nil
diff --git a/cue/value.go b/cue/value.go
index 519408b..f3cf133 100644
--- a/cue/value.go
+++ b/cue/value.go
@@ -639,8 +639,8 @@
 
 	// template must evaluated to a lambda and is applied to all concrete
 	// values in the struct, whether it be open or closed.
-	template value
-	isClosed bool
+	template    value
+	closeStatus byte
 
 	comprehensions []value
 
@@ -649,6 +649,15 @@
 	expanded evaluated
 }
 
+func (x *structLit) isClosed() bool {
+	return x.closeStatus != 0
+}
+
+const (
+	toClose  = 1
+	isClosed = 2
+)
+
 func (x *structLit) addTemplate(ctx *context, pos token.Pos, t value) {
 	if x.template == nil {
 		x.template = t
@@ -658,7 +667,7 @@
 }
 
 func (x *structLit) allows(f label) bool {
-	return !x.isClosed || f&hidden != 0
+	return x.closeStatus&isClosed == 0 || f&hidden != 0
 }
 
 func newStruct(src source) *structLit {
@@ -679,7 +688,7 @@
 	}
 
 	newS := *x
-	newS.isClosed = true
+	newS.closeStatus = isClosed
 	return &newS
 }
 
@@ -767,6 +776,11 @@
 		// it is safe to cache the result.
 		ctx.cycleErr = false
 
+		if s, ok := v.(*structLit); ok {
+			if s.closeStatus != 0 {
+				s.closeStatus = 2
+			}
+		}
 		x.arcs[i].cache = v
 		if doc != nil {
 			x.arcs[i].docs = &docNode{n: doc, left: x.arcs[i].docs}
@@ -788,6 +802,10 @@
 // should not be evaluated until the other fields of a struct are
 // fully evaluated.
 func (x *structLit) expandFields(ctx *context) (st *structLit, err *bottom) {
+	if x.closeStatus == toClose {
+		x.closeStatus = isClosed
+	}
+
 	switch v := x.expanded.(type) {
 	case nil:
 	case *structLit:
diff --git a/doc/ref/spec.md b/doc/ref/spec.md
index cc6ad2c..f07149d 100644
--- a/doc/ref/spec.md
+++ b/doc/ref/spec.md
@@ -1330,8 +1330,18 @@
 to be concrete when emitting data.
 It is illegal to have a regular field and a definition with the same name
 within the same struct.
-Literal structs that are part of a definition's value are implicitly closed.
+Literal structs that are part of a definition's value are implicitly closed,
+but may unify unrestricted with other structs within the field's declaration.
 This excludes literals structs in embeddings and aliases.
+<!--
+This may be a more intuitive definition:
+    Literal structs that are part of a definition's value are implicitly closed.
+    Implicitly closed literal structs that are unified within
+    a single field declaration are considered to be a single literal struct.
+However, this would make unification non-commutative, unless one imposes an
+ordering where literal structs are unified before unifying them with others.
+Imposing such an ordering is complex and error prone.
+-->
 An ellipsis `...` in such literal structs keeps them open,
 as it defines `_` for all labels.
 <!--
@@ -1359,22 +1369,17 @@
 -->
 
 ```
-// MyStruct is closed and as there is no expression label or `...`, we know
-// this is the full definition.
 MyStruct :: {
-    field:    string
-    enabled?: bool
+    sub field:    string
 }
 
-// Without the `...`, this field would not unify with its previous declaration.
 MyStruct :: {
-    enabled: bool | *false
-    ...
+    sub enabled?: bool
 }
 
 myValue: MyStruct & {
-    feild:   2     // error, feild not defined in MyStruct
-    enabled: true  // okay
+    sub feild:   2     // error, feild not defined in MyStruct
+    sub enabled: true  // okay
 }
 
 D :: {
@@ -1441,6 +1446,7 @@
 // attr:  int    @xml(,attr) @xml(a1,attr) @go(Attr)
 ```
 
+
 #### Aliases
 
 In addition to fields, a struct literal may also define aliases.