fix(simplecue): handle CUE v0.16 single-branch Expr() in getReference for Type | *Default structs

In CUE v0.11, Expr() on a value like `VariableOption | *{...}` returned
(NoOp, [typeVertex, defaultVertex]) — two expressions. getReference
relied on len(exprs) == 2 to detect this pattern and extract exprs[0]
as the named reference.

In CUE v0.16, when the default struct is subsumed by the named type,
Expr() filters the default branch and returns (NoOp, [typeVertex]) — a
single expression. The len(exprs) != 2 guard caused an early return of
false, so declareNode fell through to StructKind handling and iterated
the concrete default's fields instead of the abstract type's fields,
generating a wrong anonymous struct type rather than a reference to the
named type.

Fix: allow len(exprs) == 1 as a valid case when op == NoOp and the
single branch has a reference path. We additionally confirm v.Default()
succeeds to rule out unrelated single-expr NoOp values.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: moustafab

internal/simplecue/generator.go

@@ -426,20 +426,33 @@ func getReference(v cue.Value) (bool, cue.Value, cue.Value) {
 
 	op, exprs := v.Expr()
 
-	if len(exprs) != 2 {
+	if len(exprs) == 0 || len(exprs) > 2 {
 		return false, v, v
 	}
 
 	_, path = exprs[0].ReferencePath()
 	if v.Kind() == cue.BottomKind && v.IncompleteKind() == cue.StructKind && path.String() != "" {
 		// When a struct with defaults is completely filled, it usually has a NoOp op.
+		// In CUE v0.16+, `A | *B` where B is subsumed by A may reduce Expr() to (NoOp, [A]),
+		// filtering out the default branch entirely. We handle both the two-expr (v0.11) and
+		// one-expr (v0.16) cases identically: return the type branch (exprs[0]) as the reference.
 		if op == cue.NoOp {
-			return true, exprs[0], v
+			if len(exprs) == 1 {
+				// v0.16: only the type branch remains in Expr(); confirm v still has a default.
+				if _, ok := v.Default(); ok {
+					return true, exprs[0], v
+				}
+			} else {
+				// len(exprs) == 2: v0.11 behavior — both type branch and default struct present.
+				return true, exprs[0], v
+			}
 		}
 
 		// Accepts [AStruct | *{ ... }] and skips [AStruct | BStruct]
-		if _, ok := v.Default(); ok {
-			return true, exprs[0], v
+		if len(exprs) == 2 {
+			if _, ok := v.Default(); ok {
+				return true, exprs[0], v
+			}
 		}
 	}