diff --git a/cue/ast.go b/cue/ast.go
index 3bf6798..b8163ee 100644
--- a/cue/ast.go
+++ b/cue/ast.go
@@ -244,7 +244,10 @@
 				v1.object.addTemplate(v.ctx(), token.NoPos, template)
 
 			case *ast.EmbedDecl:
+				old := v.ctx().inDefinition
+				v.ctx().inDefinition = 0
 				e := v1.walk(x.Expr)
+				v.ctx().inDefinition = old
 				if isBottom(e) {
 					return e
 				}
@@ -498,7 +501,10 @@
 		}
 
 		if a, ok := n.Node.(*ast.Alias); ok {
+			old := v.ctx().inDefinition
+			v.ctx().inDefinition = 0
 			ret = v.walk(a.Expr)
+			v.ctx().inDefinition = old
 			break
 		}
 
diff --git a/cue/resolve_test.go b/cue/resolve_test.go
index 9a0f471..9839e49 100644
--- a/cue/resolve_test.go
+++ b/cue/resolve_test.go
@@ -1230,6 +1230,31 @@
 			`ctcp: <16>C{x: int}, ` +
 			`ctct: <17>{x: int, ...}}`,
 	}, {
+		desc: "excluded embedding from closing",
+		in: `
+		S :: {
+			a: { c: int }
+			{
+				c: { d: int }
+			}
+			B = { open: int }
+			b: B
+		}
+		V: S & {
+			c e: int
+			b extra: int
+		}
+		`,
+		out: `<0>{` +
+			`S :: <1>C{` +
+			`a: <2>C{c: int}, ` +
+			`c: <3>{d: int}, ` +
+			`b: <4>{open: int}}, ` +
+			`V: <5>C{` +
+			`a: <6>C{c: int}, ` +
+			`c: <7>{d: int, e: int}, ` +
+			`b: <8>{open: int, extra: int}}}`,
+	}, {
 		desc: "closing with failed optional",
 		in: `
 		k1 :: {a: int, b?: int} & {a: int} // closed({a: int})
diff --git a/doc/ref/spec.md b/doc/ref/spec.md
index ca04260..6b694f1 100644
--- a/doc/ref/spec.md
+++ b/doc/ref/spec.md
@@ -1198,9 +1198,32 @@
 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.
+This excludes literals structs in embeddings and aliases.
 An ellipsis `...` in such literal structs keeps them open,
 as it defines `_` for all labels.
+<!--
+Excluding embeddings from recursive closing allows comprehensions to be
+interpreted as embeddings without some exception. For instance,
+    if x > 2 {
+        foo: string
+    }
+should not cause any failure. It is also consistent with embeddings being
+opened when included in a closed struct.
 
+Finally, excluding embeddings from recursive closing allows for
+a mechanism to not recursively close, without needing an additional language
+construct, such as a triple colon or something else:
+foo :: {
+    {
+        // not recursively closed
+    }
+    ... // include this to not close outer struct
+}
+
+Including aliases from this exclusion, which are more a separate definition
+than embedding seems sensible, and allows for an easy mechanism to avoid
+closing, aside from embedding.
+-->
 
 ```
 // MyStruct is closed and as there is no expression label or `...`, we know