diff --git a/internal/core/adt/adt.go b/internal/core/adt/adt.go
index d746190..f67f1cb 100644
--- a/internal/core/adt/adt.go
+++ b/internal/core/adt/adt.go
@@ -114,7 +114,7 @@
 // a value.
 type Resolver interface {
 	Node
-	resolve(ctx *OpContext) *Vertex
+	resolve(ctx *OpContext, state VertexStatus) *Vertex
 }
 
 type YieldFunc func(env *Environment, s *StructLit)
diff --git a/internal/core/adt/context.go b/internal/core/adt/context.go
index 4a9ce1d..443fc90 100644
--- a/internal/core/adt/context.go
+++ b/internal/core/adt/context.go
@@ -398,7 +398,7 @@
 func (c *OpContext) Resolve(env *Environment, r Resolver) (*Vertex, *Bottom) {
 	s := c.PushState(env, r.Source())
 
-	arc := r.resolve(c)
+	arc := r.resolve(c, AllArcs)
 	// TODO: check for cycle errors?
 
 	err := c.PopState(s)
@@ -583,7 +583,7 @@
 		return v
 
 	case Resolver:
-		arc := x.resolve(c)
+		arc := x.resolve(c, state)
 		if c.HasErr() {
 			return nil
 		}
@@ -600,6 +600,67 @@
 	}
 }
 
+// unifyNode returns a possibly partially evaluated node value.
+//
+// TODO: maybe return *Vertex, *Bottom
+func (c *OpContext) unifyNode(v Expr, state VertexStatus) (result Value) {
+	savedSrc := c.src
+	c.src = v.Source()
+	err := c.errs
+	c.errs = nil
+
+	defer func() {
+		c.errs = CombineErrors(c.src, c.errs, err)
+		// TODO: remove this when we handle errors more principally.
+		if b, ok := result.(*Bottom); ok && c.src != nil &&
+			b.Code == CycleError &&
+			b.Err.Position() == token.NoPos &&
+			len(b.Err.InputPositions()) == 0 {
+			bb := *b
+			bb.Err = errors.Wrapf(b.Err, c.src.Pos(), "")
+			result = &bb
+		}
+		c.errs = CombineErrors(c.src, c.errs, result)
+		if c.errs != nil {
+			result = c.errs
+		}
+		c.src = savedSrc
+	}()
+
+	switch x := v.(type) {
+	case Value:
+		return x
+
+	case Evaluator:
+		v := x.evaluate(c)
+		return v
+
+	case Resolver:
+		v := x.resolve(c, state)
+		if c.HasErr() {
+			return nil
+		}
+		if v == nil {
+			return nil
+		}
+
+		if v.BaseValue == nil || v.BaseValue == cycle {
+			// Use node itself to allow for cycle detection.
+			c.Unifier.Unify(c, v, state)
+		}
+
+		if b, _ := v.BaseValue.(*Bottom); b != nil && b.Code != IncompleteError {
+			return b
+		}
+
+		return v
+
+	default:
+		// This can only happen, really, if v == nil, which is not allowed.
+		panic(fmt.Sprintf("unexpected Expr type %T", v))
+	}
+}
+
 func (c *OpContext) lookup(x *Vertex, pos token.Pos, l Feature) *Vertex {
 	if l == InvalidLabel || x == nil {
 		// TODO: is it possible to have an invalid label here? Maybe through the
@@ -726,12 +787,11 @@
 	return x.Source().Pos()
 }
 
-func (c *OpContext) node(orig Node, x Expr, scalar bool) *Vertex {
+func (c *OpContext) node(orig Node, x Expr, scalar bool, state VertexStatus) *Vertex {
 	// TODO: always get the vertex. This allows a whole bunch of trickery
 	// down the line.
-	// This must be partial, because
-	// TODO: this should always be "AllArcs"
-	v := c.evalState(x, AllArcs)
+
+	v := c.unifyNode(x, AllArcs)
 
 	v, ok := c.getDefault(v)
 	if !ok {
diff --git a/internal/core/adt/expr.go b/internal/core/adt/expr.go
index ba5aabd..494199e 100644
--- a/internal/core/adt/expr.go
+++ b/internal/core/adt/expr.go
@@ -533,8 +533,11 @@
 func (x *NodeLink) Kind() Kind {
 	return x.Node.Kind()
 }
-func (x *NodeLink) Source() ast.Node             { return x.Node.Source() }
-func (x *NodeLink) resolve(c *OpContext) *Vertex { return x.Node }
+func (x *NodeLink) Source() ast.Node { return x.Node.Source() }
+
+func (x *NodeLink) resolve(c *OpContext, state VertexStatus) *Vertex {
+	return x.Node
+}
 
 // A FieldReference represents a lexical reference to a field.
 //
@@ -553,7 +556,7 @@
 	return x.Src
 }
 
-func (x *FieldReference) resolve(c *OpContext) *Vertex {
+func (x *FieldReference) resolve(c *OpContext, state VertexStatus) *Vertex {
 	n := c.relNode(x.UpCount)
 	pos := pos(x)
 	return c.lookup(n, pos, x.Label)
@@ -616,7 +619,7 @@
 	return x.Src
 }
 
-func (x *DynamicReference) resolve(ctx *OpContext) *Vertex {
+func (x *DynamicReference) resolve(ctx *OpContext, state VertexStatus) *Vertex {
 	e := ctx.Env(x.UpCount)
 	frame := ctx.PushState(e, x.Src)
 	v := ctx.value(x.Label)
@@ -644,7 +647,7 @@
 	return x.Src
 }
 
-func (x *ImportReference) resolve(ctx *OpContext) *Vertex {
+func (x *ImportReference) resolve(ctx *OpContext, state VertexStatus) *Vertex {
 	path := x.ImportPath.StringValue(ctx)
 	v, _ := ctx.Runtime.LoadImport(path)
 	return v
@@ -668,7 +671,7 @@
 	return x.Src
 }
 
-func (x *LetReference) resolve(c *OpContext) *Vertex {
+func (x *LetReference) resolve(c *OpContext, state VertexStatus) *Vertex {
 	e := c.Env(x.UpCount)
 	label := e.Vertex.Label
 	if x.X == nil {
@@ -702,8 +705,8 @@
 	return x.Src
 }
 
-func (x *SelectorExpr) resolve(c *OpContext) *Vertex {
-	n := c.node(x, x.X, x.Sel.IsRegular())
+func (x *SelectorExpr) resolve(c *OpContext, state VertexStatus) *Vertex {
+	n := c.node(x, x.X, x.Sel.IsRegular(), state)
 	if n == emptyNode {
 		return n
 	}
@@ -727,9 +730,9 @@
 	return x.Src
 }
 
-func (x *IndexExpr) resolve(ctx *OpContext) *Vertex {
+func (x *IndexExpr) resolve(ctx *OpContext, state VertexStatus) *Vertex {
 	// TODO: support byte index.
-	n := ctx.node(x, x.X, true)
+	n := ctx.node(x, x.X, true, state)
 	i := ctx.value(x.Index)
 	if n == emptyNode {
 		return n
@@ -1379,7 +1382,7 @@
 }
 
 func (x *ForClause) yield(c *OpContext, f YieldFunc) {
-	n := c.node(x, x.Src, true)
+	n := c.node(x, x.Src, true, AllArcs)
 	for _, a := range n.Arcs {
 		if !a.Label.IsRegular() {
 			continue