diff --git a/cue/builtin.go b/cue/builtin.go
index 4b4a3c5..3fdf53c 100644
--- a/cue/builtin.go
+++ b/cue/builtin.go
@@ -231,7 +231,7 @@
 	return x
 }
 
-func (x *builtin) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *builtin) subsumesImpl(s *subsumer, v value) bool {
 	if y, ok := v.(*builtin); ok {
 		return x == y
 	}
@@ -295,6 +295,9 @@
 			if err, ok := err.Err.(*marshalError); ok && err.b != nil {
 				ret = err.b
 			}
+		case *valueError:
+			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)
diff --git a/cue/errors.go b/cue/errors.go
index f9c05ab..bf6739f 100644
--- a/cue/errors.go
+++ b/cue/errors.go
@@ -159,10 +159,17 @@
 func (x *bottom) kind() kind { return bottomKind }
 
 func (x *bottom) Positions(ctx *context) []token.Pos {
+	var a []token.Pos
 	if x.index != nil { // TODO: remove check?
-		return appendPositions(ctx, nil, x.pos)
+		a = appendPositions(ctx, nil, x.pos)
 	}
-	return nil
+	if w := x.wrapped; w != nil {
+		a = append(a, w.Positions(ctx)...)
+	}
+	for _, sub := range x.sub {
+		a = append(a, sub.Positions(ctx)...)
+	}
+	return a
 }
 
 func appendPositions(ctx *context, pos []token.Pos, src source) []token.Pos {
diff --git a/cue/examples_test.go b/cue/examples_test.go
index be46bbd..7f48b96 100644
--- a/cue/examples_test.go
+++ b/cue/examples_test.go
@@ -66,7 +66,7 @@
 	// json: cannot unmarshal string into Go struct field ab.B of type int
 }
 
-func ExampleValue_Subsumes() {
+func ExampleValue_Subsume() {
 	// Check compatibility of successive APIs.
 	var r cue.Runtime
 
@@ -105,13 +105,13 @@
 	}
 
 	// Is V2 backwards compatible with V1? In other words, does V2 subsume V1?
-	pass := v2.Value.Subsumes(v1.Value)
-	fmt.Println("V2 is backwards compatible with V1:", pass)
+	err = v2.Value.Subsume(v1.Value)
+	fmt.Println("V2 is backwards compatible with V1:", err)
 
-	pass = v3.Value.Subsumes(v2.Value)
-	fmt.Println("V3 is backwards compatible with V2:", pass)
+	err = v3.Value.Subsume(v2.Value)
+	fmt.Println("V3 is backwards compatible with V2:", err)
 
 	// Output:
-	// V2 is backwards compatible with V1: true
-	// V3 is backwards compatible with V2: false
+	// V2 is backwards compatible with V1: <nil>
+	// V3 is backwards compatible with V2: conflicting values <=150 and string (mismatched types number and string)
 }
diff --git a/cue/strip.go b/cue/strip.go
index 5d82834..76c3ca6 100644
--- a/cue/strip.go
+++ b/cue/strip.go
@@ -124,6 +124,6 @@
 	return &mergedValues{x.baseValue, vs}
 }
 
-func (x *mergedValues) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *mergedValues) subsumesImpl(s *subsumer, v value) bool {
 	return false
 }
diff --git a/cue/subsume.go b/cue/subsume.go
index 5cc134f..b4bc2b7 100644
--- a/cue/subsume.go
+++ b/cue/subsume.go
@@ -16,8 +16,44 @@
 
 import (
 	"bytes"
+
+	"cuelang.org/go/cue/token"
 )
 
