diff --git a/cmd/cue/cmd/orphans.go b/cmd/cue/cmd/orphans.go
index 94b2eea..de54d92 100644
--- a/cmd/cue/cmd/orphans.go
+++ b/cmd/cue/cmd/orphans.go
@@ -15,7 +15,6 @@
 package cmd
 
 import (
-	"errors"
 	"fmt"
 	"path/filepath"
 	"regexp"
@@ -25,6 +24,7 @@
 	"cuelang.org/go/cue/ast"
 	"cuelang.org/go/cue/ast/astutil"
 	"cuelang.org/go/cue/build"
+	"cuelang.org/go/cue/errors"
 	"cuelang.org/go/cue/parser"
 	"cuelang.org/go/cue/token"
 	"cuelang.org/go/internal"
@@ -191,7 +191,18 @@
 					"recordCount", ast.NewLit(token.INT, strconv.Itoa(len(objs))),
 				)
 			}
-			inst, err := runtime.CompileExpr(expr)
+			var f *ast.File
+			if s, ok := expr.(*ast.StructLit); ok {
+				f = &ast.File{Decls: s.Elts}
+			} else {
+				f = &ast.File{Decls: []ast.Decl{&ast.EmbedDecl{Expr: expr}}}
+			}
+			err := astutil.Sanitize(f)
+			if err != nil {
+				return nil, errors.Wrapf(err, token.NoPos,
+					"invalid combination of input files")
+			}
+			inst, err := runtime.CompileFile(f)
 			if err != nil {
 				return nil, err
 			}
@@ -273,7 +284,7 @@
 		}
 	}
 
