diff --git a/main.go b/main.go
index 85a75c8..a2a85d7 100644
--- a/main.go
+++ b/main.go
@@ -1169,14 +1169,15 @@ func (tf *transformer) transformGo(file *ast.File) *ast.File {
 		}
 		pkg := obj.Pkg()
 		if vr, ok := obj.(*types.Var); ok && vr.Embedded() {
+
 			// The docs for ObjectOf say:
 			//
 			//     If id is an embedded struct field, ObjectOf returns the
 			//     field (*Var) it defines, not the type (*TypeName) it uses.
 			//
 			// If this embedded field is a type alias, we want to
-			// handle that instead of treating it as the type the
-			// alias points to.
+			// handle the alias's TypeName instead of treating it as
+			// the type the alias points to.
 			//
 			// Alternatively, if we don't have an alias, we want to
 			// use the embedded type, not the field.
@@ -1190,7 +1191,24 @@ func (tf *transformer) transformGo(file *ast.File) *ast.File {
 				if named == nil {
 					return true // unnamed type (probably a basic type, e.g. int)
 				}
-				obj = named.Obj()
+				// If the field embeds an alias,
+				// and the field is declared in a dependency,
+				// fieldToAlias might not tell us about the alias.
+				// We lack the *ast.Ident for the field declaration,
+				// so we can't see it in types.Info.Uses.
+				//
+				// Instead, detect such a "foreign alias embed".
+				// If we embed a final named type,
+				// but the field name does not match its name,
+				// then it must have been done via an alias.
+				// We dig out the alias's TypeName via locateForeignAlias.
+				if named.Obj().Name() != node.Name {
+					tname := locateForeignAlias(vr.Pkg().Path(), node.Name)
+					tf.fieldToAlias[vr] = tname // to reuse it later
+					obj = tname
+				} else {
+					obj = named.Obj()
+				}
 			}
 			pkg = obj.Pkg()
 		}
@@ -1359,6 +1377,44 @@ func (tf *transformer) transformGo(file *ast.File) *ast.File {
 	return astutil.Apply(file, pre, post).(*ast.File)
 }
 
+// locateForeignAlias finds the TypeName for an alias by the name aliasName,
+// which must be declared in one of the dependencies of dependentImportPath.
+func locateForeignAlias(dependentImportPath, aliasName string) *types.TypeName {
+	var found *types.TypeName
+	lpkg, err := listPackage(dependentImportPath)
+	if err != nil {
+		panic(err) // shouldn't happen
+	}
+	for _, importedPath := range lpkg.Imports {
+		pkg2, err := origImporter.ImportFrom(importedPath, opts.GarbleDir, 0)
+		if err != nil {
+			panic(err)
+		}
+		tname, ok := pkg2.Scope().Lookup(aliasName).(*types.TypeName)
+		if ok && tname.IsAlias() {
+			if found != nil {
+				// We assume that the alias is declared exactly
+				// once in the set of direct imports.
+				// This might not be the case, e.g. if two
+				// imports declare the same alias name.
+				//
+				// TODO: Think how we could solve that
+				// efficiently, if it happens in practice.
+				panic(fmt.Sprintf("found multiple TypeNames for %s", aliasName))
+			}
+			found = tname
+		}
+	}
+	if found == nil {
+		// This should never happen.
+		// If package A embeds an alias declared in a dependency,
+		// it must show up in the form of "B.Alias",
+		// so A must import B and B must declare "Alias".
+		panic(fmt.Sprintf("could not find TypeName for %s", aliasName))
+	}
+	return found
+}
+
 // recordIgnore adds any named types (including fields) under typ to
 // ignoreObjects.
 //
diff --git a/shared.go b/shared.go
index ed082b1..d4f20f5 100644
--- a/shared.go
+++ b/shared.go
@@ -169,6 +169,7 @@ type listedPackage struct {
 
 	Dir     string
 	GoFiles []string
+	Imports []string
 
 	// The fields below are not part of 'go list', but are still reused
 	// between garble processes. Use "Garble" as a prefix to ensure no
diff --git a/testdata/scripts/syntax.txt b/testdata/scripts/syntax.txt
index 7e05811..c44f87a 100644
--- a/testdata/scripts/syntax.txt
+++ b/testdata/scripts/syntax.txt
@@ -100,6 +100,11 @@ func main() {
 	println(extra.Func())
 	sub.Test()
 	neverInlined()
+
+	_ = sub.EmbeddingExternalForeignAlias{
+		ExternalForeignAlias: nil,
+		Reader:       nil,
+	}
 }
 
 -- scopes.go --
@@ -135,7 +140,11 @@ func input(localNameParam string) (localNameReturn string) { return localNamePar
 -- sub/names.go --
 package sub
 
-import "io"
+import (
+	"io"
+
+	"test/main/external"
+)
 
 var someGlobalVar0 = "0"
 var someGlobalVar1 = "1"
@@ -184,6 +193,35 @@ var _ = embeddingForeignAlias{
 	Reader: nil,
 }
 
+// Similar to embeddingForeignAlias,
+// but the alias is declared in a dependency,
+// and this type is used in a dependent.
+type EmbeddingExternalForeignAlias struct {
+	external.ExternalForeignAlias
+	io.Reader
+}
+
+// Like the cases above,
+// but this time the alias doesn't rename its destination named type.
+// We can't tell this apart from "struct { io.Reader }" at the type info level.
+// It's fine to ignore the alias entirely, in this case.
+type embeddingAliasSameName struct {
+	external.Reader
+}
+
+var _ = embeddingAliasSameName{
+	Reader: nil,
+}
+
+-- external/external.go --
+package external
+
+import "io"
+
+type ExternalForeignAlias = io.Reader
+
+type Reader = io.Reader
+
 -- main.stderr --
 nil case
 1 1 1