+// TODO: it probably makes sense to have only two modes left: subsuming a schema
+// and subsuming a final value.
+
+func subsumes(v, w Value, mode subsumeMode) error {
+	ctx := v.ctx()
+	gt := v.eval(ctx)
+	lt := w.eval(ctx)
+	s := subsumer{ctx: ctx, mode: mode}
+	if !s.subsumes(gt, lt) {
+		var b *bottom
+		var ok bool
+		src := binSrc(token.NoPos, opUnify, gt, lt)
+		src2 := src
+		if s.gt != nil && s.lt != nil {
+			src := binSrc(token.NoPos, opUnify, s.gt, s.lt)
+			b, ok = binOp(ctx, src, opUnify, s.gt, s.lt).(*bottom)
+		}
+		if !ok {
+			b = ctx.mkErr(src, "value not an instance")
+		}
+		b = ctx.mkErr(src2, b, "%v", b)
+		return w.toErr(b)
+	}
+	return nil
+}
+
+type subsumer struct {
+	ctx  *context
+	mode subsumeMode
+
+	// recorded values where an error occurred.
+	gt, lt evaluated
+}
+
 type subsumeMode int
 
 const (
@@ -27,13 +63,18 @@
 
 	// subNoOptional ignores optional fields for the purpose of subsumption.
 	// This option is predominantly intended for implementing equality checks.
+	// TODO: may be unnecessary now subFinal is available.
 	subNoOptional
+
+	// the subsumed value is final
+	subFinal
 )
 
 // TODO: improve upon this highly inefficient implementation. There should
 // be a dedicated equal function once the dust settles.
 func equals(c *context, x, y value) bool {
-	return subsumes(c, x, y, subNoOptional) && subsumes(c, y, x, subNoOptional)
+	s := subsumer{ctx: c, mode: subNoOptional}
+	return s.subsumes(x, y) && s.subsumes(y, x)
 }
 
 // subsumes checks gt subsumes lt. If any of the values contains references or
@@ -41,9 +82,10 @@
 // subsumption is conservative; it may return false when a guarantee for
 // subsumption could be proven. For concreted values it returns the exact
 // relation. It never returns a false positive.