-	return f, nil
+	return f, astutil.Sanitize(f)
 }
 
 func parseFullPath(inst *cue.Instance, exprs string) (p []ast.Label, t []token.Token, err error) {
diff --git a/cmd/cue/cmd/testdata/script/def_jsonschema.txt b/cmd/cue/cmd/testdata/script/def_jsonschema.txt
index 5c6224c..258ef36 100644
--- a/cmd/cue/cmd/testdata/script/def_jsonschema.txt
+++ b/cmd/cue/cmd/testdata/script/def_jsonschema.txt
@@ -16,12 +16,14 @@
 -- expect-stdout --
 package schema
 
+import "strings"
+
 #Person: {
 	// The person's first name.
 	firstName?: string
 
 	// The person's last name.
-	lastName?: string
+	lastName?: strings.MinRunes(1)
 
 	// Age in years which must be equal to or greater than zero.
 	age?: >=0
@@ -40,7 +42,8 @@
     },
     "lastName": {
       "type": "string",
-      "description": "The person's last name."
+      "description": "The person's last name.",
+      "minLength": 1
     },
     "age": {
       "description": "Age in years which must be equal to or greater than zero.",
@@ -63,6 +66,6 @@
 
 -- expect-stderr2 --
 age: conflicting values "twenty" and >=0 (mismatched types string and number):
-    11:7
+    13:7
     ./data.yaml:1:7
 -- cue.mod --
diff --git a/cmd/cue/cmd/testdata/script/import_proto.txt b/cmd/cue/cmd/testdata/script/import_proto.txt
index 6ab00a8..932c0a1 100644
--- a/cmd/cue/cmd/testdata/script/import_proto.txt
+++ b/cmd/cue/cmd/testdata/script/import_proto.txt
@@ -164,9 +164,9 @@
 package v1
 
 import (
-	"googleapis.com/acme/test"
-	"googleapis.com/acme/test/test"
 	"time"
+	"googleapis.com/acme/test"
+	"googleapis.com/acme/test/test:test_test"
 )
 
 // Attributes defines attributes.
diff --git a/cue/ast/astutil/sanitize.go b/cue/ast/astutil/sanitize.go
new file mode 100644
index 0000000..c5b3092
--- /dev/null
+++ b/cue/ast/astutil/sanitize.go
@@ -0,0 +1,355 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package astutil
+
+import (
+	"fmt"
+	"math/rand"
+	"strings"
+
+	"cuelang.org/go/cue/ast"
+	"cuelang.org/go/cue/errors"
+	"cuelang.org/go/cue/token"
+)
+
+// TODO:
+// - handle comprehensions
+// - change field from foo to "foo" if it isn't referenced, rather than
+//   relying on introducing a unique alias.
+// - change a predeclared identifier reference to use the __ident form,
+//   instead of introducing an alias.
+
+// Sanitize rewrites File f in place to be well formed after automated
+// construction of an AST.
+//
+// Rewrites:
+//    - auto inserts imports associated with Idents
+//    - unshadows imports associated with idents
+//    - unshadows references for identifiers that were already resolved.
+//
+func Sanitize(f *ast.File) error {
+	z := &sanitizer{
+		file: f,
+		rand: rand.New(rand.NewSource(808)),
+
+		names:      map[string]bool{},
+		importMap:  map[string]*ast.ImportSpec{},
+		referenced: map[ast.Node]bool{},
+		altMap:     map[ast.Node]string{},
+	}
+
+	// Gather all names.
+	walk(&scope{
+		errFn:   z.errf,
+		nameFn:  z.addName,
+		identFn: z.markUsed,
+	}, f)
+	if z.errs != nil {
+		return z.errs
+	}
+
+	// Add imports and unshadow.
+	s := &scope{
+		file:    f,
+		errFn:   z.errf,
+		identFn: z.handleIdent,
+		index:   make(map[string]entry),
+	}
+	z.fileScope = s
+	walk(s, f)
+	if z.errs != nil {
+		return z.errs
+	}
+
+	z.cleanImports()
+
+	return z.errs
+}
+
+type sanitizer struct {
+	file      *ast.File
+	fileScope *scope
+
+	rand *rand.Rand
+
+	// names is all used names. Can be used to determine a new unique name.
+	names      map[string]bool
+	referenced map[ast.Node]bool
+
+	// altMap defines an alternative name for an existing entry link (a field,
+	// alias or let clause). As new names are globally unique, they can be
+	// safely reused for any unshadowing.
+	altMap    map[ast.Node]string
+	importMap map[string]*ast.ImportSpec
+
+	errs errors.Error
+}
+
+func (z *sanitizer) errf(p token.Pos, msg string, args ...interface{}) {
+	z.errs = errors.Append(z.errs, errors.Newf(p, msg, args...))
+}
+
+func (z *sanitizer) addName(name string) {
+	z.names[name] = true
+}
+
+func (z *sanitizer) addRename(base string, n ast.Node) (alt string, new bool) {
+	if name, ok := z.altMap[n]; ok {
+		return name, false
+	}
+
+	name := z.uniqueName(base, false)
+	z.altMap[n] = name
+	return name, true
+}
+
+func (z *sanitizer) unshadow(parent ast.Node, base string, link ast.Node) string {
+	name, ok := z.altMap[link]
+	if !ok {
+		name = z.uniqueName(base, false)
+		z.altMap[link] = name
+
+		// Insert new let clause at top to refer to a declaration in possible
+		// other files.
+		let := &ast.LetClause{
+			Ident: ast.NewIdent(name),
+			Expr:  ast.NewIdent(base),
+		}
+
+		var decls *[]ast.Decl
+
+		switch x := parent.(type) {
+		case *ast.File:
+			decls = &x.Decls
+		case *ast.StructLit:
+			decls = &x.Elts
+		default:
+			panic("impossible scope")
+		}
+
+		i := 0
+		for ; i < len(*decls); i++ {
+			if (*decls)[i] == link {
+				break
+			}
+			if f, ok := (*decls)[i].(*ast.Field); ok && f.Label == link {
+				break
+			}
+		}
+
+		if i > 0 {
+			ast.SetRelPos(let, token.NewSection)
+		}
+
+		a := append((*decls)[:i:i], let)
+		*decls = append(a, (*decls)[i:]...)
+	}
+	return name
+}
+
+func (z *sanitizer) markUsed(s *scope, n *ast.Ident) bool {
+	if n.Node != nil {
+		return false
+	}
+	_, _, entry := s.lookup(n.String())
+	z.referenced[entry.link] = true
+	return true
+}
+
+func (z *sanitizer) cleanImports() {
+	for _, d := range z.file.Decls {
+		switch id := d.(type) {
+		case *ast.Package, *ast.CommentGroup:
+		case *ast.ImportDecl:
+			k := 0
+			for _, s := range id.Specs {
+				if _, ok := z.referenced[s]; ok {
+					id.Specs[k] = s
+					k++
+				}
+			}
+			id.Specs = id.Specs[:k]
+
+		default:
+			return
+		}
+	}
+}
+
+func (z *sanitizer) handleIdent(s *scope, n *ast.Ident) bool {
+	if n.Node == nil {
+		return true
+	}
+
+	_, _, node := s.lookup(n.Name)
+	if node.node == nil {
+		spec, ok := n.Node.(*ast.ImportSpec)
+		if !ok {
+			// Clear node. A reference may have been moved to a different
+			// file. If not, it should be an error.
+			n.Node = nil
+			n.Scope = nil
+			return false
+		}
+
+		_ = z.addImport(spec)
+		info, _ := ParseImportSpec(spec)
+		z.fileScope.insert(info.Ident, spec, spec)
+		return true
+	}
+
+	if x, ok := n.Node.(*ast.ImportSpec); ok {
+		xi, _ := ParseImportSpec(x)
+
+		if y, ok := node.node.(*ast.ImportSpec); ok {
+			yi, _ := ParseImportSpec(y)
+			if xi.ID == yi.ID { // name must be identical as a result of lookup.
+				z.referenced[y] = true
+				n.Node = x
+				n.Scope = nil
+				return false
+			}
+		}
+
+		// Either:
+		// - the import is shadowed
+		// - an incorrect import is matched
+		// In all cases we need to create a new import with a unique name or
+		// use a previously created one.
+		spec := z.importMap[xi.ID]
+		if spec == nil {
+			name := z.uniqueName(xi.Ident, false)
+			spec = z.addImport(&ast.ImportSpec{
+				Name: ast.NewIdent(name),
+				Path: x.Path,
+			})
+			z.importMap[xi.ID] = spec
+			z.fileScope.insert(name, spec, spec)
+		}
+
+		info, _ := ParseImportSpec(spec)
+		// TODO(apply): replace n itself directly
+		n.Name = info.Ident
+		n.Node = spec
+		n.Scope = nil
+		return false
+	}
+
+	if node.node == n.Node {
+		return true
+	}
+
+	// n.Node != node and are both not nil and n.Node is not an ImportSpec.
+	// This means that either n.Node is illegal or shadowed.
+	// Look for the scope in which n.Node is defined and add an alias or let.
+
+	parent, e, ok := s.resolveScope(n.Name, n.Node)
+	if !ok {
+		// The node isn't within a legal scope within this file. It may only
+		// possibly shadow a value of another file. We add a top-level let
+		// clause to refer to this value.
+
+		// TODO(apply): better would be to have resolve use Apply so that we can replace
+		// the entire ast.Ident, rather than modifying it.
+		// TODO: resolve to new node or rely on another pass of Resolve?
+		n.Name = z.unshadow(z.file, n.Name, n)
+		n.Node = nil
+		n.Scope = nil
+
+		return false
+	}
+
+	var name string
+	// var isNew bool
+	switch x := e.link.(type) {
+	case *ast.Field: // referring to regular field.
+		name, ok = z.altMap[x]
+		if ok {
+			break
+		}
+		// If this field has not alias, introduce one with a unique name.
+		// If this has an alias, also introduce a new name. There is a
+		// possibility that the alias can be used, but it is easier to just
+		// assign a new name, assuming this case is rather rare.
+		switch y := x.Label.(type) {
+		case *ast.Alias:
+			name = z.unshadow(parent, y.Ident.Name, y)
+
+		case *ast.Ident:
+			var isNew bool
+			name, isNew = z.addRename(y.Name, x)
+			if isNew {
+				x.Label = &ast.Alias{Ident: ast.NewIdent(name), Expr: y}
+			}
+
+		default:
+			// This is an illegal reference.
+			return false
+		}
+
+	case *ast.LetClause:
+		name = z.unshadow(parent, x.Ident.Name, x)
+
+	case *ast.Alias:
+		name = z.unshadow(parent, x.Ident.Name, x)
+
+	default:
+		panic(fmt.Sprintf("unexpected link type %T", e.link))
+	}
+
+	// TODO(apply): better would be to have resolve use Apply so that we can replace
+	// the entire ast.Ident, rather than modifying it.
+	n.Name = name
+	n.Node = nil
+	n.Scope = nil
+
+	return true
+}
+
+// uniqueName returns a new name globally unique name of the form
+// base_XX ... base_XXXXXXXXXXXXXX or _base or the same pattern with a '_'
+// prefix if hidden is true.
+//
+// It prefers short extensions over large ones, while ensuring the likelihood of
+// fast termination is high. There are at least two digits to make it visually
+// clearer this concerns a generated number.
+//
+func (z *sanitizer) uniqueName(base string, hidden bool) string {
+	if hidden && !strings.HasPrefix(base, "_") {
+		base = "_" + base
+		if !z.names[base] {
+			z.names[base] = true
+			return base
+		}
+	}
+
+	// TODO(go1.13): const mask = 0xff_ffff_ffff_ffff
+	const mask = 0xffffffffffffff // max bits; stay clear of int64 overflow
+	const shift = 4               // rate of growth
+	for n := int64(0x10); ; n = int64(mask&((n<<shift)-1)) + 1 {
+		num := z.rand.Intn(int(n))
+		name := fmt.Sprintf("%s_%01X", base, num)
+		if !z.names[name] {
+			z.names[name] = true
+			return name
+		}
+	}
+}
+
+func (z *sanitizer) addImport(spec *ast.ImportSpec) *ast.ImportSpec {
+	spec = insertImport(&z.file.Decls, spec)
+	z.referenced[spec] = true
+	return spec
+}
diff --git a/cue/ast/astutil/sanitize_test.go b/cue/ast/astutil/sanitize_test.go
new file mode 100644
index 0000000..997396f
--- /dev/null
+++ b/cue/ast/astutil/sanitize_test.go
@@ -0,0 +1,495 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package astutil_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/cue/ast"
+	"cuelang.org/go/cue/ast/astutil"
+	"cuelang.org/go/cue/format"
+	"cuelang.org/go/internal"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSanitize(t *testing.T) {
+	testCases := []struct {
+		desc string
+		file *ast.File
+		want string
+	}{{
+		desc: "Take existing import and rename it",
+		file: func() *ast.File {
+			spec := ast.NewImport(nil, "list")
+			spec.AddComment(internal.NewComment(true, "will be renamed"))
+			return &ast.File{Decls: []ast.Decl{
+				&ast.ImportDecl{Specs: []*ast.ImportSpec{spec}},
+				&ast.EmbedDecl{
+					Expr: ast.NewStruct(
+						ast.NewIdent("list"), ast.NewCall(
+							ast.NewSel(&ast.Ident{Name: "list", Node: spec},
+								"Min")),
+					)},
+			}}
+		}(),
+		want: `import (
+	// will be renamed
+	list_1 "list"
+)
+
+{
+	list: list_1.Min()
+}
+`,
+	}, {
+		desc: "Take existing import and rename it",
+		file: func() *ast.File {
+			spec := ast.NewImport(nil, "list")
+			return &ast.File{Decls: []ast.Decl{
+				&ast.ImportDecl{Specs: []*ast.ImportSpec{spec}},
+				&ast.Field{
+					Label: ast.NewIdent("a"),
+					Value: ast.NewStruct(
+						ast.NewIdent("list"), ast.NewCall(
+							ast.NewSel(&ast.Ident{Name: "list", Node: spec}, "Min")),
+					),
+				},
+			}}
+		}(),
+		want: `import list_1 "list"
+
+a: {
+	list: list_1.Min()
+}
+`,
+	}, {
+		desc: "One import added, one removed",
+		file: &ast.File{Decls: []ast.Decl{
+			&ast.ImportDecl{Specs: []*ast.ImportSpec{
+				{Path: ast.NewString("foo")},
+			}},
+			&ast.Field{
+				Label: ast.NewIdent("a"),
+				Value: ast.NewCall(
+					ast.NewSel(&ast.Ident{
+						Name: "bar",
+						Node: &ast.ImportSpec{Path: ast.NewString("bar")},
+					}, "Min")),
+			},
+		}},
+		want: `import "bar"
+
+a: bar.Min()
+`,
+	}, {
+		desc: "Rename duplicate import",
+		file: func() *ast.File {
+			spec1 := ast.NewImport(nil, "bar")
+			spec2 := ast.NewImport(nil, "foo/bar")
+			spec3 := ast.NewImport(ast.NewIdent("bar"), "foo")
+			return &ast.File{Decls: []ast.Decl{
+				internal.NewComment(false, "File comment"),
+				&ast.Package{Name: ast.NewIdent("pkg")},
+				&ast.Field{
+					Label: ast.NewIdent("a"),
+					Value: ast.NewStruct(
+						ast.NewIdent("b"), ast.NewCall(
+							ast.NewSel(&ast.Ident{Name: "bar", Node: spec1}, "A")),
+						ast.NewIdent("c"), ast.NewCall(
+							ast.NewSel(&ast.Ident{Name: "bar", Node: spec2}, "A")),
+						ast.NewIdent("d"), ast.NewCall(
+							ast.NewSel(&ast.Ident{Name: "bar", Node: spec3}, "A")),
+					),
+				},
+			}}
+		}(),
+		want: `// File comment
+
+package pkg
+
+import (
+	"bar"
+	bar_1 "foo/bar"
+	bar_5 "foo"
+)
+
+a: {
+	b: bar.A()
+	c: bar_1.A()
+	d: bar_5.A()
+}
+`,
+	}, {
+		desc: "Rename duplicate import, reuse and drop",
+		file: func() *ast.File {
+			spec1 := ast.NewImport(nil, "bar")
+			spec2 := ast.NewImport(nil, "foo/bar")
+			spec3 := ast.NewImport(ast.NewIdent("bar"), "foo")
+			return &ast.File{Decls: []ast.Decl{
+				&ast.ImportDecl{Specs: []*ast.ImportSpec{
+					spec3,
+					ast.NewImport(nil, "foo"),
+				}},
+				&ast.Field{
+					Label: ast.NewIdent("a"),
+					Value: ast.NewStruct(
+						ast.NewIdent("b"), ast.NewCall(
+							ast.NewSel(&ast.Ident{Name: "bar", Node: spec1}, "A")),
+						ast.NewIdent("c"), ast.NewCall(
+							ast.NewSel(&ast.Ident{Name: "bar", Node: spec2}, "A")),
+						ast.NewIdent("d"), ast.NewCall(
+							ast.NewSel(&ast.Ident{Name: "bar", Node: spec3}, "A")),
+					),
+				},
+			}}
+		}(),
+		want: `import (
+	bar "foo"
+	bar_1 "bar"
+	bar_5 "foo/bar"
+)
+
+a: {
+	b: bar_1.A()
+	c: bar_5.A()
+	d: bar.A()
+}
+`,
+	}, {
+		desc: "Reuse different import",
+		file: &ast.File{Decls: []ast.Decl{
+			&ast.Package{Name: ast.NewIdent("pkg")},
+			&ast.ImportDecl{Specs: []*ast.ImportSpec{
+				{Path: ast.NewString("bar")},
+			}},
+			&ast.Field{
+				Label: ast.NewIdent("a"),
+				Value: ast.NewStruct(
+					ast.NewIdent("list"), ast.NewCall(
+						ast.NewSel(&ast.Ident{
+							Name: "bar",
+							Node: &ast.ImportSpec{Path: ast.NewString("bar")},
+						}, "Min")),
+				),
+			},
+		}},
+		want: `package pkg
+
+import "bar"
+
+a: {
+	list: bar.Min()
+}
+`,
+	}, {
+		desc: "Clear reference that does not exist in scope",
+		file: &ast.File{Decls: []ast.Decl{
+			&ast.Field{
+				Label: ast.NewIdent("a"),
+				Value: ast.NewStruct(
+					ast.NewIdent("b"), &ast.Ident{
+						Name: "c",
+						Node: ast.NewString("foo"),
+					},
+					ast.NewIdent("d"), ast.NewIdent("e"),
+				),
+			},
+		}},
+		want: `a: {
+	b: c
+	d: e
+}
+`,
+	}, {
+		desc: "Unshadow possible reference to other file",
+		file: &ast.File{Decls: []ast.Decl{
+			&ast.Field{
+				Label: ast.NewIdent("a"),
+				Value: ast.NewStruct(
+					ast.NewIdent("b"), &ast.Ident{
+						Name: "c",
+						Node: ast.NewString("foo"),
+					},
+					ast.NewIdent("c"), ast.NewIdent("d"),
+				),
+			},
+		}},
+		want: `a: {
+	b: c_1
+	c: d
+}
+
+let c_1 = c
+`,
+	}, {
+		desc: "Add alias to shadowed field",
+		file: func() *ast.File {
+			field := &ast.Field{
+				Label: ast.NewIdent("a"),
+				Value: ast.NewString("b"),
+			}
+			return &ast.File{Decls: []ast.Decl{
+				field,
+				&ast.Field{
+					Label: ast.NewIdent("c"),
+					Value: ast.NewStruct(
+						ast.NewIdent("a"), ast.NewStruct(),
+						ast.NewIdent("b"), &ast.Ident{
+							Name: "a",
+							Node: field.Value,
+						},
+						ast.NewIdent("c"), ast.NewIdent("d"),
+					),
+				},
+			}}
+		}(),
+		want: `a_1=a: "b"
+c: {
+	a: {}
+	b: a_1
+	c: d
+}
+`,
+	}, {
+		desc: "Add let clause to shadowed field",
+		// Resolve both identifiers to same clause.
+		file: func() *ast.File {
+			field := &ast.Field{
+				Label: ast.NewIdent("a"),
+				Value: ast.NewString("b"),
+			}
+			return &ast.File{Decls: []ast.Decl{
+				field,
+				&ast.Field{
+					Label: ast.NewIdent("c"),
+					Value: ast.NewStruct(
+						ast.NewIdent("a"), ast.NewStruct(),
+						// Remove this reference.
+						ast.NewIdent("b"), &ast.Ident{
+							Name: "a",
+							Node: field.Value,
+						},
+						ast.NewIdent("c"), ast.NewIdent("d"),
+						ast.NewIdent("e"), &ast.Ident{
+							Name: "a",
+							Node: field.Value,
+						},
+					),
+				},
+			}}
+		}(),
+		want: `a_1=a: "b"
+c: {
+	a: {}
+	b: a_1
+	c: d
+	e: a_1
+}
+`,
+	}, {
+		desc: "Add let clause to shadowed field",
+		// Resolve both identifiers to same clause.
+		file: func() *ast.File {
+			fieldX := &ast.Field{
+				Label: &ast.Alias{
+					Ident: ast.NewIdent("X"),
+					Expr:  ast.NewIdent("a"), // shadowed
+				},
+				Value: ast.NewString("b"),
+			}
+			fieldY := &ast.Field{
+				Label: &ast.Alias{
+					Ident: ast.NewIdent("Y"), // shadowed
+					Expr:  ast.NewIdent("q"), // not shadowed
+				},
+				Value: ast.NewString("b"),
+			}
+			return &ast.File{Decls: []ast.Decl{
+				fieldX,
+				fieldY,
+				&ast.Field{
+					Label: ast.NewIdent("c"),
+					Value: ast.NewStruct(
+						ast.NewIdent("a"), ast.NewStruct(),
+						ast.NewIdent("b"), &ast.Ident{
+							Name: "X",
+							Node: fieldX,
+						},
+						ast.NewIdent("c"), ast.NewIdent("d"),
+						ast.NewIdent("e"), &ast.Ident{
+							Name: "a",
+							Node: fieldX.Value,
+						},
+						ast.NewIdent("f"), &ast.Ident{
+							Name: "Y",
+							Node: fieldY,
+						},
+					),
+				},
+			}}
+		}(),
+		want: `
+let X_1 = X
+X=a: "b"
+Y=q: "b"
+c: {
+	a: {}
+	b: X
+	c: d
+	e: X_1
+	f: Y
+}
+`,
+	}, {
+		desc: "Add let clause to nested shadowed field",
+		// Resolve both identifiers to same clause.
+		file: func() *ast.File {
+			field := &ast.Field{
+				Label: ast.NewIdent("a"),
+				Value: ast.NewString("b"),
+			}
+			return &ast.File{Decls: []ast.Decl{
+				&ast.Field{
+					Label: ast.NewIdent("b"),
+					Value: ast.NewStruct(
+						field,
+						ast.NewIdent("b"), ast.NewStruct(
+							ast.NewIdent("a"), ast.NewString("bar"),
+							ast.NewIdent("b"), &ast.Ident{
+								Name: "a",
+								Node: field.Value,
+							},
+							ast.NewIdent("e"), &ast.Ident{
+								Name: "a",
+								Node: field.Value,
+							},
+						),
+					),
+				},
+			}}
+		}(),
+		want: `b: {
+	a_1=a: "b"
+	b: {
+		a: "bar"
+		b: a_1
+		e: a_1
+	}
+}
+`,
+	}, {
+		desc: "Add let clause to nested shadowed field with alias",
+		// Resolve both identifiers to same clause.
+		file: func() *ast.File {
+			field := &ast.Field{
+				Label: &ast.Alias{
+					Ident: ast.NewIdent("X"),
+					Expr:  ast.NewIdent("a"),
+				},
+				Value: ast.NewString("b"),
+			}
+			return &ast.File{Decls: []ast.Decl{
+				&ast.Field{
+					Label: ast.NewIdent("b"),
+					Value: ast.NewStruct(
+						field,
+						ast.NewIdent("b"), ast.NewStruct(
+							ast.NewIdent("a"), ast.NewString("bar"),
+							ast.NewIdent("b"), &ast.Ident{
+								Name: "a",
+								Node: field.Value,
+							},
+							ast.NewIdent("e"), &ast.Ident{
+								Name: "a",
+								Node: field.Value,
+							},
+						),
+					),
+				},
+			}}
+		}(),
+		want: `b: {
+	let X_1 = X
+	X=a: "b"
+	b: {
+		a: "bar"
+		b: X_1
+		e: X_1
+	}
+}
+`,
+	}}
+	for _, tc := range testCases {
+		t.Run(tc.desc, func(t *testing.T) {
+			err := astutil.Sanitize(tc.file)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			b, errs := format.Node(tc.file)
+			if errs != nil {
+				t.Fatal(errs)
+			}
+
+			got := string(b)
+			assert.Equal(t, got, tc.want)
+		})
+	}
+}
+
+// For testing purposes: do not remove.
+func TestX(t *testing.T) {
+	t.Skip()
+
+	field := &ast.Field{
+		Label: &ast.Alias{
+			Ident: ast.NewIdent("X"),
+			Expr:  ast.NewIdent("a"),
+		},
+		Value: ast.NewString("b"),
+	}
+
+	file := &ast.File{Decls: []ast.Decl{
+		&ast.Field{
+			Label: ast.NewIdent("b"),
+			Value: ast.NewStruct(
+				field,
+				ast.NewIdent("b"), ast.NewStruct(
+					ast.NewIdent("a"), ast.NewString("bar"),
+					ast.NewIdent("b"), &ast.Ident{
+						Name: "a",
+						Node: field.Value,
+					},
+					ast.NewIdent("e"), &ast.Ident{
+						Name: "a",
+						Node: field.Value,
+					},
+				),
+			),
+		},
+	}}
+
+	err := astutil.Sanitize(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	b, errs := format.Node(file)
+	if errs != nil {
+		t.Fatal(errs)
+	}
+
+	t.Error(string(b))
+}
diff --git a/encoding/protobuf/parse.go b/encoding/protobuf/parse.go
index 833b731..c9b2fe5 100644
--- a/encoding/protobuf/parse.go
+++ b/encoding/protobuf/parse.go
@@ -20,7 +20,6 @@
 	"os"
 	"path"
 	"path/filepath"
-	"sort"
 	"strconv"
 	"strings"
 	"text/scanner"
@@ -29,7 +28,9 @@
 	"github.com/emicklei/proto"
 
 	"cuelang.org/go/cue/ast"
+	"cuelang.org/go/cue/ast/astutil"
 	"cuelang.org/go/cue/errors"
+	"cuelang.org/go/cue/format"
 	"cuelang.org/go/cue/parser"
 	"cuelang.org/go/cue/token"
 	"cuelang.org/go/internal/source"
@@ -69,7 +70,6 @@
 		tfile:    tfile,
 		imported: map[string]bool{},
 		symbols:  map[string]bool{},
-		aliases:  map[string]string{},
 	}
 
 	defer func() {
@@ -139,34 +139,13 @@
 		}
 	}
 
