@@ -19691,9 +19691,7 @@ func (c *Checker) resolveObjectTypeMember(resolution *objectMemberResolution, na
 		if resolution.mapper == nil || c.isNamedMember(symbol, name) {
 			result = symbol
 			if instantiate && resolution.mapper != nil {
-				if _, unaffected := slices.BinarySearch(resolution.unaffected, name); !unaffected {
-					result = c.newInstantiatedSymbol(symbol, resolution.mapper)
-				}
+				result = c.instantiateObjectTypeMember(resolution, name, symbol)
 			}
 		}
 	}
@@ -19732,6 +19730,15 @@ func (c *Checker) resolveObjectTypeMember(resolution *objectMemberResolution, na
 	return result
 }
 
+func (c *Checker) instantiateObjectTypeMember(resolution *objectMemberResolution, name string, symbol *ast.Symbol) *ast.Symbol {
+	if resolution.mapper != nil {
+		if _, unaffected := slices.BinarySearch(resolution.unaffected, name); !unaffected {
+			return c.newInstantiatedSymbol(symbol, resolution.mapper)
+		}
+	}
+	return symbol
+}
+
 func (c *Checker) everyObjectTypeMemberName(resolution *objectMemberResolution, f func(string) bool) bool {
 	var seen collections.Set[*objectMemberResolution]
 	return c.everyObjectTypeMemberNameWorker(resolution, &seen, f)
@@ -19764,18 +19771,62 @@ func (c *Checker) everyObjectTypeMemberNameWorker(resolution *objectMemberResolu
 }
 
 func (c *Checker) resolveObjectTypeProperties(t *Type, resolution *objectMemberResolution) {
+	if resolution.mapper != nil && len(resolution.baseTypes) == 0 && !resolution.fullOnly {
+		// Canonical declared properties need no temporary name table. Retain any
+		// symbols already returned by selective lookups.
+		properties := c.getNamedMembers(resolution.source.declaredMembers, t.symbol)
+		count := 0
+		for _, symbol := range properties {
+			name := symbol.Name()
+			member, cached := resolution.members[name]
+			if !cached {
+				member = c.instantiateObjectTypeMember(resolution, name, symbol)
+			}
+			if member != nil {
+				properties[count] = member
+				count++
+			}
+		}
+		data := t.AsStructuredType()
+		data.properties = properties[:count]
+		data.members = c.newPropertyIndex(data.properties, nil)
+		t.objectFlags |= ObjectFlagsMembersResolved
+		delete(c.objectMemberResolutions, t)
+		return
+	}
 	if resolution.mapper == nil && len(resolution.baseTypes) == 0 {
 		resolution.members = resolution.source.declaredMembers
 	} else {
 		if resolution.members == nil {
 			resolution.members = make(ast.SymbolTable, len(resolution.source.declaredMembers))
 		}
-		for name := range resolution.source.declaredMembers {
-			c.resolveObjectTypeMember(resolution, name, true /*instantiate*/)
+		for name, symbol := range resolution.source.declaredMembers {
+			if _, cached := resolution.members[name]; cached {
+				continue
+			}
+			if symbol.Flags()&ast.SymbolFlagsValue != 0 && (resolution.mapper == nil || !isReservedMemberName(name)) {
+				resolution.members[name] = c.instantiateObjectTypeMember(resolution, name, symbol)
+			} else {
+				c.resolveObjectTypeMember(resolution, name, true /*instantiate*/)
+			}
 		}
 		for _, baseType := range resolution.baseTypes {
-			for _, property := range c.getPropertiesOfType(baseType) {
-				c.resolveObjectTypeMember(resolution, property.Name(), true /*instantiate*/)
+			properties := c.getPropertiesOfType(baseType)
+			base := c.getReducedApparentType(baseType)
+			canonical := base.flags&TypeFlagsObject != 0 && base.objectFlags&ObjectFlagsMembersResolved != 0 &&
+				(base.AsStructuredType().members == nil || base.AsStructuredType().members.fallback == nil)
+			for _, property := range properties {
+				name := property.Name()
+				if _, cached := resolution.members[name]; cached {
+					continue
+				}
+				// Enumeration already supplies the first inherited value. Reuse
+				// it instead of looking the name up through every base again.
+				if canonical && property.Flags()&ast.SymbolFlagsValue != 0 && !isStaticPrivateIdentifierProperty(property) {
+					resolution.members[name] = property
+				} else {
+					c.resolveObjectTypeMember(resolution, name, true /*instantiate*/)
+				}
 			}
 		}
 	}
 
@@ -253,6 +253,64 @@ instance;`,
 	assert.Assert(t, c.GetPropertyOfType(typ, "different") == nil)
 }
 
+func TestInstantiatedMemberEnumeration(t *testing.T) {
+	t.Parallel()
+	var source strings.Builder
+	source.WriteString("interface Base<T> { shared: T; ")
+	for i := range 64 {
+		fmt.Fprintf(&source, "p%d: T; ", i)
+	}
+	source.WriteString("}\ninterface First<T> extends Base<T> { first: T }\n")
+	source.WriteString("interface Second<T> { shared: T; second: T }\n")
+	source.WriteString("interface Derived<T> extends First<T>, Second<T> { own: T }\n")
+	for _, test := range []struct {
+		name     string
+		typeName string
+		count    int
+		first    string
+		partial  bool
+	}{
+		{name: "declared", typeName: "Base", count: 65, first: "shared"},
+		{name: "declaredCached", typeName: "Base", count: 65, first: "shared", partial: true},
+		{name: "inherited", typeName: "Derived", count: 68, first: "own"},
+		{name: "inheritedCached", typeName: "Derived", count: 68, first: "own", partial: true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			fs := bundled.WrapFS(vfstest.FromMap(map[string]string{
+				"/main.ts":       source.String() + fmt.Sprintf("declare const instance: %s<string>;\ninstance;", test.typeName),
+				"/tsconfig.json": `{"compilerOptions":{"strict":true},"files":["main.ts"]}`,
+			}, tspath.CaseInsensitive))
+			host := compiler.NewCompilerHost(fs, bundled.LibPath(), nil, nil, nil)
+			parsed, errors := tsoptions.GetParsedCommandLineOfConfigFile("/tsconfig.json", &core.CompilerOptions{}, nil, fs, nil)
+			assert.Equal(t, len(errors), 0)
+			program := compiler.NewProgram(compiler.ProgramOptions{Config: parsed, Host: host})
+			program.BindSourceFiles()
+			c, done := program.GetTypeChecker(t.Context())
+			defer done()
+			file := program.GetSourceFile("/main.ts")
+			typ := c.GetTypeAtLocation(file.Statements.Nodes[5].Expression())
+			cached := make(map[string]*ast.Symbol)
+			if test.partial {
+				for _, name := range []string{"p63", "shared", "second", "missing"} {
+					cached[name] = c.GetPropertyOfType(typ, name)
+				}
+			}
+			properties := c.GetPropertiesOfType(typ)
+			assert.Equal(t, len(properties), test.count)
+			assert.Equal(t, properties[0].Name(), test.first)
+			for _, property := range properties {
+				assert.Equal(t, c.GetPropertyOfType(typ, property.Name()), property)
+				assert.Equal(t, c.TypeToString(c.GetTypeOfSymbol(property)), "string")
+			}
+			for name, symbol := range cached {
+				assert.Equal(t, c.GetPropertyOfType(typ, name), symbol)
+			}
+			assert.Equal(t, len(c.GetDiagnostics(t.Context(), file)), 0)
+		})
+	}
+}
+
 func TestInstantiatedDiamondMissingMember(t *testing.T) {
 	t.Parallel()
 	var source strings.Builder