-func subsumes(ctx *context, gt, lt value, mode subsumeMode) bool {
-	var v, w value
-	if mode&subChoose == 0 {
+func (s *subsumer) subsumes(gt, lt value) (result bool) {
+	ctx := s.ctx
+	var v, w evaluated
+	if s.mode&subChoose == 0 {
 		v = gt.evalPartial(ctx)
 		w = lt.evalPartial(ctx)
 	} else {
@@ -62,7 +104,7 @@
 	case b&^(a&b) != 0:
 		// a does not have strictly more bits. This implies any ground kind
 		// subsuming a non-ground type.
-		return false
+		goto exit
 		// TODO: consider not supporting references.
 		// case (a|b)&(referenceKind) != 0:
 		// 	// no resolution if references are in play.
@@ -72,17 +114,17 @@
 	case *unification:
 		if _, ok := gt.(*unification); !ok {
 			for _, x := range lt.values {
-				if subsumes(ctx, gt, x, mode) {
+				if s.subsumes(gt, x) {
 					return true
 				}
 			}
-			return false
+			goto exit
 		}
 
 	case *disjunction:
 		if _, ok := gt.(*disjunction); !ok {
 			for _, x := range lt.values {
-				if !subsumes(ctx, gt, x.val, mode) {
+				if !s.subsumes(gt, x.val) {
 					return false
 				}
 			}
@@ -90,22 +132,41 @@
 		}
 	}
 
-	return gt.subsumesImpl(ctx, lt, mode)
+	result = gt.subsumesImpl(s, lt)
+exit:
+	if !result && s.gt == nil && s.lt == nil {
+		s.gt = v
+		s.lt = w
+	}
+	return result
 }
 
-func (x *structLit) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
-	ignoreOptional := mode&subNoOptional != 0
+func (x *structLit) subsumesImpl(s *subsumer, v value) bool {
+	ctx := s.ctx
+	ignoreOptional := s.mode&subNoOptional != 0
 	if o, ok := v.(*structLit); ok {
-		// TODO: consider what to do with templates. Perhaps we should always
-		// do subsumption on fully evaluated structs.
 		if x.optionals != nil && !ignoreOptional {
-			return false
+			if s.mode&subFinal == 0 {
+				// TODO: also cross-validate optional fields in the schema case.
+				return false
+			}
+			for _, b := range o.arcs {
+				if b.optional || b.definition {
+					continue
+				}
+				name := ctx.labelStr(b.feature)
+				arg := &stringLit{x.baseValue, name, nil}
+				u, _ := x.optionals.constraint(ctx, arg)
+				if u != nil && !s.subsumes(u, b.v) {
+					return false
+				}
+			}
 		}
 		if len(x.comprehensions) > 0 {
 			return false
 		}
 		if x.emit != nil {
-			if o.emit == nil || !subsumes(ctx, x.emit, o.emit, mode) {
+			if o.emit == nil || !s.subsumes(x.emit, o.emit) {
 				return false
 			}
 		}
@@ -118,29 +179,50 @@
 			b := o.lookup(ctx, a.feature)
 			if !a.optional && b.optional {
 				return false
-			} else if a.definition != b.definition {
-				return false
 			} else if b.val() == nil {
+				if a.definition && s.mode&subFinal != 0 {
+					continue
+				}
+				// if o is closed, the field is implicitly defined as _|_ and
+				// thus subsumed. Technically, this is even true if a is not
+				// optional, but in that case it means that o is invalid, so
+				// return false regardless
+				if a.optional && (o.closeStatus.shouldClose() || s.mode&subFinal != 0) {
+					continue
+				}
 				// If field a is optional and has value top, neither the
 				// omission of the field nor the field defined with any value
 				// may cause unification to fail.
-				return a.optional && isTop(a.v)
-			} else if !subsumes(ctx, a.v, b.val(), mode) {
+				if a.optional && isTop(a.v) {
+					continue
+				}
+				s.gt = a.val()
+				return false
+			} else if a.definition != b.definition {
+				return false
+			} else if !s.subsumes(a.v, b.val()) {
 				return false
 			}
 		}
 		// For closed structs, all arcs in b must exist in a.
 		if x.closeStatus.shouldClose() {
-			if !ignoreOptional && !o.closeStatus.shouldClose() {
+			if !ignoreOptional && !o.closeStatus.shouldClose() && s.mode&subFinal == 0 {
 				return false
 			}
+			ignoreOptional = ignoreOptional || s.mode&subFinal != 0
 			for _, b := range o.arcs {
 				if ignoreOptional && b.optional {
 					continue
 				}
 				a := x.lookup(ctx, b.feature)
 				if a.val() == nil {
-					return false
+					name := ctx.labelStr(b.feature)
+					arg := &stringLit{x.baseValue, name, nil}
+					u, _ := x.optionals.constraint(ctx, arg)
+					if u == nil { // subsumption already checked
+						s.lt = b.val()
+						return false
+					}
 				}
 			}
 		}
@@ -148,20 +230,21 @@
 	return !isBottom(v)
 }
 
-func (*top) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (*top) subsumesImpl(s *subsumer, v value) bool {
 	return true
 }
 
-func (x *bottom) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *bottom) subsumesImpl(s *subsumer, v value) bool {
 	// never called.
 	return v.kind() == bottomKind
 }
 
-func (x *basicType) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *basicType) subsumesImpl(s *subsumer, v value) bool {
 	return true
 }
 
-func (x *bound) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *bound) subsumesImpl(s *subsumer, v value) bool {
+	ctx := s.ctx
 	if isBottom(v) {
 		return true
 	}
@@ -243,81 +326,81 @@
 	return false
 }
 
-func (x *nullLit) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *nullLit) subsumesImpl(s *subsumer, v value) bool {
 	return true
 }
 
-func (x *boolLit) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *boolLit) subsumesImpl(s *subsumer, v value) bool {
 	return x.b == v.(*boolLit).b
 }
 
-func (x *stringLit) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *stringLit) subsumesImpl(s *subsumer, v value) bool {
 	return x.str == v.(*stringLit).str
 }
 
-func (x *bytesLit) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *bytesLit) subsumesImpl(s *subsumer, v value) bool {
 	return bytes.Equal(x.b, v.(*bytesLit).b)
 }
 
-func (x *numLit) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *numLit) subsumesImpl(s *subsumer, v value) bool {
 	b := v.(*numLit)
 	return x.v.Cmp(&b.v) == 0
 }
 
-func (x *durationLit) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *durationLit) subsumesImpl(s *subsumer, v value) bool {
 	return x.d == v.(*durationLit).d
 }
 