-	imports := &ast.ImportDecl{}
-	importIdx := len(p.file.Decls)
-	p.file.Decls = append(p.file.Decls, imports)
-
 	for _, e := range d.Elements {
 		p.topElement(e)
 	}
 
-	imported := []string{}
-	for k := range p.imported {
-		imported = append(imported, k)
-	}
-	sort.Strings(imported)
-	p.sorted = imported
+	err = astutil.Sanitize(p.file)
 
-	for _, v := range imported {
-		spec := ast.NewImport(nil, v)
-		imports.Specs = append(imports.Specs, spec)
-		p.file.Imports = append(p.file.Imports, spec)
-	}
-
-	if len(imports.Specs) == 0 {
-		a := p.file.Decls
-		copy(a[importIdx:], a[importIdx+1:])
-		p.file.Decls = a[:len(a)-1]
-	}
-
-	return p, nil
+	return p, err
 }
 
 // A protoConverter converts a proto definition to CUE. Proto files map to
@@ -185,20 +164,24 @@
 	file    *ast.File
 	current *ast.StructLit
 
-	sorted   []string
 	imported map[string]bool
 
 	path    []string
 	scope   []map[string]mapping // for symbols resolution within package.
 	symbols map[string]bool      // symbols provided by package
-	aliases map[string]string    // for shadowed packages
 }
 
 type mapping struct {
-	ref     string
-	cueName string
-	alias   string // alias for the type, if exists.
-	pkg     *protoConverter
+	cue func() ast.Expr // needs to be a new copy as position changes
+	pkg *protoConverter
+}
+
+func (p *protoConverter) qualifiedImportPath() string {
+	s := p.importPath()
+	if short := p.shortPkgName; short != "" && short != path.Base(s) {
+		s += ":" + short
+	}
+	return s
 }
 
 func (p *protoConverter) importPath() string {
@@ -224,12 +207,12 @@
 	return p.tfile.Pos(pos.Offset, 0)
 }
 
