// shortname+. is only for hosts in current namespace
		var altHosts sets.String
		if ni.Registry == string(provider.Kubernetes) {
			altHosts = generateAltHosts(hostname, ni, h.proxyNamespace, h.proxyDomain, h.proxyDomainParts)
		} else {
			if !strings.HasSuffix(hostname, ".") {
				hostname += "."
			}
			altHosts = sets.New(hostname)
		}
		ipv4, ipv6 := netutil.ParseIPsSplitToV4V6(ni.Ips)

	// Deprecated. Was added for experimentation only.
	//
	// Deprecated: Marked as deprecated in dns/proto/nds.proto.
	AltHosts []string `protobuf:"bytes,5,rep,name=alt_hosts,json=altHosts,proto3" json:"alt_hosts,omitempty"`
}

func (x *NameTable_NameInfo) Reset() {
	*x = NameTable_NameInfo{}
	if protoimpl.UnsafeEnabled {
		mi := &file_dns_proto_nds_proto_msgTypes[1]

	for _, a := range service.Attributes.Aliases {
		all = append(all, a.Hostname.String())
	}
	for _, s := range all {
		altHosts := GenerateAltVirtualHosts(s, port, node.DNSDomain)
		domains = appendDomainPort(domains, s, port)
		domains = append(domains, altHosts...)
		allAltHosts = append(allAltHosts, altHosts...)
	}

	if service.Resolution == model.Passthrough &&
		service.Attributes.ServiceRegistry == provider.Kubernetes {

			expected:   sets.New("example.localhost."),
		},
	}

	nt := d.NameTable()
	nt = proto.Clone(nt).(*dnsProto.NameTable)
	d.BuildAlternateHosts(nt, func(althosts map[string]struct{}, ipv4 []netip.Addr, ipv6 []netip.Addr, _ []string) {
		for host := range althosts {
			if _, exists := nt.Table[host]; !exists {
				addresses := make([]string, 0, len(ipv4)+len(ipv6))
				for _, addr := range ipv4 {

		nt := a.localDNSServer.NameTable()
		nt = proto.Clone(nt).(*dnsProto.NameTable)
		a.localDNSServer.BuildAlternateHosts(nt, func(althosts map[string]struct{}, ipv4 []netip.Addr, ipv6 []netip.Addr, _ []string) {
			for host := range althosts {
				if _, exists := nt.Table[host]; !exists {
					addresses := make([]string, 0, len(ipv4)+len(ipv6))
					for _, addr := range ipv4 {

		}

		// exact hosts are saved separately for map lookup
		if !hName.IsWildCarded() {
			hostsByNamespace[ns].exactHosts.Insert(hName)
		}

		// allHosts contains the exact hosts and wildcard hosts,
		// since SelectVirtualServices will use `Matches` semantic matching.
		hc := hostsByNamespace[ns]
		hc.allHosts = append(hc.allHosts, hName)

        // The k8s namespace for the service. Only applies when registry=`Kubernetes`
        string namespace = 4;

        // Deprecated. Was added for experimentation only.
        repeated string alt_hosts = 5 [deprecated = true];
    }

    // Map of hostname to resolution attributes.
    map<string, NameInfo> table = 1;

			},
			services:  []*Service{serviceA8000},
			expected:  []*Service{serviceA8000},
			namespace: "a",
		},
		{
			name: "fall back to wildcard namespace",
			listenerHosts: map[string]hostClassification{
				wildcardNamespace: {allHosts: []host.Name{"host"}, exactHosts: sets.New[host.Name]("host")},

		ns := svc.Attributes.Namespace
		if _, exists := hostsByNamespace[ns]; !exists {
			hostsByNamespace[ns] = hostClassification{exactHosts: sets.New[host.Name](), allHosts: make([]host.Name, 0)}
		}

		hc := hostsByNamespace[ns]
		hc.allHosts = append(hc.allHosts, svc.Hostname)
		hostsByNamespace[ns] = hc

		if !svc.Hostname.IsWildCarded() {
			hostsByNamespace[ns].exactHosts.Insert(svc.Hostname)
		}
	}