-func (x *list) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *list) subsumesImpl(s *subsumer, v value) bool {
 	switch y := v.(type) {
 	case *list:
-		if !subsumes(ctx, x.len, y.len, mode) {
+		if !s.subsumes(x.len, y.len) {
 			return false
 		}
 		// TODO: need to handle case where len(x.elem) > len(y.elem) explicitly
 		// if we introduce cap().
-		if !subsumes(ctx, x.elem, y.elem, mode) {
+		if !s.subsumes(x.elem, y.elem) {
 			return false
 		}
 		// TODO: assuming continuous indices, use merge sort if we allow
 		// sparse arrays.
 		for _, a := range y.elem.arcs[len(x.elem.arcs):] {
-			if !subsumes(ctx, x.typ, a.v, mode) {
+			if !s.subsumes(x.typ, a.v) {
 				return false
 			}
 		}
 		if y.isOpen() { // implies from first check that x.IsOpen.
-			return subsumes(ctx, x.typ, y.typ, 0)
+			return s.subsumes(x.typ, y.typ)
 		}
 		return true
 	}
 	return isBottom(v)
 }
 
-func (x *params) subsumes(ctx *context, y *params, mode subsumeMode) bool {
+func (x *params) subsumes(s *subsumer, y *params) bool {
 	// structural equivalence
 	// TODO: make agnostic to argument names.
 	if len(y.arcs) != len(x.arcs) {
 		return false
 	}
 	for i, a := range x.arcs {
-		if !subsumes(ctx, a.v, y.arcs[i].v, 0) {
+		if !s.subsumes(a.v, y.arcs[i].v) {
 			return false
 		}
 	}
 	return true
 }
 
-func (x *lambdaExpr) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *lambdaExpr) subsumesImpl(s *subsumer, v value) bool {
 	// structural equivalence
 	if y, ok := v.(*lambdaExpr); ok {
-		return x.params.subsumes(ctx, y.params, 0) &&
-			subsumes(ctx, x.value, y.value, 0)
+		return x.params.subsumes(s, y.params) &&
+			s.subsumes(x.value, y.value)
 	}
 	return isBottom(v)
 }
 
-func (x *unification) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *unification) subsumesImpl(s *subsumer, v value) bool {
 	if y, ok := v.(*unification); ok {
 		// A unification subsumes another unification if for all values a in x
 		// there is a value b in y such that a subsumes b.
@@ -328,7 +411,7 @@
 	outer:
 		for _, vx := range x.values {
 			for _, vy := range y.values {
-				if subsumes(ctx, vx, vy, mode) {
+				if s.subsumes(vx, vy) {
 					continue outer
 				}
 			}
@@ -338,14 +421,14 @@
 	}
 	subsumed := true
 	for _, vx := range x.values {
-		subsumed = subsumed && subsumes(ctx, vx, v, mode)
+		subsumed = subsumed && s.subsumes(vx, v)
 	}
 	return subsumed
 }
 
 // subsumes for disjunction is logically precise. However, just like with
 // structural subsumption, it should not have to be called after evaluation.
-func (x *disjunction) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *disjunction) subsumesImpl(s *subsumer, v value) bool {
 	// A disjunction subsumes another disjunction if all values of v are
 	// subsumed by any of the values of x, and default values in v are subsumed
 	// by the default values of x.
@@ -358,7 +441,7 @@
 		for _, vd := range d.values {
 			// v is subsumed if any value in x subsumes v.
 			for _, vx := range x.values {
-				if (vx.marked || !vd.marked) && subsumes(ctx, vx.val, vd.val, 0) {
+				if (vx.marked || !vd.marked) && s.subsumes(vx.val, vd.val) {
 					continue outer
 				}
 			}
@@ -368,7 +451,7 @@
 	}
 	// v is subsumed if any value in x subsumes v.
 	for _, vx := range x.values {
-		if subsumes(ctx, vx.val, v, 0) {
+		if s.subsumes(vx.val, v) {
 			return true
 		}
 	}
@@ -379,7 +462,7 @@
 // evaluation.
 
 // structural equivalence
-func (x *nodeRef) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *nodeRef) subsumesImpl(s *subsumer, v value) bool {
 	if r, ok := v.(*nodeRef); ok {
 		return x.node == r.node
 	}
@@ -387,14 +470,14 @@
 }
 
 // structural equivalence
-func (x *selectorExpr) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *selectorExpr) subsumesImpl(s *subsumer, v value) bool {
 	if r, ok := v.(*selectorExpr); ok {
-		return x.feature == r.feature && subsumes(ctx, x.x, r.x, subChoose)
+		return x.feature == r.feature && s.subsumes(x.x, r.x) // subChoose
 	}
 	return isBottom(v)
 }
 
-func (x *interpolation) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *interpolation) subsumesImpl(s *subsumer, v value) bool {
 	switch v := v.(type) {
 	case *stringLit:
 		// Be conservative if not ground.
@@ -406,7 +489,7 @@
 			return false
 		}
 		for i, p := range x.parts {
-			if !subsumes(ctx, p, v.parts[i], 0) {
+			if !s.subsumes(p, v.parts[i]) {
 				return false
 			}
 		}
@@ -416,31 +499,31 @@
 }
 
 // structural equivalence
-func (x *indexExpr) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *indexExpr) subsumesImpl(s *subsumer, v value) bool {
 	// TODO: what does it mean to subsume if the index value is not known?
 	if r, ok := v.(*indexExpr); ok {
 		// TODO: could be narrowed down if we know the exact value of the index
 		// and referenced value.
-		return subsumes(ctx, x.x, r.x, mode) && subsumes(ctx, x.index, r.index, 0)
+		return s.subsumes(x.x, r.x) && s.subsumes(x.index, r.index)
 	}
 	return isBottom(v)
 }
 
 // structural equivalence
-func (x *sliceExpr) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *sliceExpr) subsumesImpl(s *subsumer, v value) bool {
 	// TODO: what does it mean to subsume if the index value is not known?
 	if r, ok := v.(*sliceExpr); ok {
 		// TODO: could be narrowed down if we know the exact value of the index
 		// and referenced value.
-		return subsumes(ctx, x.x, r.x, 0) &&
-			subsumes(ctx, x.lo, r.lo, 0) &&
-			subsumes(ctx, x.hi, r.hi, 0)
+		return s.subsumes(x.x, r.x) &&
+			s.subsumes(x.lo, r.lo) &&
+			s.subsumes(x.hi, r.hi)
 	}
 	return isBottom(v)
 }
 
 // structural equivalence
-func (x *customValidator) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *customValidator) subsumesImpl(s *subsumer, v value) bool {
 	y, ok := v.(*customValidator)
 	if !ok {
 		return isBottom(v)
@@ -449,7 +532,7 @@
 		return false
 	}
 	for i, v := range x.args {
-		if !subsumes(ctx, v, y.args[i], mode) {
+		if !s.subsumes(v, y.args[i]) {
 			return false
 		}
 	}
@@ -457,60 +540,60 @@
 }
 
 // structural equivalence
-func (x *callExpr) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *callExpr) subsumesImpl(s *subsumer, v value) bool {
 	if c, ok := v.(*callExpr); ok {
 		if len(x.args) != len(c.args) {
 			return false
 		}
 		for i, a := range x.args {
-			if !subsumes(ctx, a, c.args[i], 0) {
+			if !s.subsumes(a, c.args[i]) {
 				return false
 			}
 		}
-		return subsumes(ctx, x.x, c.x, 0)
+		return s.subsumes(x.x, c.x)
 	}
 	return isBottom(v)
 }
 
 // structural equivalence
-func (x *unaryExpr) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *unaryExpr) subsumesImpl(s *subsumer, v value) bool {
 	if b, ok := v.(*unaryExpr); ok {
-		return x.op == b.op && subsumes(ctx, x.x, b.x, 0)
+		return x.op == b.op && s.subsumes(x.x, b.x)
 	}
 	return isBottom(v)
 }
 
 // structural equivalence
-func (x *binaryExpr) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *binaryExpr) subsumesImpl(s *subsumer, v value) bool {
 	if b, ok := v.(*binaryExpr); ok {
 		return x.op == b.op &&
-			subsumes(ctx, x.left, b.left, 0) &&
-			subsumes(ctx, x.right, b.right, 0)
+			s.subsumes(x.left, b.left) &&
+			s.subsumes(x.right, b.right)
 	}
 	return isBottom(v)
 }
 
 // structural equivalence
-func (x *listComprehension) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *listComprehension) subsumesImpl(s *subsumer, v value) bool {
 	if b, ok := v.(*listComprehension); ok {
-		return subsumes(ctx, x.clauses, b.clauses, 0)
+		return s.subsumes(x.clauses, b.clauses)
 	}
 	return isBottom(v)
 }
 
 // structural equivalence