-func (p *protoConverter) addRef(pos scanner.Position, name, cuename string) {
+func (p *protoConverter) addRef(pos scanner.Position, name string, cue func() ast.Expr) {
 	top := p.scope[len(p.scope)-1]
 	if _, ok := top[name]; ok {
 		failf(pos, "entity %q already defined", name)
 	}
-	top[name] = mapping{ref: name, cueName: cuename}
+	top[name] = mapping{cue: cue}
 }
 
 func (p *protoConverter) addNames(elems []proto.Visitee) {
@@ -261,7 +244,7 @@
 		}
 		sym := strings.Join(append(p.path, name), ".")
 		p.symbols[sym] = true
-		p.addRef(pos, name, "#"+name)
+		p.addRef(pos, name, func() ast.Expr { return ast.NewIdent("#" + name) })
 	}
 }
 
@@ -269,68 +252,24 @@
 	p.scope = p.scope[:len(p.scope)-1]
 }
 
-func (p *protoConverter) uniqueTop(name string, asIs bool) string {
-	a := strings.SplitN(name, ".", 2)
-	for i := len(p.scope) - 1; i > 0; i-- {
-		if _, ok := p.scope[i][a[0]]; ok {
-			first := a[0]
-			alias, ok := p.aliases[first]
-			if !ok {
-				// TODO: this is likely to be okay, but find something better.
-				alias = "_" + first + "_"
-				p.file.Decls = append(p.file.Decls, &ast.LetClause{
-					Ident: ast.NewIdent(alias),
-					Expr:  ast.NewIdent(first),
-				})
-				p.aliases[first] = alias
-			}
-			a[0] = alias
-			if len(a) > 1 && !asIs {
-				a[1] = "#" + a[1]
-			}
-			return strings.Join(a, ".")
-		}
-	}
-
-	if e, ok := p.scope[0][name]; ok {
-		return e.cueName
-	}
-	// TODO: do something more principled.
-	switch name {
-	case "time.Time", "time.Duration":
-		return name
-	}
-	if !asIs {
-		a[len(a)-1] = "#" + a[len(a)-1]
-	}
-	return strings.Join(a, ".")
-}
-
-func (p *protoConverter) toExpr(pos scanner.Position, name string) (expr ast.Expr) {
-	expr, err := parser.ParseExpr("", name, parser.ParseComments)
-	if err != nil {
-		panic(fmt.Sprintf("error parsing name %q: %v", name, err))
-	}
-	ast.SetPos(expr, p.toCUEPos(pos))
-	return expr
-}
-
-func (p *protoConverter) resolve(pos scanner.Position, name string, options []*proto.Option) string {
-	if s, ok := protoToCUE(name, options); ok {
-		return p.uniqueTop(s, true)
+func (p *protoConverter) resolve(pos scanner.Position, name string, options []*proto.Option) ast.Expr {
+	if expr := protoToCUE(name, options); expr != nil {
+		ast.SetPos(expr, p.toCUEPos(pos))
+		return expr
 	}
 	if strings.HasPrefix(name, ".") {
 		return p.resolveTopScope(pos, name[1:], options)
 	}
 	for i := len(p.scope) - 1; i > 0; i-- {
 		if m, ok := p.scope[i][name]; ok {
-			return m.cueName
+			return m.cue()
 		}
 	}
-	return p.resolveTopScope(pos, name, options)
+	expr := p.resolveTopScope(pos, name, options)
+	return expr
 }
 
-func (p *protoConverter) resolveTopScope(pos scanner.Position, name string, options []*proto.Option) string {
+func (p *protoConverter) resolveTopScope(pos scanner.Position, name string, options []*proto.Option) ast.Expr {
 	for i := 0; i < len(name); i++ {
 		k := strings.IndexByte(name[i:], '.')
 		i += k
@@ -338,18 +277,23 @@
 			i = len(name)
 		}
 		if m, ok := p.scope[0][name[:i]]; ok {
-			isPkg := false
 			if m.pkg != nil {
-				p.imported[m.pkg.importPath()] = true
-				// TODO: do something more principled.
-				isPkg = true
+				p.imported[m.pkg.qualifiedImportPath()] = true
 			}
-			cueName := name[i:]
-			return p.uniqueTop(m.ref+cueName, !isPkg || m.ref == m.cueName)
+			expr := m.cue()
+			for i < len(name) {
+				name = name[i+1:]
+				if i = strings.IndexByte(name, '.'); i == -1 {
+					i = len(name)
+				}
+				expr = ast.NewSel(expr, "#"+name[:i])
+			}
+			ast.SetPos(expr, p.toCUEPos(pos))
+			return expr
 		}
 	}
 	failf(pos, "name %q not found", name)
-	return ""
+	return nil
 }
 
 func (p *protoConverter) doImport(v *proto.Import) error {
@@ -383,11 +327,6 @@
 		fail(v.Position, err)
 	}
 
-	prefix := ""
-	if imp.importPath() != p.importPath() {
-		prefix = imp.shortName() + "."
-	}
-
 	pkgNamespace := strings.Split(imp.protoPkg, ".")
 	curNamespace := strings.Split(p.protoPkg, ".")
 	for {
@@ -398,10 +337,23 @@
 			}
 			if _, ok := p.scope[0][ref]; !ok {
 				pkg := imp
-				if imp.importPath() == p.importPath() {
+				a := toCue(k)
+
+				var f func() ast.Expr
+
+				if imp.qualifiedImportPath() == p.qualifiedImportPath() {
 					pkg = nil
+					f = func() ast.Expr { return ast.NewIdent(a[0]) }
+				} else {
+					f = func() ast.Expr {
+						ident := &ast.Ident{
+							Name: imp.shortName(),
+							Node: ast.NewImport(nil, imp.qualifiedImportPath()),
+						}
+						return ast.NewSel(ident, a[0])
+					}
 				}
-				p.scope[0][ref] = mapping{prefix + k, prefix + toCue(k), "", pkg}
+				p.scope[0][ref] = mapping{f, pkg}
 			}
 		}
 		if len(pkgNamespace) == 0 {
@@ -417,12 +369,12 @@
 }
 
 // TODO: this doesn't work. Do something more principled.
-func toCue(name string) string {
+func toCue(name string) []string {
 	a := strings.Split(name, ".")
 	for i, s := range a {
 		a[i] = "#" + s
 	}
-	return strings.Join(a, ".")
+	return a
 }
 
 func (p *protoConverter) stringLit(pos scanner.Position, s string) *ast.BasicLit {
@@ -557,7 +509,7 @@
 		// All keys are converted to strings.
 		// TODO: support integer keys.
 		f.Label = ast.NewList(ast.NewIdent("string"))
-		f.Value = p.toExpr(x.Position, p.resolve(x.Position, x.Type, x.Options))
+		f.Value = p.resolve(x.Position, x.Type, x.Options)
 
 		name := p.ident(x.Position, x.Name)
 		f = &ast.Field{
@@ -746,14 +698,16 @@
 	name := p.ident(x.Position, x.Name)
 	f.Label = name
 	typ := p.resolve(x.Position, x.Type, x.Options)
-	f.Value = p.toExpr(x.Position, typ)
+	f.Value = typ
 	s.Elts = append(s.Elts, f)
 
 	o := optionParser{message: s, field: f}
 
 	// body of @protobuf tag: sequence[,type][,name=<name>][,...]
 	o.tags += fmt.Sprint(x.Sequence)
-	if x.Type != strings.TrimLeft(typ, "#") {
+	b, _ := format.Node(typ)
+	str := string(b)
+	if x.Type != strings.TrimLeft(str, "#") {
 		o.tags += ",type=" + x.Type
 	}
 	if x.Name != name.Name {
diff --git a/encoding/protobuf/protobuf.go b/encoding/protobuf/protobuf.go
index a138f67..848726d 100644
--- a/encoding/protobuf/protobuf.go
+++ b/encoding/protobuf/protobuf.go
@@ -272,11 +272,6 @@
 		}
 
 		inst.Files = append(inst.Files, f)
-		// inst.CUEFiles = append(inst.CUEFiles, f.Filename)
-		// err := parser.Resolve(f)
-		// if err != nil {
-		// 	return nil, err
-		// }
 
 		for pkg := range r.p.imported {
 			inst.ImportPaths = append(inst.ImportPaths, pkg)
@@ -311,7 +306,7 @@
 	if b.errs != nil {
 		return nil
 	}
-	importPath := p.importPath()
+	importPath := p.qualifiedImportPath()
 	if importPath == "" {
 		err := errors.Newf(token.NoPos,
 			"no package clause for proto package %q in file %s", p.id, p.file.Filename)
@@ -321,7 +316,7 @@
 	}
 
 	dir := b.root
-	path := importPath
+	path := p.importPath()
 	file := p.file.Filename
 	if !filepath.IsAbs(file) {
 		file = filepath.Join(b.root, p.file.Filename)
diff --git a/encoding/protobuf/testdata/attributes.proto.out.cue b/encoding/protobuf/testdata/attributes.proto.out.cue
index 1c3ff05..5ef33a6 100644
--- a/encoding/protobuf/testdata/attributes.proto.out.cue
+++ b/encoding/protobuf/testdata/attributes.proto.out.cue
@@ -14,9 +14,10 @@
 package v1
 
 import (
-	"googleapis.com/acme/test"
-	"googleapis.com/acme/test/test"
 	"time"
+	"googleapis.com/acme/test"
+	"googleapis.com/acme/test/test:test_test"
+	time_1 "time"
 )
 
 #StructWrap: {
@@ -127,17 +128,17 @@
 
 	// Holds attributes of type TIMESTAMP
 	time?: {
-		[string]: _time_.Time
+		[string]: time_1.Time
 	} @protobuf(6,type=map<sint32,google.protobuf.Timestamp>,"(gogoproto.nullable)=false","(gogoproto.stdtime)")
 
 	// Holds attributes of type DURATION
 	durations?: {
-		[string]: _time_.Duration
+		[string]: time_1.Duration
 	} @protobuf(7,type=map<sint32,google.protobuf.Duration>,"(gogoproto.nullable)=false","(gogoproto.stdduration)")
 
 	// Holds attributes of type BYTES
 	bytes?: {
-		[string]: _bytes_
+		[string]: bytes_5
 	} @protobuf(8,type=map<sint32,bytes>)
 
 	// Holds attributes of type STRING_MAP
@@ -145,8 +146,6 @@
 		[string]: #StringMap
 	} @protobuf(9,type=map<sint32,StringMap>,string_maps,"(gogoproto.nullable)=false")
 }
-let _time_ = time
-let _bytes_ = bytes
 
 // A map of string to string. The keys and values in this map are dictionary
 // indices (see the [Attributes][istio.mixer.v1.CompressedAttributes] message for an explanation)
@@ -156,3 +155,5 @@
 		[string]: int32
 	} @protobuf(1,type=map<sint32,sint32>)
 }
+
+let bytes_5 = bytes
diff --git a/encoding/protobuf/testdata/client_config.proto.out.cue b/encoding/protobuf/testdata/client_config.proto.out.cue
index 5bf1119..febae34 100644
--- a/encoding/protobuf/testdata/client_config.proto.out.cue
+++ b/encoding/protobuf/testdata/client_config.proto.out.cue
@@ -20,8 +20,8 @@
 package client
 
 import (
-	"istio.io/api/mixer/v1"
 	"time"
+	"istio.io/api/mixer/v1"
 )
 
 // Specifies the behavior when the client is unable to connect to Mixer.
diff --git a/encoding/protobuf/testdata/istio.io/api/mixer/v1/attributes_proto_gen.cue b/encoding/protobuf/testdata/istio.io/api/mixer/v1/attributes_proto_gen.cue
index 1c3ff05..5ef33a6 100644
--- a/encoding/protobuf/testdata/istio.io/api/mixer/v1/attributes_proto_gen.cue
+++ b/encoding/protobuf/testdata/istio.io/api/mixer/v1/attributes_proto_gen.cue
@@ -14,9 +14,10 @@
 package v1
 
 import (
-	"googleapis.com/acme/test"
-	"googleapis.com/acme/test/test"
 	"time"
+	"googleapis.com/acme/test"
+	"googleapis.com/acme/test/test:test_test"
+	time_1 "time"
 )
 
 #StructWrap: {
@@ -127,17 +128,17 @@
 
 	// Holds attributes of type TIMESTAMP
 	time?: {
-		[string]: _time_.Time
+		[string]: time_1.Time
 	} @protobuf(6,type=map<sint32,google.protobuf.Timestamp>,"(gogoproto.nullable)=false","(gogoproto.stdtime)")
 
 	// Holds attributes of type DURATION
 	durations?: {
-		[string]: _time_.Duration
+		[string]: time_1.Duration
 	} @protobuf(7,type=map<sint32,google.protobuf.Duration>,"(gogoproto.nullable)=false","(gogoproto.stdduration)")
 
 	// Holds attributes of type BYTES
 	bytes?: {
-		[string]: _bytes_
+		[string]: bytes_5
 	} @protobuf(8,type=map<sint32,bytes>)
 
 	// Holds attributes of type STRING_MAP
@@ -145,8 +146,6 @@
 		[string]: #StringMap
 	} @protobuf(9,type=map<sint32,StringMap>,string_maps,"(gogoproto.nullable)=false")
 }
-let _time_ = time
-let _bytes_ = bytes
 
 // A map of string to string. The keys and values in this map are dictionary
 // indices (see the [Attributes][istio.mixer.v1.CompressedAttributes] message for an explanation)
@@ -156,3 +155,5 @@
 		[string]: int32
 	} @protobuf(1,type=map<sint32,sint32>)
 }
