diff --git a/internal/core/eval/closed.go b/internal/core/eval/closed.go
index 0b8025e..b2201fd 100644
--- a/internal/core/eval/closed.go
+++ b/internal/core/eval/closed.go
@@ -104,6 +104,32 @@
 	return mask
 }
 
+// A disjunction acceptor represents a disjunction of all possible fields. Note
+// that this is never used in evaluation as evaluation stops at incomplete nodes
+// and a disjunction is incomplete. When the node is referenced, the original
+// conjuncts are used instead.
+//
+// The value may be used in the API, though, where it may be an argument to
+// UnifyAccept.
+//
+// TODO(perf): it would be sufficient to only implement the Accept method of an
+// Acceptor. This could be implemented as an allocation-free wrapper type around
+// a Disjunction. This will require a bit more API cleaning, though.
+func newDisjunctionAcceptor(x *adt.Disjunction) adt.Acceptor {
+	tree := &CloseDef{}
+	sets := []fieldSet{}
+	for _, d := range x.Values {
+		if a, _ := d.Closed.(*acceptor); a != nil {
+			sets = append(sets, a.fields...)
+			tree.List = append(tree.List, a.tree)
+		}
+	}
+	if len(tree.List) == 0 && len(sets) == 0 {
+		return nil
+	}
+	return &acceptor{tree: tree, fields: sets}
+}
+
 // CloseDef defines how individual FieldSets (corresponding to conjuncts)
 // combine to determine whether a field is contained in a closed set.
 //
diff --git a/internal/core/eval/eval.go b/internal/core/eval/eval.go
index 82dba9a..591e179 100644
--- a/internal/core/eval/eval.go
+++ b/internal/core/eval/eval.go
@@ -143,7 +143,7 @@
 	if v.Value == nil {
 		save := *v
 		// Use node itself to allow for cycle detection.
-		s := e.evalVertex(c, v, adt.Partial)
+		s := e.evalVertex(c, v, adt.Partial, nil)
 
 		if d := s.disjunct; d != nil && len(d.Values) > 1 && d.NumDefaults != 1 {
 			v.Value = d
@@ -239,6 +239,19 @@
 // Phase two: record incomplete
 // Phase three: record cycle.
 func (e *Evaluator) Unify(c *adt.OpContext, v *adt.Vertex, state adt.VertexStatus) {
+	e.UnifyAccept(c, v, state, nil) //v.Closed)
+}
+
+// UnifyAccept is like Unify, but takes an extra argument to override the
+// accepted set of fields.
+//
+// Instead of deriving the allowed set of fields, it verifies this set by
+// consulting the given Acceptor. This can be useful when splitting an existing
+// values into individual conjuncts and then unifying some of its components
+// back into a new value. Under normal circumstances, this may not always
+// succeed as the missing context may result in stricter closedness rules.
+func (e *Evaluator) UnifyAccept(c *adt.OpContext, v *adt.Vertex, state adt.VertexStatus, accept adt.Acceptor) {
+
 	// defer c.PopVertex(c.PushVertex(v))
 
 	if state <= v.Status()+1 {
@@ -252,7 +265,7 @@
 		return
 	}
 
-	n := e.evalVertex(c, v, state)
+	n := e.evalVertex(c, v, state, accept)
 
 	switch d := n.disjunct; {
 	case d != nil && len(d.Values) == 1:
@@ -282,6 +295,7 @@
 		}
 		v.Arcs = nil
 		// v.Structs = nil // TODO: should we keep or discard the Structs?
+		v.Closed = newDisjunctionAcceptor(n.disjunct)
 
 	default:
 		if r := n.result(); r.Value != nil {
@@ -292,7 +306,7 @@
 	// Else set it to something.
 
 	if v.Value == nil {
-		panic("errer")
+		panic("error")
 	}
 
 	// Check whether result is done.
@@ -301,13 +315,13 @@
 // evalVertex computes the vertex results. The state indicates the minimum
 // status to which this vertex should be evaluated. It should be either
 // adt.Finalized or adt.Partial.
-func (e *Evaluator) evalVertex(c *adt.OpContext, v *adt.Vertex, state adt.VertexStatus) *nodeShared {
-	// fmt.Println(debug.NodeString(c.StringIndexer, v, nil))
+func (e *Evaluator) evalVertex(c *adt.OpContext, v *adt.Vertex, state adt.VertexStatus, accept adt.Acceptor) *nodeShared {
 	shared := &nodeShared{
-		ctx:   c,
-		eval:  e,
-		node:  v,
-		stack: nil, // silence linter
+		ctx:    c,
+		eval:   e,
+		node:   v,
+		stack:  nil, // silence linter
+		accept: accept,
 	}
 	saved := *v
 
@@ -577,7 +591,14 @@
 			a.Closed = m
 		}
 		if updated != nil && m.isClosed {
-			if err := m.verifyArcAllowed(n.ctx, a.Label); err != nil {
+			if accept := n.nodeShared.accept; accept != nil {
+				if !accept.Accept(n.ctx, a.Label) {
+					label := a.Label.SelectorString(ctx)
+					n.node.Value = &adt.Bottom{
+						Err: errors.Newf(token.NoPos, "field `%s` not allowed by Acceptor", label),
+					}
+				}
+			} else if err := m.verifyArcAllowed(n.ctx, a.Label); err != nil {
 				n.node.Value = err
 			}
 			// TODO: use continue to not process already failed fields,
@@ -633,6 +654,9 @@
 	resultNode *nodeContext
 	result_    adt.Vertex
 	stack      []int
+
+	// Closedness override.
+	accept adt.Acceptor
 }
 
 func (n *nodeShared) result() *adt.Vertex {