-func (x *structComprehension) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *structComprehension) subsumesImpl(s *subsumer, v value) bool {
 	if b, ok := v.(*structComprehension); ok {
-		return subsumes(ctx, x.clauses, b.clauses, 0)
+		return s.subsumes(x.clauses, b.clauses)
 	}
 	return isBottom(v)
 }
 
 // structural equivalence
-func (x *fieldComprehension) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *fieldComprehension) subsumesImpl(s *subsumer, v value) bool {
 	if b, ok := v.(*fieldComprehension); ok {
-		return subsumes(ctx, x.key, b.key, 0) &&
-			subsumes(ctx, x.val, b.val, 0) &&
+		return s.subsumes(x.key, b.key) &&
+			s.subsumes(x.val, b.val) &&
 			!x.opt && b.opt &&
 			x.def == b.def
 	}
@@ -518,27 +601,27 @@
 }
 
 // structural equivalence
-func (x *yield) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *yield) subsumesImpl(s *subsumer, v value) bool {
 	if b, ok := v.(*yield); ok {
-		return subsumes(ctx, x.value, b.value, 0)
+		return s.subsumes(x.value, b.value)
 	}
 	return isBottom(v)
 }
 
 // structural equivalence
-func (x *feed) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *feed) subsumesImpl(s *subsumer, v value) bool {
 	if b, ok := v.(*feed); ok {
-		return subsumes(ctx, x.source, b.source, 0) &&
-			subsumes(ctx, x.fn, b.fn, 0)
+		return s.subsumes(x.source, b.source) &&
+			s.subsumes(x.fn, b.fn)
 	}
 	return isBottom(v)
 }
 
 // structural equivalence