+
+let bytes_5 = bytes
diff --git a/encoding/protobuf/testdata/istio.io/api/mixer/v1/config/client/client_config_proto_gen.cue b/encoding/protobuf/testdata/istio.io/api/mixer/v1/config/client/client_config_proto_gen.cue
index f032d06..626345a 100644
--- a/encoding/protobuf/testdata/istio.io/api/mixer/v1/config/client/client_config_proto_gen.cue
+++ b/encoding/protobuf/testdata/istio.io/api/mixer/v1/config/client/client_config_proto_gen.cue
@@ -20,8 +20,8 @@
 package client
 
 import (
-	"istio.io/api/mixer/v1"
 	"time"
+	"istio.io/api/mixer/v1"
 )
 
 // Specifies the behavior when the client is unable to connect to Mixer.
diff --git a/encoding/protobuf/testdata/istio.io/api/mixer/v1/mixer_proto_gen.cue b/encoding/protobuf/testdata/istio.io/api/mixer/v1/mixer_proto_gen.cue
index 59535a4..47e96b9 100644
--- a/encoding/protobuf/testdata/istio.io/api/mixer/v1/mixer_proto_gen.cue
+++ b/encoding/protobuf/testdata/istio.io/api/mixer/v1/mixer_proto_gen.cue
@@ -17,7 +17,7 @@
 package v1
 
 import (
-	"google.golang.org/genproto/googleapis/rpc/status"
+	status_1 "google.golang.org/genproto/googleapis/rpc/status"
 	"time"
 )
 
@@ -59,7 +59,7 @@
 	#PreconditionResult: {
 		// A status code of OK indicates all preconditions were satisfied. Any other code indicates not
 		// all preconditions were satisfied and details describe why.
-		status?: _status_.#Status @protobuf(1,type=google.rpc.Status,"(gogoproto.nullable)=false")
+		status?: status_1.#Status @protobuf(1,type=google.rpc.Status,"(gogoproto.nullable)=false")
 
 		// The amount of time for which this result can be considered valid.
 		validDuration?: time.Duration @protobuf(2,type=google.protobuf.Duration,name=valid_duration,"(gogoproto.nullable)=false","(gogoproto.stdduration)")
@@ -98,7 +98,6 @@
 		[string]: #QuotaResult
 	} @protobuf(3,type=map<string,QuotaResult>,"(gogoproto.nullable)=false")
 }
-let _status_ = status
 
 // Describes the attributes that were used to determine the response.
 // This can be used to construct a response cache.
diff --git a/encoding/protobuf/types.go b/encoding/protobuf/types.go
index 5628660..60b55af 100644
--- a/encoding/protobuf/types.go
+++ b/encoding/protobuf/types.go
@@ -15,14 +15,21 @@
 package protobuf
 
 import (
+	"fmt"
 	"text/scanner"
 
+	"cuelang.org/go/cue/ast"
+	"cuelang.org/go/cue/parser"
+	"cuelang.org/go/cue/token"
 	"github.com/emicklei/proto"
 )
 