-func (x *guard) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+func (x *guard) subsumesImpl(s *subsumer, v value) bool {
 	if b, ok := v.(*guard); ok {
-		return subsumes(ctx, x.condition, b.condition, 0) &&
-			subsumes(ctx, x.value, b.value, 0)
+		return s.subsumes(x.condition, b.condition) &&
+			s.subsumes(x.value, b.value)
 	}
 	return isBottom(v)
 }
diff --git a/cue/subsume_test.go b/cue/subsume_test.go
index 0a95aa0..96a1372 100644
--- a/cue/subsume_test.go
+++ b/cue/subsume_test.go
@@ -404,10 +404,24 @@
 		607: {subsumes: false, in: `a: close({b: 1}), b: close({b?: 1})`},
 		608: {subsumes: true, in: `a: {}, b: close({})`},
 		609: {subsumes: true, in: `a: {}, b: close({foo?: 1})`},
+		610: {subsumes: true, in: `a: {foo?:1}, b: close({})`},
 
 		// Definitions are not regular fields.
-		610: {subsumes: false, in: `a: {a :: 1}, b: {a: 1}`},
-		611: {subsumes: false, in: `a: {a: 1}, b: {a :: 1}`},
+		630: {subsumes: false, in: `a: {a :: 1}, b: {a: 1}`},
+		631: {subsumes: false, in: `a: {a: 1}, b: {a :: 1}`},
+
+		// Subsuming final values.
+		700: {subsumes: true, in: `a: {[string]: 1}, b: {foo: 1}`, mode: subFinal},
+		701: {subsumes: true, in: `a: {[string]: int}, b: {foo: 1}`, mode: subFinal},
+		702: {subsumes: true, in: `a: {["foo"]: int}, b: {foo: 1}`, mode: subFinal},
+		703: {subsumes: false, in: `a: close({["foo"]: 1}), b: {bar: 1}`, mode: subFinal},
+		704: {subsumes: false, in: `a: {foo: 1}, b: {foo?: 1}`, mode: subFinal},
+		705: {subsumes: true, in: `a: close({}), b: {foo?: 1}`, mode: subFinal},
+		706: {subsumes: true, in: `a: close({}), b: close({foo?: 1})`, mode: subFinal},
+		707: {subsumes: true, in: `a: {}, b: close({})`, mode: subFinal},
+		708: {subsumes: false, in: `a: {[string]: 1}, b: {foo: 2}`, mode: subFinal},
+		709: {subsumes: true, in: `a: {}, b: close({foo?: 1})`, mode: subFinal},
+		710: {subsumes: false, in: `a: {foo: [...string]}, b: {}`, mode: subFinal},
 	}
 
 	re := regexp.MustCompile(`a: (.*).*b: ([^\n]*)`)
@@ -432,7 +446,8 @@
 					b = arc.v
 				}
 			}
-			got := subsumes(ctx, a, b, tc.mode)
+			s := subsumer{ctx: ctx, mode: tc.mode}
+			got := s.subsumes(a, b)
 			if got != tc.subsumes {
 				t.Errorf("got %v; want %v (%v vs %v)", got, tc.subsumes, a.kind(), b.kind())
 			}
@@ -443,5 +458,5 @@
 func TestTouchBottom(t *testing.T) {
 	// Just call this function to mark coverage. It is otherwise never called.
 	var x bottom
-	x.subsumesImpl(nil, &bottom{}, 0)
+	x.subsumesImpl(nil, &bottom{})
 }
diff --git a/cue/types.go b/cue/types.go
index 89fcad7..e8ffdd1 100644
--- a/cue/types.go
+++ b/cue/types.go
@@ -1333,13 +1333,40 @@
 	}
 }
 
-// Subsumes reports whether w is an instance of v.
+// Subsume reports nil when w is an instance of v or an error otherwise.
+//
+// Without options, the entire value is considered for assumption, which means
+// Subsume tests whether  v is a backwards compatible (newer) API version of w.
+// Use the Final() to indicate that the subsumed value is data, and that
+//
+// Use the Final option to check subsumption if a w is known to be final,
+// and should assumed to be closed.
+//
+// Options are currently ignored and the function will panic if any are passed.
 //
 // Value v and w must be obtained from the same build.
 // TODO: remove this requirement.
+func (v Value) Subsume(w Value, opts ...Option) error {
+	var mode subsumeMode
+	o := getOptions(opts)
+	if o.final {
+		mode |= subFinal | subChoose
+	}
+	return subsumes(v, w, mode)
+}
+
+// Deprecated: use Subsume.
+//
+// Subsumes reports whether w is an instance of v.
+//
+// Without options, Subsumes checks whether v is a backwards compatbile schema
+// of w.
+//
+// By default, Subsumes tests whether two values are compatib
+// Value v and w must be obtained from the same build.
+// TODO: remove this requirement.
 func (v Value) Subsumes(w Value) bool {
-	ctx := v.ctx()
-	return subsumes(ctx, v.eval(ctx), w.eval(ctx), subChoose)
+	return subsumes(v, w, subChoose) == nil
 }
 
 // Unify reports the greatest lower bound of v and w.
@@ -1541,6 +1568,7 @@
 	omitDefinitions bool
 	omitOptional    bool
 	omitAttrs       bool
+	final           bool
 	disallowCycles  bool // implied by concrete
 }
 
@@ -1549,9 +1577,11 @@
 
 type option func(p *options)
 
-// Used in Iter, Validate, Subsume?, Fields() Syntax, Export
-
-// TODO: could also be used for subsumption.
+// 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 }
+}
 
 // Concrete ensures that all values are concrete.
 //
@@ -1915,7 +1945,8 @@
 		for _, disjunct := range x.values {
 			if disjunct.marked {
 				for _, n := range x.values {
-					if !n.marked && subsumes(v.ctx(), n.val, disjunct.val, 0) {
+					s := subsumer{ctx: v.ctx()}
+					if !n.marked && s.subsumes(n.val, disjunct.val) {
 						continue outer
 					}
 				}
diff --git a/cue/value.go b/cue/value.go
index 5d8564d..5df4323 100644
--- a/cue/value.go
+++ b/cue/value.go
@@ -39,7 +39,7 @@
 
 	// subsumesImpl is only defined for non-reference types.
 	// It should only be called by the subsumes function.
-	subsumesImpl(*context, value, subsumeMode) bool
+	subsumesImpl(*subsumer, value) bool
 }
 
 type evaluated interface {
@@ -767,7 +767,7 @@
 }
 
 // match reports whether a field with the given name may be added in the
-// associated struct as a new field. ok is false, fif there was any closed
+// associated struct as a new field. ok is false if there was any closed
 // struct that failed to match. Even if match returns false, there may still be
 // constraints represented by optionals that are to be applied to existing
 // concrete fields.
@@ -1695,7 +1695,8 @@
 		if isBottom(lt.val) {
 			return true
 		}
-		return (!lt.marked || gt.marked) && subsumes(ctx, gt.val, lt.val, 0)
+		s := subsumer{ctx: ctx}
+		return (!lt.marked || gt.marked) && s.subsumes(gt.val, lt.val)
 	}
 	k := 0
 
diff --git a/tools/trim/trim.go b/tools/trim/trim.go
index 55c22e7..e78be9b 100644
--- a/tools/trim/trim.go
+++ b/tools/trim/trim.go
@@ -401,7 +401,7 @@
 
 	default:
 		// Mark any subsumed part that is covered by generated config.
-		if in.Err() == nil && v.Subsumes(in) {
+		if in.Err() == nil && v.Subsume(in) == nil {
 			for _, v := range vSplit {
 				src := v.Source()
 				if t.canRemove(src) && !inNodes(gen, src) &&