-func protoToCUE(typ string, options []*proto.Option) (ref string, ok bool) {
+func protoToCUE(typ string, options []*proto.Option) ast.Expr {
 	t, ok := scalars[typ]
-	return t, ok
+	if !ok {
+		return nil
+	}
+	return predeclared(t)
 }
 
 var scalars = map[string]string{
@@ -48,13 +55,33 @@
 	"bytes":  "bytes",
 }
 
-func (p *protoConverter) setBuiltin(from, to string, pkg *protoConverter) {
-	p.scope[0][from] = mapping{to, to, "", pkg}
+func predeclared(s string) ast.Expr {
+	return &ast.Ident{
+		Name: s,
+		Node: ast.NewIdent("__" + s),
+	}
+}
+
+func (p *protoConverter) setBuiltin(from string, to func() ast.Expr, pkg *protoConverter) {
+	p.scope[0][from] = mapping{to, pkg}
+}
+
+func (p *protoConverter) setBuiltinParse(from, to string, pkg *protoConverter) {
+	f := func() ast.Expr {
+		expr, err := parser.ParseExpr("", to, parser.ParseComments)
+		if err != nil {
+			panic(fmt.Sprintf("error parsing name %q: %v", to, err))
+		}
+		return expr
+	}
+	p.scope[0][from] = mapping{f, pkg}
 }
 
 var (
-	pkgTime   = &protoConverter{cuePkgPath: "time"}
-	pkgStruct = &protoConverter{cuePkgPath: "struct"}
+	pkgTime      = &protoConverter{cuePkgPath: "time"}
+	pkgStruct    = &protoConverter{cuePkgPath: "struct"}
+	importTime   = ast.NewImport(nil, "time")
+	importStruct = ast.NewImport(nil, "struct")
 )
 
 func (p *protoConverter) mapBuiltinPackage(pos scanner.Position, file string, required bool) (generate bool) {
@@ -63,25 +90,61 @@
 	case "gogoproto/gogo.proto":
 
 	case "google/protobuf/struct.proto":
-		p.setBuiltin("google.protobuf.Struct", "{}", nil)
-		p.setBuiltin("google.protobuf.Value", "_", nil)
-		p.setBuiltin("google.protobuf.NullValue", "null", nil)
-		p.setBuiltin("google.protobuf.ListValue", "[...]", nil)
-		p.setBuiltin("google.protobuf.StringValue", "string", nil)
-		p.setBuiltin("google.protobuf.BoolValue", "bool", nil)
-		p.setBuiltin("google.protobuf.NumberValue", "number", nil)
+		p.setBuiltin("google.protobuf.Struct", func() ast.Expr {
+			return ast.NewStruct()
+		}, nil)
+
+		p.setBuiltin("google.protobuf.Value", func() ast.Expr {
+			return ast.NewIdent("_")
+		}, nil)
+
+		p.setBuiltin("google.protobuf.NullValue", func() ast.Expr {
+			return ast.NewLit(token.NULL, "null")
+		}, nil)
+
+		p.setBuiltin("google.protobuf.ListValue", func() ast.Expr {
+			return ast.NewList(&ast.Ellipsis{})
+		}, nil)
+
+		p.setBuiltin("google.protobuf.StringValue", func() ast.Expr {
+			return predeclared("string")
+		}, nil)
+
+		p.setBuiltin("google.protobuf.BoolValue", func() ast.Expr {
+			return predeclared("bool")
+		}, nil)
+
+		p.setBuiltin("google.protobuf.NumberValue", func() ast.Expr {
+			return predeclared("number")
+		}, nil)
+
 		return false
 
 	case "google/protobuf/empty.proto":
-		p.setBuiltin("google.protobuf.Empty", "struct.MaxFields(0)", pkgStruct)
+		f := func() ast.Expr {
+			time := &ast.Ident{Name: "struct", Node: importStruct}
+			return ast.NewCall(
+				ast.NewSel(time, "MaxFields"),
+				ast.NewLit(token.INT, "0"),
+			)
+		}
+		p.setBuiltin("google.protobuf.Empty", f, pkgStruct)
 		return false
 
 	case "google/protobuf/duration.proto":
-		p.setBuiltin("google.protobuf.Duration", "time.Duration", pkgTime)
+		f := func() ast.Expr {
+			time := &ast.Ident{Name: "time", Node: importTime}
+			return ast.NewSel(time, "Duration")
+		}
+		p.setBuiltin("google.protobuf.Duration", f, pkgTime)
 		return false
 
 	case "google/protobuf/timestamp.proto":
-		p.setBuiltin("google.protobuf.Timestamp", "time.Time", pkgTime)
+		f := func() ast.Expr {
+			time := &ast.Ident{Name: "time", Node: importTime}
+			return ast.NewSel(time, "Time")
+		}
+		p.setBuiltin("google.protobuf.Timestamp", f, pkgTime)
 		return false
 
 	case "google/protobuf/any.proto":
@@ -91,7 +154,7 @@
 		// be used here) are represented as strings.
 		//
 		// In Structural OpenAPI this type cannot be represented.
-		p.setBuiltin("google.protobuf.Any", `{
+		p.setBuiltinParse("google.protobuf.Any", `{
 	// A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `+
 			"`type.googleapis.com/google.protobuf.Duration`"+`). The name should be in a canonical form (e.g., leading "." is not accepted).
 	// The remaining fields of this object correspond to fields of the proto messsage. If the embedded message is well-known and has a custom JSON representation, that representation is assigned to the 'value' field.
@@ -100,15 +163,15 @@
 		return false
 
 	case "google/protobuf/wrappers.proto":
-		p.setBuiltin("google.protobuf.DoubleValue", `null | float`, nil)
-		p.setBuiltin("google.protobuf.FloatValue", `null | float`, nil)
-		p.setBuiltin("google.protobuf.Int64Value", `null | int64`, nil)
-		p.setBuiltin("google.protobuf.UInt64Value", `null | uint64`, nil)
-		p.setBuiltin("google.protobuf.Int32Value", `null | int32`, nil)
-		p.setBuiltin("google.protobuf.UInt32Value", `null | uint32`, nil)
-		p.setBuiltin("google.protobuf.BoolValue", `null | bool`, nil)
-		p.setBuiltin("google.protobuf.StringValue", `null | string`, nil)
-		p.setBuiltin("google.protobuf.BytesValue", `null | bytes`, nil)
+		p.setBuiltinParse("google.protobuf.DoubleValue", `null | float`, nil)
+		p.setBuiltinParse("google.protobuf.FloatValue", `null | float`, nil)
+		p.setBuiltinParse("google.protobuf.Int64Value", `null | int64`, nil)
+		p.setBuiltinParse("google.protobuf.UInt64Value", `null | uint64`, nil)
+		p.setBuiltinParse("google.protobuf.Int32Value", `null | int32`, nil)
+		p.setBuiltinParse("google.protobuf.UInt32Value", `null | uint32`, nil)
+		p.setBuiltinParse("google.protobuf.BoolValue", `null | bool`, nil)
+		p.setBuiltinParse("google.protobuf.StringValue", `null | string`, nil)
+		p.setBuiltinParse("google.protobuf.BytesValue", `null | bytes`, nil)
 		return false
 
 	// case "google/protobuf/field_mask.proto":
diff --git a/internal/internal.go b/internal/internal.go
index ffc8e66..87df900 100644
--- a/internal/internal.go
+++ b/internal/internal.go
@@ -100,6 +100,21 @@
 	return elts, e
 }
 
+func Imports(f *ast.File) (a []ast.Decl) {
+	for _, d := range f.Decls {
+		switch x := d.(type) {
+		case *ast.CommentGroup:
+		case *ast.Package:
+		case *ast.Attribute:
+		case *ast.ImportDecl:
+			a = append(a, x)
+		default:
+			return a
+		}
+	}
+	return a
+}
+
 func PackageInfo(f *ast.File) (p *ast.Package, name string, tok token.Pos) {
 	for _, d := range f.Decls {
 		switch x := d.(type) {